@liquiditytech/rapidx-cli 1.0.32 → 1.0.34

package/dist/cli/commands/algo.js

@@ -7,6 +7,7 @@ const ALGO_CAPABILITY_BY_ACTION = {
     replace: "algo.replace",
     cancel: "algo.cancel",
     "open-orders": "algo.open-orders",
+    history: "algo.history",
     query: "algo.query"
 };
 export async function runAlgoCommand(action, input) {

package/dist/cli/commands/index.js

@@ -11,6 +11,7 @@ import { runPositionCommand } from "./position.js";
 import { runSchemaCommand } from "./schema.js";
 import { runSelfCheckCommand, runTradingVerificationCommand } from "./self-check.js";
 import { runTradeCommand } from "./trade.js";
+import { runTransactionCommand } from "./transaction.js";
 import { runUpdateCommand } from "./update.js";
 export async function dispatchCli(parsed) {
     const [domain, action, subAction] = parsed.commandParts;
@@ -63,6 +64,9 @@ export async function dispatchCli(parsed) {
     if (domain === "trade") {
         return runTradeCommand(action ?? "preview", parsed.input);
     }
+    if (domain === "transaction") {
+        return runTransactionCommand(action ?? "executions", parsed.input);
+    }
     if (domain === "position") {
         return runPositionCommand(action ?? "query", parsed.input);
     }

package/dist/cli/commands/order.js

@@ -5,10 +5,10 @@ const safetyState = makeSafetyState();
 export async function runOrderCommand(action, input) {
     const previewStoreFile = resolvePreviewStoreFile();
     const previewStore = loadPreviewStoreFromFile(previewStoreFile);
-    if (action === "preview" || action === "place-preview") {
-        const capability = findCapabilityById("order.preview");
+    if (action === "place-preview") {
+        const capability = findCapabilityById("order.place-preview");
         if (!capability) {
-            return fail("RCLI30001", "order.preview capability missing.");
+            return fail("RCLI30001", "order.place-preview capability missing.");
         }
         try {
             const preview = createTradePreview(capability, input, { ...defaultSafetyPolicy(), tradingEnabled: true, readOnly: false }, safetyState, previewStore);

package/dist/cli/commands/transaction.js

@@ -0,0 +1,23 @@
+import { executeRapidXCapability, findCapabilityById, normalizeUnknownError, publicErrorDetails } from "../../core/index.js";
+import { fail, ok } from "../envelope.js";
+const TRANSACTION_CAPABILITY_BY_ACTION = {
+    executions: "transaction.executions"
+};
+export async function runTransactionCommand(action, input) {
+    const capabilityId = TRANSACTION_CAPABILITY_BY_ACTION[action];
+    if (!capabilityId) {
+        return fail("RCLI12001", `Unknown transaction command: ${action}`, "FAIL", `rapidx transaction ${action}`);
+    }
+    const capability = findCapabilityById(capabilityId);
+    if (!capability) {
+        return fail("RCLI30002", `Missing capability: ${capabilityId}`, "FAIL", `rapidx transaction ${action}`);
+    }
+    try {
+        const data = await executeRapidXCapability(capabilityId, input);
+        return ok(data, `rapidx transaction ${action}`, "PASS", "real_tool_call");
+    }
+    catch (error) {
+        const productError = normalizeUnknownError(error, "RCLI12001");
+        return fail(productError.code.replace(/^RCORE/, "RCLI"), productError.message, productError.status, `rapidx transaction ${action}`, publicErrorDetails(productError));
+    }
+}

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

@@ -11,14 +11,14 @@ export function formatCliHelp() {
         "  rapidx self-check --input '{\"scope\":\"deep\"}' --json",
         "  rapidx market get-ticker --input '{\"symbol\":\"BINANCE_PERP_BTC_USDT\"}' --json",
         "  rapidx market get-ticker --symbol BINANCE_PERP_BTC_USDT --json",
-        "  rapidx order preview --input '{\"symbol\":\"BINANCE_PERP_BTC_USDT\",\"side\":\"BUY\",\"orderType\":\"LIMIT\",\"price\":\"1\",\"quantity\":\"0.001\",\"maxNotional\":\"1\",\"clientOrderId\":\"example\"}' --json",
+        "  rapidx order place-preview --input '{\"symbol\":\"BINANCE_PERP_BTC_USDT\",\"side\":\"BUY\",\"orderType\":\"LIMIT\",\"price\":\"1\",\"quantity\":\"0.001\",\"maxNotional\":\"1\",\"clientOrderId\":\"example\"}' --json",
         "  rapidx order cancel-preview --input '{\"orderId\":\"<order-id>\"}' --json",
         "  rapidx trade verify-live --input '{\"symbol\":\"BINANCE_PERP_BTC_USDT\",\"side\":\"BUY\",\"maxNotional\":\"10\",\"clientOrderId\":\"verify-001\",\"explicitUserConsent\":true,\"acceptedRiskText\":\"I authorize a real verification order for BINANCE_PERP_BTC_USDT BUY maxNotional 10 with cancel cleanup.\"}' --json",
         "  rapidx mcp serve",
         "",
         "Domains:",
         "  schema, doctor, auth, config, update, self-check, invocation",
-        "  market, portfolio, order, trade, position, algo",
+        "  market, portfolio, order, transaction, 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

@@ -47,8 +47,8 @@ export async function executeRapidXCapability(capabilityId, input = {}, options
         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", orderListParams(input, "100"));
-        case "order.executions":
+            return client.get("/api/v1/trading/history/orders", orderHistoryParams(input));
+        case "transaction.executions":
             return client.get("/api/v1/trading/executions", executionParams(input));
         case "position.query":
             return executePositionListCapability(client, input);
@@ -76,6 +76,8 @@ export async function executeRapidXCapability(capabilityId, input = {}, options
             return client.delete("/api/v1/algo/order", optionalParams(input, ["algoOrderId", "clientOrderId"]));
         case "algo.open-orders":
             return client.get("/api/v1/algo/openOrders", algoListParams(input));
+        case "algo.history":
+            return client.get("/api/v1/algo/history/orders", algoHistoryParams(input));
         case "algo.query":
             return client.get("/api/v1/algo/order", optionalParams(input, ["algoOrderId", "clientOrderId", "attachedOrderId"]));
         default:
@@ -321,14 +323,28 @@ function orderListParams(input, defaultPageSize) {
         ])
     };
 }
+function orderHistoryParams(input) {
+    return {
+        pageSize: stringValue(input.pageSize, "1000"),
+        ...mappedOptionalParams(input, [
+            ["symbol", "sym"],
+            ["exchange", "exchange"],
+            ["businessType", "businessType"],
+            ["begin", "begin"],
+            ["end", "end"],
+            ["page", "page"],
+            ["filterExecuted", "filterExecuted"]
+        ])
+    };
+}
 function executionParams(input) {
     return mappedOptionalParams(input, [
         ["orderId", "orderId"],
         ["symbol", "sym"],
         ["exchange", "exchange"],
         ["businessType", "businessType"],
-        ["startTime", "begin"],
-        ["endTime", "end"],
+        ["begin", "begin"],
+        ["end", "end"],
         ["limit", "limit"]
     ]);
 }
@@ -404,6 +420,18 @@ function algoListParams(input) {
         ["pageSize", "pageSize"]
     ]);
 }
+function algoHistoryParams(input) {
+    return mappedOptionalParams(input, [
+        ["symbol", "sym"],
+        ["exchange", "exchange"],
+        ["businessType", "businessType"],
+        ["algoOrderType", "algoOrderType"],
+        ["begin", "begin"],
+        ["end", "end"],
+        ["page", "page"],
+        ["pageSize", "pageSize"]
+    ]);
+}
 function positionHistoryParams(input) {
     const params = mappedOptionalParams(input, [
         ["startTime", "begin"],

package/dist/core/contracts/capabilities.js

@@ -24,7 +24,6 @@ export const CAPABILITIES = [
     { 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.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 },
@@ -35,7 +34,7 @@ export const CAPABILITIES = [
     { 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: "order.executions", cliCommand: "rapidx order executions", mcpTool: "rapidx/order/executions", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "ExecutionListInput", outputSchema: "ExecutionList", previewRequired: false },
+    { capabilityId: "transaction.executions", cliCommand: "rapidx transaction executions", mcpTool: "rapidx/transaction/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 },
@@ -46,6 +45,7 @@ export const CAPABILITIES = [
     { 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.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.history", cliCommand: "rapidx algo history", mcpTool: "rapidx/algo/history", operationType: "TRADE_READ", riskLevel: "trade-read", inputSchema: "AlgoHistoryInput", outputSchema: "AlgoHistory", 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" },

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

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

@@ -92,11 +92,14 @@ const exchangeTypeSchema = { type: "string", description: "RapidX exchange type,
 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 startTimeSchema = { type: "string", description: "Optional time range start timestamp accepted by the RapidX API. If omitted, the upstream server default range applies." };
+const endTimeSchema = { type: "string", description: "Optional time range end timestamp accepted by the RapidX API. If omitted, the upstream server default range applies." };
+const beginSchema = { type: "string", description: "Official RapidX begin timestamp in milliseconds for the query window. If omitted, RapidX defaults to up to 7 days ago." };
+const endSchema = { type: "string", description: "Official RapidX end timestamp in milliseconds for the query window. If omitted, RapidX uses the current time." };
 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 algoOrderTypeSchema = { type: "string", description: "RapidX algo order type filter." };
 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 = {
@@ -135,15 +138,18 @@ export function inputSchemaForName(name) {
                 anyOf: [{ required: ["orderId"] }, { required: ["clientOrderId"] }]
             };
         case "OrderListInput":
-        case "OrderHistoryInput":
             return objectSchema({ symbol: symbolSchema, exchange: stringSchema, businessType: businessTypeSchema, page: pageSchema, pageSize: pageSizeSchema, startTime: startTimeSchema, endTime: endTimeSchema, filterExecuted: filterExecutedSchema });
+        case "OrderHistoryInput":
+            return objectSchema({ symbol: symbolSchema, exchange: stringSchema, businessType: businessTypeSchema, page: pageSchema, pageSize: pageSizeSchema, begin: beginSchema, end: endSchema, filterExecuted: filterExecutedSchema });
         case "ExecutionListInput":
-            return objectSchema({ orderId: orderIdSchema, symbol: symbolSchema, exchange: stringSchema, businessType: businessTypeSchema, limit: numberSchema, startTime: startTimeSchema, endTime: endTimeSchema });
+            return objectSchema({ orderId: orderIdSchema, symbol: symbolSchema, exchange: stringSchema, businessType: businessTypeSchema, limit: numberSchema, begin: beginSchema, end: endSchema });
         case "StatementInput":
             return objectSchema({ coin: coinSchema, symbol: symbolSchema, statementType: statementTypeSchema, exchange: stringSchema, page: pageSchema, pageSize: pageSizeSchema, startTime: startTimeSchema, endTime: endTimeSchema });
-        case "PositionListInput":
         case "AlgoListInput":
+        case "PositionListInput":
             return objectSchema({ symbol: symbolSchema, exchange: stringSchema, businessType: businessTypeSchema, page: pageSchema, pageSize: pageSizeSchema, startTime: startTimeSchema, endTime: endTimeSchema });
+        case "AlgoHistoryInput":
+            return objectSchema({ symbol: symbolSchema, exchange: stringSchema, businessType: businessTypeSchema, algoOrderType: algoOrderTypeSchema, begin: beginSchema, end: endSchema, page: pageSchema, pageSize: pageSizeSchema });
         case "PositionHistoryInput":
             return objectSchema({ symbol: symbolSchema, pageSize: pageSizeSchema, startTime: startTimeSchema, endTime: endTimeSchema });
         case "TradePreviewInput":
@@ -305,7 +311,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

@@ -105,7 +105,6 @@ export function evaluateSafety(capability, input, policy, state = makeSafetyStat
 function requiredTradeFields(capability, input) {
     const missing = [];
     switch (capability.capabilityId) {
-        case "order.preview":
         case "order.place-preview":
         case "order.place":
         case "algo.place":
@@ -164,8 +163,7 @@ function requiredTradeFields(capability, input) {
     return missing;
 }
 function requiresNotionalLimit(capability) {
-    return capability.capabilityId === "order.preview"
-        || capability.capabilityId === "order.place-preview"
+    return capability.capabilityId === "order.place-preview"
         || capability.capabilityId === "order.place"
         || capability.capabilityId === "algo.place"
         || capability.capabilityId === "position.close";

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

@@ -4,7 +4,6 @@ import { parseRapidXSymbol } from "../client/symbol.js";
 import { ProductError } from "../errors/product-error.js";
 export async function runPreviewPreflight(capabilityId, input, options = {}) {
     switch (capabilityId) {
-        case "order.preview":
         case "order.place-preview":
         case "order.place":
         case "algo.place":

package/dist/core/trading/preview.js

@@ -156,7 +156,7 @@ export function verifyPreview(store, previewId, capability, input, now = new Dat
         });
     }
     const capabilityMatches = record.capabilityId === capability.capabilityId
-        || ((record.capabilityId === "order.preview" || record.capabilityId === "order.place-preview") && capability.capabilityId === "order.place");
+        || (record.capabilityId === "order.place-preview" && capability.capabilityId === "order.place");
     if (!capabilityMatches) {
         throw new ProductError({
             code: "RCORE20002",
@@ -203,7 +203,7 @@ function makePreviewDetails(capability, tradeParams, automation) {
     };
 }
 function makeRequestSummary(capabilityId, params) {
-    if (capabilityId === "order.preview" || capabilityId === "order.place-preview" || capabilityId === "order.place") {
+    if (capabilityId === "order.place-preview" || capabilityId === "order.place") {
         return compactRecord({
             action: "place_order",
             symbol: params.symbol,

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

@@ -62,9 +62,9 @@ export async function runTradingVerification(rawInput, probes = {}) {
         };
     }
     steps.push({ name: "market", status: "PASS", toolOrCommandEvidence: `minNotional=${marketRules.minNotional};tickSize=${marketRules.tickSize}` });
-    const capability = findCapabilityById("order.preview");
+    const capability = findCapabilityById("order.place-preview");
     if (!capability) {
-        throw new Error("Missing order.preview capability");
+        throw new Error("Missing order.place-preview capability");
     }
     const policy = { ...defaultSafetyPolicy(), tradingEnabled: true, readOnly: false, maxNotional: input.maxNotional };
     const price = marketRules.orderPrice ?? (input.side === "BUY" ? marketRules.bestBid : marketRules.bestAsk);

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.32";
+export const RAPIDX_VERSION = "1.0.34";

package/dist/mcp/tool-registry.js

@@ -18,12 +18,57 @@ export function getMcpToolDefinitions() {
     return tools.sort((a, b) => a.name.localeCompare(b.name));
 }
 function toolDescription(capability) {
-    const base = `RapidX ${capability.capabilityId} (${capability.riskLevel}, schema ${SCHEMA_VERSION})`;
+    const base = TOOL_DESCRIPTIONS[capability.capabilityId]
+        ?? `RapidX ${capability.capabilityId}. Use the published input schema before calling this tool. Risk level: ${capability.riskLevel}. Schema version: ${SCHEMA_VERSION}.`;
     if (!capability.containsRealOrder) {
         return base;
     }
     return `${base}. This submits a real verification order and requires explicit human confirmation bound to symbol, side, maxNotional, and cancel cleanup behavior.`;
 }
+const TOOL_DESCRIPTIONS = {
+    "schema.discover": `Discover the RapidX MCP tool surface, capability metadata, and concrete JSON input schemas. Use this before constructing tool inputs. Schema version: ${SCHEMA_VERSION}.`,
+    "self-check.run": "Run a read-only RapidX integration self-check. Verifies tool discovery, schema, credential configuration, and optional live read probes without submitting trade writes.",
+    "update.check": "Check the RapidX release manifest for CLI, MCP schema, and skills versions. Use during setup, review, or session startup; do not run before every trade submit.",
+    "market.ticker": "Read the latest ticker for a RapidX symbol. Public market adapter may query Binance or OKX venue APIs and returns canonical RapidX symbol plus original venue symbol when they differ.",
+    "market.orderbook": "Read the order book for a RapidX symbol. Public market adapter may query Binance or OKX venue depth/books endpoints and returns canonical RapidX symbol plus venue data.",
+    "market.klines": "Read historical candlesticks for a RapidX symbol. Requires symbol and interval, with optional limit. Public market adapter currently supports Binance-style kline data.",
+    "market.funding-rate": "Read the current funding rate for a perpetual RapidX symbol through the RapidX market funding-rate endpoint.",
+    "market.mark-price": "Read the current mark price for a perpetual RapidX symbol through the RapidX market mark-price endpoint.",
+    "market.symbol-info": "Read RapidX symbol trading rules and metadata, including minNotional, minSize, lotSize, and tickSize when available. Use before order preview or sizing.",
+    "market.open-interest": "Read current open interest for a perpetual RapidX symbol. Public market adapter may query Binance or OKX and returns canonical RapidX symbol plus original venue symbol.",
+    "portfolio.overview": "Read the RapidX trading portfolio overview from GET /api/v1/trading/account. Requires configured RapidX credentials.",
+    "portfolio.assets": "Read RapidX portfolio asset and balance details from GET /api/v1/trading/portfolio/assets. Supports optional exchangeType, page, and pageSize filters.",
+    "portfolio.statement": "Read RapidX portfolio statements from GET /api/v1/trading/statement. Supports optional coin, symbol, statementType, exchange, page, pageSize, startTime, and endTime filters.",
+    "portfolio.user-fee-rate": "Read the user's RapidX trading fee rates from GET /api/v1/trading/userFeeRate. Use this for fee-aware order and execution analysis.",
+    "portfolio.position-bracket": "Read RapidX position tier/bracket information for a symbol from GET /api/v1/trading/positionBracket.",
+    "portfolio.set-position-mode": "Preview-required write: change RapidX account position mode through POST /api/v1/trading/account. Use only when the user explicitly asks to change account position mode.",
+    "trade.preview": "Create a generic preview token by targetCapabilityId for write operations without a dedicated order preview command, including portfolio writes, position writes, and algo writes before submitting the target tool.",
+    "order.place-preview": "Preview an order placement before submitting a real order. Validates input schema, local safety rules, symbol trading rules from GET /api/v1/trading/sym/info, maxNotional, and returns previewId plus confirmation.submitToken.",
+    "order.replace-preview": "Preview an order replacement before submitting a real replace. Performs order readback through GET /api/v1/trading/order to verify the order exists and is replaceable, then returns previewId plus confirmation.submitToken.",
+    "order.cancel-preview": "Preview an order cancellation before submitting a real cancel. Performs order readback through GET /api/v1/trading/order to verify the order exists and is cancelable, then returns previewId plus confirmation.submitToken.",
+    "order.place": "Preview-required write: submit a real order to POST /api/v1/trading/order. Must use unchanged business parameters from order.place-preview and continueConsentId=confirmation.submitToken.",
+    "order.replace": "Preview-required write: replace a real order through PUT /api/v1/trading/order. Must use unchanged business parameters from order.replace-preview or a matching trade preview.",
+    "order.cancel": "Preview-required write: cancel a real order through DELETE /api/v1/trading/order. Cancel can be asynchronous; inspect cancelAccepted, terminalStateConfirmed, and poll order.query when needed.",
+    "order.cancel-all": "Preview-required write: cancel multiple open orders through DELETE /api/v1/trading/cancelAll. Use filters carefully and verify final open-orders state after submission.",
+    "order.query": "Read a single RapidX order from GET /api/v1/trading/order using orderId or clientOrderId. orderId is locally validated as a 16-digit numeric id before upstream lookup.",
+    "order.open-orders": "Read current non-terminal RapidX open orders from GET /api/v1/trading/orders. open-orders means currently active orders, not placing a new order.",
+    "order.history": "Read RapidX order history from GET /api/v1/trading/history/orders. Supports optional sym, businessType, exchange, begin, end, filterExecuted, page, and pageSize. If begin is omitted, RapidX defaults to up to the last 7 days; if end is omitted, current time is used.",
+    "transaction.executions": "Read RapidX transaction executions from GET /api/v1/trading/executions. Supports optional orderId, sym, exchange, businessType, begin, end, and limit filters.",
+    "position.query": "Read current RapidX portfolio positions from GET /api/v1/trading/position. Supports optional symbol and other list filters; client may apply symbol filtering when upstream returns a list.",
+    "position.history": "Read RapidX historical positions from GET /api/v1/trading/history/position. Supports optional symbol, pageSize, startTime, and endTime filters.",
+    "position.get-leverage": "Read current leverage for a perpetual RapidX symbol from GET /api/v1/trading/perp/leverage.",
+    "position.close": "Preview-required write: close a RapidX position through DELETE /api/v1/trading/position. Do not pass side or quantity; NET mode omits positionSide, hedge mode uses LONG or SHORT.",
+    "position.close-all": "Preview-required write: close multiple RapidX positions through DELETE /api/v1/trading/positions. Use filters carefully and verify final positions after submission.",
+    "position.set-leverage": "Preview-required write: set leverage for a RapidX position through POST /api/v1/trading/position/leverage. Verify current leverage after submission.",
+    "algo.place": "Preview-required write: place a RapidX algo order through POST /api/v1/algo/order, including TPSL and conditional flows. Preview first with targetCapabilityId=algo.place.",
+    "algo.replace": "Preview-required write: replace a RapidX algo order through PUT /api/v1/algo/order. Preview first and keep business parameters unchanged between preview and submit.",
+    "algo.cancel": "Preview-required write: cancel a RapidX algo order through DELETE /api/v1/algo/order. Preview first and verify final algo order state after submission.",
+    "algo.open-orders": "Read current non-terminal RapidX algo orders from GET /api/v1/algo/openOrders. open-orders means active algo orders that have not ended.",
+    "algo.history": "Read RapidX algo order history from GET /api/v1/algo/history/orders. Supports optional sym, businessType, exchange, algoOrderType, begin, end, page, and pageSize. The endpoint retrieves finished orders from the past 7 days.",
+    "algo.query": "Read a RapidX algo order detail from GET /api/v1/algo/order using algoOrderId, clientOrderId, or attachedOrderId.",
+    "trading.verify": "Run the compatibility live trading verification flow. It performs read-only self-check, previews a small real order, submits it with explicit user consent, then cancels/cleans up and verifies state.",
+    "trading.verify-live": "Run the live trading verification flow. It performs read-only self-check, previews a small real order, submits it with explicit user consent, then cancels/cleans up and verifies state."
+};
 export function capabilityForTool(toolName) {
     const overrideId = toolName === "rapidx/tools"
         ? "schema.discover"

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 });
@@ -51,10 +54,10 @@ export async function runMcpTool(toolName, input = {}) {
             return tradingVerificationEnvelope(toolName, report, auditId);
         }
         const capability = capabilityForTool(toolName);
-        if (toolName === "rapidx/order/preview" || toolName === "rapidx/order/place-preview") {
-            const previewCapability = findCapabilityById("order.preview");
+        if (toolName === "rapidx/order/place-preview") {
+            const previewCapability = findCapabilityById("order.place-preview");
             if (!previewCapability) {
-                throw new Error("order.preview capability missing");
+                throw new Error("order.place-preview capability missing");
             }
             const preview = createTradePreview(previewCapability, input, { ...defaultSafetyPolicy(), tradingEnabled: true, readOnly: false }, safetyState, previewStore);
             try {

package/package.json

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

package/packages/distribution/docs/cli.md

@@ -39,11 +39,37 @@ rapidx order replace-preview --input @/absolute/path/order-replace-preview.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 algo history --input @/absolute/path/algo-history.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.9"}' --json
+```
+
+For upgrade reviews, force a remote manifest refresh:
+
+```bash
+rapidx update check --input '{"installedSkillsVersion":"1.0.9","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 portfolio assets` reads `/api/v1/trading/portfolio/assets`. It is the canonical CLI command for portfolio asset balances.
@@ -54,6 +80,11 @@ rapidx portfolio set-position-mode --input @/absolute/path/set-position-mode.jso
 
 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.
 
+`rapidx order history` and `rapidx algo history` accept optional `begin` and `end` time range fields in milliseconds. If omitted, RapidX applies the upstream server default range.
+
+`rapidx transaction executions` reads transaction executions from `GET /api/v1/trading/executions`.
+
 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.
+Valid automation preview returns an `automation` object with `confirmationMode="automation-preview"`; generic or missing automation consent text is blocked before submission.
 
 `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

@@ -27,13 +27,15 @@ Key trading tools:
 - `rapidx/tools` returns the MCP tool list plus `inputSchemas`. Agents should read the concrete input schema before constructing write inputs.
 - `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/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.
+- `rapidx/order/place-preview`, `rapidx/order/replace-preview`, and `rapidx/order/cancel-preview` are concrete order preview tools. Preview responses include `confirmation.submitToken`; pass it as `continueConsentId` when submitting the matching write tool.
+- `rapidx/trade/preview` creates generic preview tokens by `targetCapabilityId` for write operations without a dedicated order preview command, 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/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.
+- Valid automation preview returns an `automation` object with `confirmationMode="automation-preview"`; generic or missing automation consent text is blocked before submission.
 - `rapidx/position/history` reads historical positions.
+- `rapidx/order/history` and `rapidx/algo/history` accept optional `begin` and `end` time range fields in milliseconds. If omitted, RapidX applies the upstream server default range.
+- `rapidx/transaction/executions` reads transaction executions from `GET /api/v1/trading/executions`.
 - 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/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.

package/packages/distribution/docs/skills.md

@@ -137,4 +137,4 @@ The config skill guides the agent to install `@liquiditytech/rapidx-cli`, config
 
 The trading skill guides read flow, preview-first write flow, state confirmation, and small real-trade verification.
 
-For existing installations, run `rapidx update check --json` or call `rapidx/update/check` through MCP before an integration review. Reinstall the GitHub-distributed skills when the update result sets `skillsUpdateRecommended=true`.
+For existing installations, read the installed skill `version` from each loaded `SKILL.md` frontmatter, then run `rapidx update check --input '{"installedSkillsVersion":"<local-skill-version>","force":true}' --json` or call `rapidx/update/check` through MCP with the same input before an integration review. Reinstall the GitHub-distributed skills when `skillsInstallStatus=UPDATE_AVAILABLE`, `installedSkillsVersion=NOT_VERIFIED`, or `skillsUpdateRecommended=true`.

package/packages/distribution/docs/tools.md

@@ -10,22 +10,24 @@ The canonical source is `rapidx schema --json` or `rapidx/tools`.
 
 ## Preview 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/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, portfolio writes, and algo writes. Pass `targetCapabilityId`, then submit the target tool with unchanged parameters, `previewId`, and `continueConsentId`.
+- `rapidx/trade/preview`: generic preview for write operations without a dedicated order preview command, 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.
 - Portfolio reads: overview, assets, statement, user fee rate, and position bracket.
-- Order reads: query, open-orders, history, and executions.
+- Order reads: query, open-orders, and history.
+- Transaction reads: `rapidx/transaction/executions`, backed by `GET /api/v1/trading/executions` under the LTP Transactions category.
 - Position reads: query, position history, and get-leverage.
-- Algo reads: open-orders and query.
+- Algo reads: `rapidx/algo/open-orders`, `rapidx/algo/query`, and `rapidx/algo/history`.
 
 `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.
 
+`rapidx/order/history` and `rapidx/algo/history` accept official RapidX `begin` and `end` time range fields in milliseconds. If they are omitted, RapidX applies the upstream server default range.
+
 ## Symbol Format
 
 Use RapidX symbols in tool inputs:
@@ -58,6 +60,7 @@ Preview ids are runtime-local. A preview created by MCP must be submitted throug
 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.
+Automation support is verified at the preview layer: valid automation input returns an `automation` object with `confirmationMode="automation-preview"`, while missing or generic `automationConsentText` is blocked before submission.
 
 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`.
 

package/packages/distribution/docs/troubleshooting/index.md

@@ -1,23 +1,94 @@
 # Troubleshooting
 
-## RCLI
+## Version and installation
+
+Check the npm package and the binary resolved by the shell:
+
+```bash
+npm view @liquiditytech/rapidx-cli version
+which rapidx
+rapidx --version
+```
+
+If npm shows a newer version but `rapidx --version` is old, the shell or agent host is resolving another binary. Update `PATH`, reinstall globally, or configure the MCP host with the absolute `rapidx` path.
+
+## RCLI errors
 
 `RCLI13001` means the CLI rejected a complex invocation. Use the `rapidx` bin directly.
 
 `RCLI25001` means the agent host preflight blocked execution before RapidX ran. Remove shell chaining or use MCP tools.
 
-## RMCP
+`RCLI20002` means preview or continuation consent is missing. Run the matching preview first, then submit with the returned `previewId` and `continueConsentId`.
+
+`RCLI22001` means RapidX upstream returned a business error. Read the upstream message and adjust the request.
+
+## RMCP errors
 
 `RMCP20001` means trade consent is missing.
 
 `RMCP20002` means preview is missing, expired, or mismatched.
 
-## RCORE
+If MCP tools are missing or stale, confirm that the MCP config starts the server with:
+
+```json
+{
+  "command": "rapidx",
+  "args": ["mcp", "serve"]
+}
+```
+
+Reload the agent host after changing MCP config. If old tools such as `rapidx/order/preview` still appear, upgrade the CLI and reload the MCP host.
+
+## RCORE errors
 
 `RCORE01001` means Portfolio credentials are missing.
 
+`RCORE01003` means `LTP_API_HOST` is missing.
+
+`RCORE00002` means `orderId` format is invalid. Use a 16-digit RapidX order id, or use `clientOrderId` where supported.
+
+`RCORE22004` means the requested upstream resource was not found.
+
+`RCORE23002` means upstream network or timeout failure.
+
+`RCORE23003` means RapidX upstream rate limit was reached. Retry later and avoid tight polling loops.
+
 `RCORE90002` means output or audit may contain secret material and must fail closed.
 
+## INVALID_INPUT
+
+Compare the request with the live schema:
+
+```bash
+rapidx schema --json
+```
+
+Common causes are missing required fields, old time fields such as `startTime` / `endTime` instead of `begin` / `end`, invalid `orderId` format, or unsupported symbol format.
+
+## BLOCKED writes
+
+For write tools, check:
+
+- The matching preview ran first.
+- `previewId` is present.
+- `continueConsentId` equals the preview response's `confirmation.submitToken`.
+- The submit request keeps the same business parameters as the preview.
+- The input matches `rapidx schema --json` or `rapidx/tools`.
+
+## Order and algo history
+
+Use official RapidX time fields:
+
+```json
+{ "begin": 1717200000000, "end": 1717804800000 }
+```
+
+If `begin` and `end` are omitted, RapidX applies the upstream default range.
+
+## Asynchronous cancel
+
+A successful cancel response means the cancel request was accepted. If `terminalStateConfirmed=false`, poll `rapidx order query` until the order reaches a terminal state.
+
 ## RSKILL
 
 `RSKILL12001` means the skill did not require evidence.

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

@@ -1,11 +1,11 @@
 {
-  "version": "1.0.32",
+  "version": "1.0.34",
   "artifacts": [
     {
       "name": "rapidx-mcp-registry",
       "path": "packages/distribution/registry/rapidx.mcp.json",
       "channel": "offline",
-      "checksum": "sha256:b75ee5a765902c45f13614cdaf906633590456480fe91174ecee2422048aaf93",
+      "checksum": "sha256:0a21dd7e9627c0996ed56d7409f28f0ca0d30de9d13c6b10650a7ef3fb67505b",
       "status": "ready"
     },
     {
@@ -19,7 +19,7 @@
       "name": "rapidx-tools-doc",
       "path": "packages/distribution/docs/tools.md",
       "channel": "offline",
-      "checksum": "sha256:d7e378d95127c2c62bb8db3a58cfa8a5f80ab2cf523ee530144ddfb9cca7bd96",
+      "checksum": "sha256:59246ef27a9b826bfdc8a20c1ccd8ec6556a95a00b7e5f71fb82d01eb1585b22",
       "status": "ready"
     }
   ]

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

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