@liquiditytech/rapidx-cli 1.0.31 → 1.0.33

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,
@@ -279,7 +305,7 @@ export function inputSchemaForName(name) {
         case "InvocationCheckInput":
             return objectSchema({ commandLine: stringSchema, preflightError: stringSchema });
         case "UpdateCheckInput":
-            return objectSchema({ force: booleanSchema, manifestUrl: stringSchema, maxCacheAgeSeconds: numberSchema });
+            return objectSchema({ force: booleanSchema, manifestUrl: stringSchema, maxCacheAgeSeconds: numberSchema, installedSkillsVersion: stringSchema });
         case "SchemaQuery":
             return objectSchema({ consumer: stringSchema, consumerVersion: stringSchema, includeExamples: booleanSchema });
         case "SelfCheckInput":

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

@@ -13,11 +13,14 @@ export async function checkForUpdate(input = {}, env = process.env, cwd = proces
     const cacheFile = resolveUpdateCacheFile(env, cwd);
     const cached = loadCachedUpdateState(cacheFile);
     if (!input.force && cached && !isCacheExpired(cached, cacheTtlSeconds)) {
-        return {
-            ...cached.result,
+        const manifest = cached.manifest ?? manifestFromCachedResult(cached.result);
+        return buildUpdateCheckResult(manifest, {
+            checkedAt: cached.checkedAt,
+            cacheTtlSeconds,
+            manifestUrl,
             manifestSource: "cache",
-            cacheTtlSeconds
-        };
+            installedSkillsVersion: input.installedSkillsVersion
+        });
     }
     try {
         const manifest = await fetchReleaseManifest(manifestUrl);
@@ -25,29 +28,35 @@ export async function checkForUpdate(input = {}, env = process.env, cwd = proces
             checkedAt: new Date().toISOString(),
             cacheTtlSeconds,
             manifestUrl,
-            manifestSource: "remote"
+            manifestSource: "remote",
+            installedSkillsVersion: input.installedSkillsVersion
         });
         saveCachedUpdateState(cacheFile, {
             checkedAt: result.checkedAt,
             cacheTtlSeconds,
+            manifest,
             result
         });
         return result;
     }
     catch (error) {
         if (cached) {
-            return {
-                ...cached.result,
-                manifestSource: "cache",
+            const manifest = cached.manifest ?? manifestFromCachedResult(cached.result);
+            return buildUpdateCheckResult(manifest, {
+                checkedAt: cached.checkedAt,
                 cacheTtlSeconds,
+                manifestUrl,
+                manifestSource: "cache",
+                installedSkillsVersion: input.installedSkillsVersion,
                 error: error instanceof Error ? error.message : String(error)
-            };
+            });
         }
         return buildUnknownUpdateCheckResult({
             checkedAt: new Date().toISOString(),
             cacheTtlSeconds,
             manifestUrl,
             manifestSource: "fallback",
+            installedSkillsVersion: input.installedSkillsVersion,
             error: error instanceof Error ? error.message : String(error)
         });
     }
@@ -62,6 +71,11 @@ export function buildUpdateCheckResult(manifest, metadata) {
         minimumWriteVersion
     });
     const writeAllowed = status !== "WRITE_BLOCKED";
+    const installedSkillsVersion = normalizeInstalledSkillsVersion(metadata.installedSkillsVersion);
+    const skillsInstallStatus = computeSkillsInstallStatus(installedSkillsVersion, manifest.skillsVersion);
+    const skillsUpdateRecommended = manifest.skillsUpdateRecommended
+        || skillsInstallStatus === "UPDATE_AVAILABLE"
+        || (skillsInstallStatus === "NOT_VERIFIED" && compareVersions(RAPIDX_SKILLS_VERSION, manifest.skillsVersion) < 0);
     return {
         currentVersion: RAPIDX_VERSION,
         latestVersion: manifest.latestCliVersion,
@@ -71,6 +85,10 @@ export function buildUpdateCheckResult(manifest, metadata) {
         currentMcpSchemaVersion: SCHEMA_VERSION,
         skillsVersion: manifest.skillsVersion,
         currentSkillsVersion: RAPIDX_SKILLS_VERSION,
+        latestSkillsVersion: manifest.skillsVersion,
+        bundledExpectedSkillsVersion: RAPIDX_SKILLS_VERSION,
+        installedSkillsVersion,
+        skillsInstallStatus,
         skillsSchemaVersion: manifest.skillsSchemaVersion,
         currentSkillsSchemaVersion: RAPIDX_SKILLS_SCHEMA_VERSION,
         updateAvailable: compareVersions(RAPIDX_VERSION, manifest.latestCliVersion) < 0,
@@ -82,9 +100,12 @@ export function buildUpdateCheckResult(manifest, metadata) {
         cacheTtlSeconds: metadata.cacheTtlSeconds,
         manifestUrl: metadata.manifestUrl,
         manifestSource: metadata.manifestSource,
+        updateFreshness: freshnessForSource(metadata.manifestSource),
+        refreshCommand: "rapidx update check --input '{\"force\":true}' --json",
         releaseNotesUrl: manifest.releaseNotesUrl,
-        skillsUpdateRecommended: manifest.skillsUpdateRecommended || compareVersions(RAPIDX_SKILLS_VERSION, manifest.skillsVersion) < 0,
+        skillsUpdateRecommended,
         upgrade: manifest.upgrade,
+        ...(metadata.manifestSource === "cache" ? { cacheWarning: "Result came from local cache. Use force=true to refresh the remote release manifest." } : {}),
         ...(metadata.error ? { error: metadata.error } : {})
     };
 }
@@ -160,6 +181,8 @@ function fallbackManifest() {
 }
 function buildUnknownUpdateCheckResult(metadata) {
     const manifest = fallbackManifest();
+    const installedSkillsVersion = normalizeInstalledSkillsVersion(metadata.installedSkillsVersion);
+    const skillsInstallStatus = computeSkillsInstallStatus(installedSkillsVersion, manifest.skillsVersion);
     return {
         currentVersion: RAPIDX_VERSION,
         latestVersion: RAPIDX_VERSION,
@@ -169,6 +192,10 @@ function buildUnknownUpdateCheckResult(metadata) {
         currentMcpSchemaVersion: SCHEMA_VERSION,
         skillsVersion: manifest.skillsVersion,
         currentSkillsVersion: RAPIDX_SKILLS_VERSION,
+        latestSkillsVersion: manifest.skillsVersion,
+        bundledExpectedSkillsVersion: RAPIDX_SKILLS_VERSION,
+        installedSkillsVersion,
+        skillsInstallStatus,
         skillsSchemaVersion: manifest.skillsSchemaVersion,
         currentSkillsSchemaVersion: RAPIDX_SKILLS_SCHEMA_VERSION,
         updateAvailable: false,
@@ -180,6 +207,8 @@ function buildUnknownUpdateCheckResult(metadata) {
         cacheTtlSeconds: metadata.cacheTtlSeconds,
         manifestUrl: metadata.manifestUrl,
         manifestSource: metadata.manifestSource,
+        updateFreshness: freshnessForSource(metadata.manifestSource),
+        refreshCommand: "rapidx update check --input '{\"force\":true}' --json",
         releaseNotesUrl: "",
         skillsUpdateRecommended: false,
         upgrade: {},
@@ -198,6 +227,41 @@ function computeUpdateStatus(input) {
     }
     return "CURRENT";
 }
+function computeSkillsInstallStatus(installedSkillsVersion, latestSkillsVersion) {
+    if (installedSkillsVersion === "NOT_VERIFIED") {
+        return "NOT_VERIFIED";
+    }
+    return compareVersions(installedSkillsVersion, latestSkillsVersion) < 0 ? "UPDATE_AVAILABLE" : "CURRENT";
+}
+function normalizeInstalledSkillsVersion(value) {
+    return typeof value === "string" && isSemver(value) ? value : "NOT_VERIFIED";
+}
+function freshnessForSource(source) {
+    if (source === "remote") {
+        return "REMOTE";
+    }
+    if (source === "cache") {
+        return "CACHE";
+    }
+    return "FALLBACK";
+}
+function manifestFromCachedResult(result) {
+    return {
+        product: "rapidx",
+        channel: "stable",
+        latestCliVersion: result.latestVersion,
+        minimumSupportedVersion: result.minimumSupportedVersion,
+        minimumWriteVersion: result.minimumWriteVersion,
+        latestMcpSchemaVersion: result.latestMcpSchemaVersion,
+        skillsVersion: result.skillsVersion,
+        skillsSchemaVersion: result.skillsSchemaVersion,
+        skillsUpdateRecommended: result.skillsUpdateRecommended,
+        severity: result.severity,
+        breaking: result.breaking,
+        releaseNotesUrl: result.releaseNotesUrl,
+        upgrade: result.upgrade
+    };
+}
 function compareVersions(left, right) {
     const a = parseVersion(left);
     const b = parseVersion(right);
@@ -220,6 +284,9 @@ function parseVersion(version) {
     }
     return [Number(match[1]), Number(match[2]), Number(match[3])];
 }
+function isSemver(version) {
+    return /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.test(version);
+}
 function assertSemver(version, field) {
     try {
         parseVersion(version);

package/dist/core/version.js

@@ -1 +1 @@
-export const RAPIDX_VERSION = "1.0.31";
+export const RAPIDX_VERSION = "1.0.33";

package/dist/mcp/tool-runner.js

@@ -40,6 +40,9 @@ export async function runMcpTool(toolName, input = {}) {
             if (typeof input.maxCacheAgeSeconds === "number") {
                 updateInput.maxCacheAgeSeconds = input.maxCacheAgeSeconds;
             }
+            if (typeof input.installedSkillsVersion === "string") {
+                updateInput.installedSkillsVersion = input.installedSkillsVersion;
+            }
             const update = await checkForUpdate(updateInput);
             const status = envelopeStatusForUpdate(update.status);
             const auditId = writeMcpAudit("update-check", status, { toolName, updateStatus: update.status });
@@ -136,8 +139,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.31",
+  "version": "1.0.33",
   "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,53 @@ 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.
 
+When checking an existing installation, read the installed RapidX skill `version` from the loaded `SKILL.md` frontmatter and pass it to update check:
+
+```bash
+rapidx update check --input '{"installedSkillsVersion":"1.0.8"}' --json
+```
+
+For upgrade reviews, force a remote manifest refresh:
+
+```bash
+rapidx update check --input '{"installedSkillsVersion":"1.0.8","force":true}' --json
+```
+
+Update output fields:
+
+- `latestVersion`: latest CLI version from the release manifest.
+- `currentVersion`: running CLI version.
+- `latestSkillsVersion` / `skillsVersion`: latest RapidX skills version from the release manifest.
+- `bundledExpectedSkillsVersion` / `currentSkillsVersion`: skills version expected by this CLI build, not proof of locally installed skills.
+- `installedSkillsVersion`: local skill version supplied by the caller, or `NOT_VERIFIED`.
+- `skillsInstallStatus`: `CURRENT`, `UPDATE_AVAILABLE`, or `NOT_VERIFIED`.
+- `manifestSource`: `remote`, `cache`, or `fallback`.
+- `updateFreshness`: `REMOTE`, `CACHE`, or `FALLBACK`.
+- `cacheWarning`: present when the result came from local cache.
+- `refreshCommand`: command for forcing a remote manifest refresh.
+
 `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.