@liquiditytech/rapidx-cli 1.0.28 → 1.0.29

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

@@ -0,0 +1,338 @@
+import { RapidXClient } from "../client/rapid-x-client.js";
+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":
+            return validateOrderPlacementPreflight(input, options);
+        case "order.cancel":
+            return validateOrderMutationPreflight(input, "cancel", options);
+        case "order.amend":
+            return validateOrderMutationPreflight(input, "amend", options);
+        case "position.close":
+            return validatePositionClosePreflight(input, options);
+        default:
+            return {};
+    }
+}
+async function validateOrderPlacementPreflight(input, options) {
+    const symbolInput = requiredString(input.symbol, "symbol");
+    const parsed = parseRapidXSymbol(symbolInput);
+    const client = options.client ?? new RapidXClient();
+    const response = await client.get("/api/v1/trading/sym/info", { sym: parsed.canonicalSymbol });
+    const rules = extractSymbolRules(response, parsed.canonicalSymbol);
+    validateQuantity(input, rules);
+    validatePrice(input, rules);
+    validateNotional(input, rules);
+    return {
+        marketRules: compactObject({
+            symbol: parsed.canonicalSymbol,
+            inputSymbol: parsed.inputSymbol !== parsed.canonicalSymbol ? parsed.inputSymbol : undefined,
+            minNotional: rules.minNotional,
+            minSize: rules.minSize,
+            lotSize: rules.lotSize,
+            qtyPrecision: rules.qtyPrecision,
+            tickSize: rules.tickSize,
+            pricePrecision: rules.pricePrecision
+        })
+    };
+}
+async function validateOrderMutationPreflight(input, action, options) {
+    const client = options.client ?? new RapidXClient();
+    const params = orderLookupParams(input);
+    const response = await client.get("/api/v1/trading/order", params);
+    const order = extractOrderReadback(response);
+    if (!order) {
+        throw new ProductError({
+            code: "RCORE22004",
+            status: "BLOCKED",
+            message: "ORDER_NOT_FOUND: order.get did not return an order for preview preflight."
+        });
+    }
+    const state = normalizeOrderState(order.orderState ?? order.state ?? order.status);
+    if (!isOpenOrderState(state)) {
+        throw new ProductError({
+            code: "RCORE22005",
+            status: "BLOCKED",
+            message: `ORDER_NOT_OPEN: order is ${state || "UNKNOWN"} and cannot be ${action}ed.`
+        });
+    }
+    return {
+        orderReadback: {
+            ...order,
+            orderState: state || order.orderState
+        }
+    };
+}
+async function validatePositionClosePreflight(input, options) {
+    const symbolInput = requiredString(input.symbol, "symbol");
+    const parsed = parseRapidXSymbol(symbolInput);
+    const client = options.client ?? new RapidXClient();
+    const response = await client.get("/api/v1/trading/position", { sym: parsed.canonicalSymbol });
+    const positions = extractPositions(response);
+    const positionSide = typeof input.positionSide === "string" && input.positionSide.length > 0 ? input.positionSide.toUpperCase() : undefined;
+    const position = positions.find((item) => {
+        const itemSymbol = stringField(item, "sym") ?? stringField(item, "symbol");
+        const itemSide = stringField(item, "positionSide")?.toUpperCase();
+        const qty = Number(stringField(item, "positionQty") ?? stringField(item, "quantity") ?? stringField(item, "qty") ?? "0");
+        return itemSymbol === parsed.canonicalSymbol && Math.abs(qty) > 0 && (!positionSide || !itemSide || itemSide === positionSide);
+    });
+    if (!position) {
+        throw new ProductError({
+            code: "RCORE24003",
+            status: "BLOCKED",
+            message: `NO_POSITION_TO_CLOSE: no non-zero position found for ${parsed.canonicalSymbol}.`
+        });
+    }
+    return {
+        positionReadback: {
+            ...position,
+            sym: stringField(position, "sym") ?? parsed.canonicalSymbol
+        }
+    };
+}
+function extractSymbolRules(response, symbol) {
+    const data = unwrapData(response);
+    const candidates = [
+        isRecord(data) ? data[symbol] : undefined,
+        isRecord(data) && isRecord(data.data) ? data.data[symbol] : undefined,
+        isRecord(data) && Array.isArray(data.list) ? data.list.find((item) => isRecord(item) && (item.sym === symbol || item.symbol === symbol)) : undefined,
+        data
+    ];
+    const record = candidates.find((item) => isSymbolRuleRecord(item, symbol));
+    if (!record) {
+        throw new ProductError({
+            code: "RCORE12001",
+            status: "BLOCKED",
+            message: `INVALID_SYMBOL: ${symbol} was not found in RapidX symbol-info.`
+        });
+    }
+    const rules = { symbol };
+    assignIfDefined(rules, "minNotional", stringField(record, "minNotional"));
+    assignIfDefined(rules, "minSize", stringField(record, "minSize") ?? stringField(record, "minQty") ?? stringField(record, "minOrderQty"));
+    assignIfDefined(rules, "lotSize", stringField(record, "lotSize") ?? stringField(record, "qtyStep") ?? stringField(record, "stepSize"));
+    assignIfDefined(rules, "qtyPrecision", stringField(record, "qtyPrecision") ?? stringField(record, "quantityPrecision"));
+    assignIfDefined(rules, "tickSize", stringField(record, "tickSize") ?? stringField(record, "priceTick") ?? stringField(record, "priceStep"));
+    assignIfDefined(rules, "pricePrecision", stringField(record, "pricePrecision"));
+    return rules;
+}
+function assignIfDefined(target, key, value) {
+    if (value !== undefined) {
+        target[key] = value;
+    }
+}
+function isSymbolRuleRecord(value, symbol) {
+    if (!isRecord(value) || Object.keys(value).length === 0) {
+        return false;
+    }
+    const recordSymbol = stringField(value, "sym") ?? stringField(value, "symbol");
+    if (recordSymbol !== undefined) {
+        return recordSymbol === symbol;
+    }
+    return [
+        "minNotional",
+        "minSize",
+        "minQty",
+        "minOrderQty",
+        "lotSize",
+        "qtyStep",
+        "stepSize",
+        "qtyPrecision",
+        "quantityPrecision",
+        "tickSize",
+        "priceTick",
+        "priceStep",
+        "pricePrecision"
+    ].some((field) => stringField(value, field) !== undefined);
+}
+function validateNotional(input, rules) {
+    const minNotional = positiveNumber(rules.minNotional);
+    if (minNotional === undefined) {
+        return;
+    }
+    const notional = estimateNotional(input);
+    if (notional !== undefined && notional < minNotional - 1e-12) {
+        throw new ProductError({
+            code: "RCORE24005",
+            status: "BLOCKED",
+            message: `MIN_NOTIONAL_NOT_MET: estimatedNotional ${formatNumber(notional)} is below minNotional ${rules.minNotional}.`
+        });
+    }
+}
+function validateQuantity(input, rules) {
+    const quantityValue = input.quantity ?? input.qty;
+    if (quantityValue === undefined || quantityValue === null || quantityValue === "") {
+        return;
+    }
+    const quantityText = String(quantityValue);
+    const quantity = positiveNumber(quantityText);
+    if (quantity === undefined) {
+        return;
+    }
+    const minSize = positiveNumber(rules.minSize);
+    if (minSize !== undefined && quantity < minSize - 1e-12) {
+        throw new ProductError({
+            code: "RCORE24006",
+            status: "BLOCKED",
+            message: `INVALID_QUANTITY: quantity ${quantityText} is below minSize ${rules.minSize}.`
+        });
+    }
+    const lotSize = positiveNumber(rules.lotSize);
+    if (lotSize !== undefined && !isAlignedToStep(quantity, lotSize)) {
+        throw new ProductError({
+            code: "RCORE24006",
+            status: "BLOCKED",
+            message: `INVALID_QUANTITY: quantity ${quantityText} is not aligned to lotSize ${rules.lotSize}.`
+        });
+    }
+    const qtyPrecision = integerValue(rules.qtyPrecision);
+    if (qtyPrecision !== undefined && decimalPlaces(quantityText) > qtyPrecision) {
+        throw new ProductError({
+            code: "RCORE24006",
+            status: "BLOCKED",
+            message: `INVALID_QUANTITY: quantity ${quantityText} exceeds qtyPrecision ${rules.qtyPrecision}.`
+        });
+    }
+}
+function validatePrice(input, rules) {
+    if (input.price === undefined || input.price === null || input.price === "") {
+        return;
+    }
+    const priceText = String(input.price);
+    const price = positiveNumber(priceText);
+    if (price === undefined) {
+        return;
+    }
+    const tickSize = positiveNumber(rules.tickSize);
+    if (tickSize !== undefined && !isAlignedToStep(price, tickSize)) {
+        throw new ProductError({
+            code: "RCORE24007",
+            status: "BLOCKED",
+            message: `INVALID_PRICE_TICK: price ${priceText} is not aligned to tickSize ${rules.tickSize}.`
+        });
+    }
+    const pricePrecision = integerValue(rules.pricePrecision);
+    if (pricePrecision !== undefined && decimalPlaces(priceText) > pricePrecision) {
+        throw new ProductError({
+            code: "RCORE24007",
+            status: "BLOCKED",
+            message: `INVALID_PRICE_TICK: price ${priceText} exceeds pricePrecision ${rules.pricePrecision}.`
+        });
+    }
+}
+function estimateNotional(input) {
+    const direct = positiveNumber(input.amount ?? input.notional);
+    if (direct !== undefined) {
+        return direct;
+    }
+    const price = positiveNumber(input.price);
+    const quantity = positiveNumber(input.quantity ?? input.qty);
+    if (price === undefined || quantity === undefined) {
+        return undefined;
+    }
+    return price * quantity;
+}
+function orderLookupParams(input) {
+    const params = compactObject({
+        orderId: input.orderId,
+        clientOrderId: input.clientOrderId,
+        symbol: input.symbol
+    });
+    if (!params.orderId && !params.clientOrderId) {
+        throw new ProductError({
+            code: "RCORE00001",
+            status: "FAIL",
+            message: "orderId or clientOrderId is required."
+        });
+    }
+    return params;
+}
+function extractOrderReadback(response) {
+    const data = unwrapData(response);
+    if (isRecord(data) && Array.isArray(data.list)) {
+        return data.list.find(isRecord);
+    }
+    if (isRecord(data) && Array.isArray(data.orders)) {
+        return data.orders.find(isRecord);
+    }
+    return isRecord(data) && Object.keys(data).length > 0 ? data : undefined;
+}
+function extractPositions(response) {
+    const data = unwrapData(response);
+    if (Array.isArray(data)) {
+        return data.filter(isRecord);
+    }
+    if (isRecord(data) && Array.isArray(data.list)) {
+        return data.list.filter(isRecord);
+    }
+    if (isRecord(data) && Array.isArray(data.positions)) {
+        return data.positions.filter(isRecord);
+    }
+    return isRecord(data) ? [data] : [];
+}
+function unwrapData(response) {
+    if (isRecord(response) && "data" in response) {
+        return response.data;
+    }
+    return response;
+}
+function normalizeOrderState(value) {
+    return value === undefined || value === null ? "" : String(value).toUpperCase();
+}
+function isOpenOrderState(state) {
+    return ["NEW", "OPEN", "ACCEPTED", "PARTIALLY_FILLED"].includes(state);
+}
+function requiredString(value, field) {
+    if (value === undefined || value === null || value === "") {
+        throw new ProductError({
+            code: "RCORE00001",
+            status: "FAIL",
+            message: `${field} is required.`
+        });
+    }
+    return String(value);
+}
+function stringField(record, field) {
+    const value = record[field];
+    return value === undefined || value === null || value === "" ? undefined : String(value);
+}
+function positiveNumber(value) {
+    if (value === undefined || value === null || value === "") {
+        return undefined;
+    }
+    const number = Number(value);
+    return Number.isFinite(number) && number > 0 ? number : undefined;
+}
+function integerValue(value) {
+    if (value === undefined || value === null || value === "") {
+        return undefined;
+    }
+    const number = Number(value);
+    return Number.isInteger(number) && number >= 0 ? number : undefined;
+}
+function isAlignedToStep(value, step) {
+    const ratio = value / step;
+    return Math.abs(ratio - Math.round(ratio)) < 1e-9;
+}
+function decimalPlaces(value) {
+    const normalized = value.toLowerCase();
+    if (normalized.includes("e")) {
+        const [mantissa, exponentRaw] = normalized.split("e");
+        const exponent = Number(exponentRaw);
+        return Math.max(0, decimalPlaces(mantissa ?? "0") - exponent);
+    }
+    const [, fractional = ""] = normalized.split(".");
+    return fractional.replace(/0+$/, "").length;
+}
+function formatNumber(value) {
+    return Number.isInteger(value) ? String(value) : String(Number(value.toFixed(12)));
+}
+function compactObject(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined && value !== null && value !== ""));
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}

package/dist/core/trading/preview.js

@@ -4,6 +4,7 @@ import { dirname, join, resolve } from "node:path";
 import { assertInputMatchesSchema } from "../contracts/input-schema.js";
 import { evaluateSafety, stableParamsHash } from "../safety/policy.js";
 import { ProductError } from "../errors/product-error.js";
+import { parseRapidXSymbol } from "../client/symbol.js";
 export function makePreviewStore() {
     return { records: new Map() };
 }
@@ -38,10 +39,11 @@ export function savePreviewStoreToFile(filePath, store) {
 }
 export function createTradePreview(capability, input, policy, state, store, ttlSeconds = 300) {
     assertInputMatchesSchema(capability.inputSchema, input, {
-        allowedExtraFields: ["explicitUserConsent", "acceptedRiskText"]
+        allowedExtraFields: ["explicitUserConsent", "acceptedRiskText", "automationMode", "automationConsentText", "automationScope"]
     });
     const tradeParams = normalizeTradeParams(input);
-    const previewDetails = makePreviewDetails(capability, tradeParams);
+    const automation = makeAutomationDetails(input, tradeParams);
+    const previewDetails = makePreviewDetails(capability, tradeParams, automation);
     const decision = evaluateSafety(capability, input, policy, state);
     if (!decision.allowed) {
         throw new ProductError({
@@ -59,7 +61,8 @@ export function createTradePreview(capability, input, policy, state, store, ttlS
         expiresAt: new Date(Date.now() + ttlSeconds * 1000).toISOString(),
         submitted: false,
         status: "PASS",
-        confirmation: makeSubmitConfirmation(previewId)
+        confirmation: makeSubmitConfirmation(previewId, automation),
+        ...(automation ? { automation } : {})
     };
     store.records.set(previewId, record);
     return record;
@@ -73,7 +76,10 @@ export function createTargetedTradePreview(targetCapability, input, policy, stat
             "acceptedRiskText",
             "mcpSchemaVersion",
             "skillsVersion",
-            "skillsSchemaVersion"
+            "skillsSchemaVersion",
+            "automationMode",
+            "automationConsentText",
+            "automationScope"
         ],
         ignoredRequiredFields: ["previewId", "continueConsentId"]
     });
@@ -92,7 +98,8 @@ export function createTargetedTradePreview(targetCapability, input, policy, stat
         });
     }
     const tradeParams = normalizeTradeParams(input);
-    const previewDetails = makePreviewDetails(targetCapability, tradeParams);
+    const automation = makeAutomationDetails(input, tradeParams);
+    const previewDetails = makePreviewDetails(targetCapability, tradeParams, automation);
     const decision = evaluateSafety(targetCapability, input, policy, state);
     if (!decision.allowed) {
         throw new ProductError({
@@ -110,16 +117,19 @@ export function createTargetedTradePreview(targetCapability, input, policy, stat
         expiresAt: new Date(Date.now() + ttlSeconds * 1000).toISOString(),
         submitted: false,
         status: "PASS",
-        confirmation: makeSubmitConfirmation(previewId)
+        confirmation: makeSubmitConfirmation(previewId, automation),
+        ...(automation ? { automation } : {})
     };
     store.records.set(previewId, record);
     return record;
 }
-function makeSubmitConfirmation(previewId) {
+function makeSubmitConfirmation(previewId, automation) {
     return {
         submitToken: `confirm_${previewId}`,
         requiredFields: ["previewId", "continueConsentId"],
-        instruction: "Pass submitToken as continueConsentId only after the user has confirmed this exact preview."
+        instruction: automation
+            ? "Automation mode is enabled for this preview. The agent may pass submitToken as continueConsentId without asking for another per-order chat confirmation, within the authorized scope."
+            : "Pass submitToken as continueConsentId only after the user has confirmed this exact preview."
     };
 }
 export function verifyPreview(store, previewId, capability, input, now = new Date()) {
@@ -135,7 +145,7 @@ export function verifyPreview(store, previewId, capability, input, now = new Dat
         throw new ProductError({
             code: "RCORE20002",
             status: "BLOCKED",
-            message: "previewId was not found."
+            message: "previewId was not found or has expired. Re-run preview and submit within 5 minutes."
         });
     }
     if (new Date(record.expiresAt).getTime() < now.getTime()) {
@@ -172,16 +182,24 @@ function normalizeTradeParams(input) {
     const normalized = {};
     for (const [key, value] of Object.entries(input)) {
         if (!NON_TRADE_HASH_FIELDS.has(key) && value !== undefined) {
-            normalized[key] = value;
+            normalized[key] = key === "symbol" && typeof value === "string" ? canonicalSymbolOrOriginal(value) : value;
         }
     }
     return normalized;
 }
-function makePreviewDetails(capability, tradeParams) {
+function canonicalSymbolOrOriginal(value) {
+    try {
+        return parseRapidXSymbol(value).canonicalSymbol;
+    }
+    catch {
+        return value;
+    }
+}
+function makePreviewDetails(capability, tradeParams, automation) {
     return {
         businessParams: { ...tradeParams },
         requestSummary: makeRequestSummary(capability.capabilityId, tradeParams),
-        riskNotes: makeRiskNotes(capability.capabilityId, tradeParams)
+        riskNotes: makeRiskNotes(capability.capabilityId, tradeParams, automation)
     };
 }
 function makeRequestSummary(capabilityId, params) {
@@ -190,6 +208,7 @@ function makeRequestSummary(capabilityId, params) {
             action: "place_order",
             symbol: params.symbol,
             side: params.side,
+            positionSide: params.positionSide,
             orderType: params.orderType,
             price: params.price,
             quantity: params.quantity,
@@ -240,11 +259,18 @@ function makeRequestSummary(capabilityId, params) {
     }
     return compactRecord({ action: capabilityId, ...params });
 }
-function makeRiskNotes(capabilityId, params) {
+function makeRiskNotes(capabilityId, params, automation) {
     const notes = [];
+    if (automation) {
+        notes.push("Automation mode allows the agent to submit this preview with submitToken without asking for another per-order chat confirmation.");
+    }
     if (params.maxNotional !== undefined) {
         notes.push("maxNotional is a safety upper bound, not the target order size.");
     }
+    if (String(params.orderType ?? "").toUpperCase() === "MARKET") {
+        notes.push("MARKET orders may execute immediately.");
+        notes.push("MARKET order fill price is not guaranteed and may include slippage.");
+    }
     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.");
@@ -252,6 +278,51 @@ function makeRiskNotes(capabilityId, params) {
     }
     return notes;
 }
+function makeAutomationDetails(input, tradeParams) {
+    if (input.automationMode !== true) {
+        return undefined;
+    }
+    const acceptedRiskText = typeof input.automationConsentText === "string" ? input.automationConsentText.trim() : "";
+    const missing = automationConsentMissingFields(acceptedRiskText, tradeParams, input);
+    if (missing.length > 0) {
+        throw new ProductError({
+            code: "RCORE20003",
+            status: "BLOCKED",
+            message: `automationConsentText must include ${missing.join(", ")} for this exact automation scope.`
+        });
+    }
+    return {
+        enabled: true,
+        confirmationMode: "automation-preview",
+        scope: typeof input.automationScope === "string" && input.automationScope.trim().length > 0 ? input.automationScope.trim() : "single-preview",
+        ...(tradeParams.maxNotional !== undefined ? { maxNotional: String(tradeParams.maxNotional) } : {}),
+        acceptedRiskText
+    };
+}
+function automationConsentMissingFields(text, tradeParams, input) {
+    const missing = [];
+    const upperText = text.toUpperCase();
+    const lowerText = text.toLowerCase();
+    if (text.length < 20) {
+        missing.push("automationConsentText");
+    }
+    const symbol = typeof tradeParams.symbol === "string" ? tradeParams.symbol : undefined;
+    if (symbol && !upperText.includes(symbol.toUpperCase())) {
+        missing.push("symbol");
+    }
+    const maxNotional = tradeParams.maxNotional;
+    if (maxNotional !== undefined && !text.includes(String(maxNotional))) {
+        missing.push("maxNotional");
+    }
+    if (!lowerText.includes("automation") && !lowerText.includes("automated") && !text.includes("自动")) {
+        missing.push("automation intent");
+    }
+    const scope = typeof input.automationScope === "string" ? input.automationScope.trim() : "";
+    if (scope && scope !== "single-preview" && !lowerText.includes(scope.toLowerCase())) {
+        missing.push("automationScope");
+    }
+    return missing;
+}
 function estimateNotional(params) {
     if (params.amount !== undefined && params.amount !== null && params.amount !== "") {
         return String(params.amount);
@@ -314,7 +385,10 @@ const NON_TRADE_HASH_FIELDS = new Set([
     "acceptedRiskText",
     "mcpSchemaVersion",
     "skillsVersion",
-    "skillsSchemaVersion"
+    "skillsSchemaVersion",
+    "automationMode",
+    "automationConsentText",
+    "automationScope"
 ]);
 function isTradePreviewRecord(value) {
     if (!value || typeof value !== "object") {

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

@@ -13,7 +13,7 @@ export async function runTradingVerification(rawInput, probes = {}) {
     }
     catch (error) {
         if (error instanceof ProductError) {
-            return { submittedRealOrder: false, status: "FAIL", cleanupStatus: "NOT_VERIFIED", steps, errorCode: error.code, errorMessage: error.message, errorStage: "input-validation" };
+            return { submittedRealOrder: false, status: error.status, cleanupStatus: "NOT_VERIFIED", steps, errorCode: error.code, errorMessage: error.message, errorStage: "input-validation" };
         }
         throw error;
     }
@@ -39,7 +39,7 @@ export async function runTradingVerification(rawInput, probes = {}) {
             errorCode: "RCORE20001",
             errorMessage: consentProblem,
             errorStage: "user-consent",
-            recommendedAction: "Ask the human user to confirm the exact symbol, side, maxNotional, real-order risk, and cancel cleanup behavior before running verify-live."
+            recommendedAction: "Ask the human user to confirm the exact symbol, side, positionSide when provided, maxNotional, real-order risk, and cancel cleanup behavior before running verify-live."
         };
     }
     if (!probes.marketRules) {
@@ -48,8 +48,18 @@ export async function runTradingVerification(rawInput, probes = {}) {
     }
     const marketRules = await probes.marketRules(input);
     if (Number(marketRules.minNotional) > Number(input.maxNotional)) {
-        steps.push({ name: "market", status: "BLOCKED", toolOrCommandEvidence: `minNotional=${marketRules.minNotional};maxNotional=${input.maxNotional}` });
-        return { submittedRealOrder: false, status: "BLOCKED", cleanupStatus: "NOT_VERIFIED", steps, errorCode: "RCORE24001", errorStage: "market" };
+        const evidence = `minNotional=${marketRules.minNotional};maxNotional=${input.maxNotional}`;
+        steps.push({ name: "market", status: "BLOCKED", toolOrCommandEvidence: evidence });
+        return {
+            submittedRealOrder: false,
+            status: "BLOCKED",
+            cleanupStatus: "NOT_VERIFIED",
+            steps,
+            errorCode: "RCORE24001",
+            errorMessage: `Verification order blocked because ${evidence}.`,
+            errorStage: "market",
+            recommendedAction: `Increase maxNotional to at least ${marketRules.minNotional}, or choose a symbol whose minNotional is within the authorized maxNotional.`
+        };
     }
     steps.push({ name: "market", status: "PASS", toolOrCommandEvidence: `minNotional=${marketRules.minNotional};tickSize=${marketRules.tickSize}` });
     const capability = findCapabilityById("order.preview");
@@ -73,7 +83,7 @@ export async function runTradingVerification(rawInput, probes = {}) {
         return { submittedRealOrder: false, status: "NOT_VERIFIED", cleanupStatus: "NOT_VERIFIED", steps, previewId: preview.previewId, errorCode: "RCORE23001", errorStage: "place" };
     }
     const placed = await probes.placeOrder({ ...input, previewId: preview.previewId, orderType: "LIMIT", postOnly: true, price, quantity });
-    steps.push({ name: "place", status: "PASS", toolOrCommandEvidence: placed.requestId ?? placed.orderId });
+    steps.push({ name: "place", status: "PASS", toolOrCommandEvidence: [placed.requestId ?? placed.orderId, input.positionSide ? `positionSide=${input.positionSide}` : undefined].filter(Boolean).join(";") });
     if (!probes.queryOrder) {
         steps.push({ name: "query", status: "NOT_VERIFIED", toolOrCommandEvidence: "queryOrder probe missing" });
         return { submittedRealOrder: true, status: "NOT_VERIFIED", cleanupStatus: "NOT_VERIFIED", steps, previewId: preview.previewId, errorCode: "RCORE23001", errorStage: "query" };
@@ -93,7 +103,11 @@ export async function runTradingVerification(rawInput, probes = {}) {
         }
     }
     else {
-        steps.push({ name: "amend", status: "EXPECTED_ERROR", toolOrCommandEvidence: "amendOrder probe not supported" });
+        steps.push({
+            name: "amend",
+            status: "EXPECTED_ERROR",
+            toolOrCommandEvidence: "optional verify-live amend check skipped; order.amend remains available outside verify-live"
+        });
     }
     if (!probes.cancelOrder) {
         steps.push({ name: "cancel", status: "FAIL", toolOrCommandEvidence: "cancelOrder probe missing" });
@@ -110,12 +124,12 @@ export async function runTradingVerification(rawInput, probes = {}) {
         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." };
     }
-    const cleanup = await probes.cleanupCheck(currentOrder);
-    if (cleanup.openOrders !== 0 || cleanup.unexpectedPositions !== 0) {
-        steps.push({ name: "cleanup-check", status: "FAIL", toolOrCommandEvidence: `openOrders=${cleanup.openOrders};unexpectedPositions=${cleanup.unexpectedPositions}` });
-        return cleanupFailureReport(steps, preview.previewId, "cleanup-check", currentOrder.status, `cleanup still shows openOrders=${cleanup.openOrders}; unexpectedPositions=${cleanup.unexpectedPositions}`);
+    const cleanupConfirmation = await confirmCleanup(currentOrder, probes);
+    if (!cleanupConfirmation.confirmed) {
+        steps.push({ name: "cleanup-check", status: "FAIL", toolOrCommandEvidence: cleanupConfirmation.evidence });
+        return cleanupFailureReport(steps, preview.previewId, "cleanup-check", currentOrder.status, `cleanup still shows ${cleanupEvidence(cleanupConfirmation.cleanup)}`);
     }
-    steps.push({ name: "cleanup-check", status: "PASS", toolOrCommandEvidence: "openOrders=0;unexpectedPositions=0" });
+    steps.push({ name: "cleanup-check", status: "PASS", toolOrCommandEvidence: cleanupConfirmation.evidence });
     return {
         submittedRealOrder: true,
         status: "PASS",
@@ -136,6 +150,9 @@ function normalizeTradingVerificationInput(input) {
     if (typeof input.acceptedRiskText === "string") {
         normalized.acceptedRiskText = input.acceptedRiskText;
     }
+    if (input.positionSide === "LONG" || input.positionSide === "SHORT") {
+        normalized.positionSide = input.positionSide;
+    }
     return normalized;
 }
 function validateParameterBoundConsent(input) {
@@ -155,6 +172,9 @@ function validateParameterBoundConsent(input) {
     if (!upperText.includes(input.side)) {
         missing.push("side");
     }
+    if (input.positionSide && !upperText.includes(input.positionSide)) {
+        missing.push("positionSide");
+    }
     if (!text.includes(input.maxNotional)) {
         missing.push("maxNotional");
     }
@@ -194,6 +214,31 @@ async function confirmCancel(order, probes) {
 function isSafeCancelTerminalState(status) {
     return status === "CANCELED" || status === "EXPIRED" || status === "REJECTED";
 }
+async function confirmCleanup(order, probes) {
+    const observations = [];
+    let current = await probes.cleanupCheck(order);
+    observations.push(cleanupEvidence(current));
+    if (isCleanupClean(current)) {
+        return { confirmed: true, cleanup: current, evidence: observations.join("->") };
+    }
+    const delays = probes.cleanupCheckDelaysMs ?? probes.cancelConfirmationDelaysMs ?? [100, 250, 500, 1_000, 2_000];
+    const wait = probes.wait ?? defaultWait;
+    for (const delay of delays) {
+        await wait(delay);
+        current = await probes.cleanupCheck(order);
+        observations.push(cleanupEvidence(current));
+        if (isCleanupClean(current)) {
+            return { confirmed: true, cleanup: current, evidence: observations.join("->") };
+        }
+    }
+    return { confirmed: false, cleanup: current, evidence: observations.join("->") };
+}
+function isCleanupClean(cleanup) {
+    return cleanup.openOrders === 0 && cleanup.unexpectedPositions === 0;
+}
+function cleanupEvidence(cleanup) {
+    return `openOrders=${cleanup.openOrders};unexpectedPositions=${cleanup.unexpectedPositions}`;
+}
 function defaultWait(milliseconds) {
     return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }

package/dist/core/version.js

@@ -1 +1 @@
-export const RAPIDX_VERSION = "1.0.28";
+export const RAPIDX_VERSION = "1.0.29";