dexbot 1.4.20 → 1.4.21

package/claw/modules/chain_actions.ts

@@ -3,11 +3,12 @@ import * as client from './bitshares_client.js';
 const { BitShares } = client;
 import { executeOperations } from './chain_broadcast.js';
 import { loadDexbotOrderUtils, requireDexbot2Module, loadDexbotOrderConstants } from './dexbot_bridge.js';
-import { requireBtsBackedMpa, CORE_SYMBOL } from './mpa_utils.js';
-import { getAsset, getBackingAsset, getFullAccount, readOpenOrders, resolveAccountId, resolveAccountName } from './chain_queries.js';
+import { requireBtsBackedMpa } from './mpa_utils.js';
+import { getAsset, getFullAccount, readOpenOrders, resolveAccountId, resolveAccountName } from './chain_queries.js';
 import { getErrorMessage } from '../../modules/utils/errors.js';
 
-// Graphene protocol constant: operation type 4 = limit_order_create (fill events carry op[0] = 4 for matched orders)
+// Graphene protocol constant: operation type 4 = fill_order (limit_order_create
+// is type 1). Account history subscriptions emit op[0] = 4 for matched fills.
 const FILL_ORDER_OPERATION_TYPE = 4;
 const accountSubscriptions = new Map();
 
@@ -134,18 +135,7 @@ async function buildBorrowMpaOperation({
     throw new Error(`Account not found: ${accountName}`);
   }
 
-  const mpaMeta = await resolveAssetMeta(mpaAsset);
-  if (!mpaMeta.bitasset_data_id) {
-    throw new Error(`${mpaAsset} is not a market-issued asset`);
-  }
-
-  const backingAsset = await getBackingAsset(mpaAsset);
-  if (!backingAsset) {
-    throw new Error(`Could not resolve backing asset for ${mpaAsset}`);
-  }
-  if (backingAsset.symbol !== CORE_SYMBOL) {
-    throw new Error(`${mpaAsset} is backed by ${backingAsset.symbol}, not ${CORE_SYMBOL}; use short_mpa_strategy for non-BTS MPAs`);
-  }
+  const { backingAsset, mpaAsset: mpaMeta } = await requireBtsBackedMpa(mpaAsset, 'use short_mpa_strategy for non-BTS MPAs');
 
   const floatToBlockchainInt = getFloatToBlockchainInt();
   const debtInt = floatToBlockchainInt(debtDelta, mpaMeta.precision);
@@ -179,18 +169,7 @@ async function buildSettleMpaOperation({ accountName, mpaAsset, amount }: any) {
     throw new Error(`Account not found: ${accountName}`);
   }
 
-  const mpaMeta = await resolveAssetMeta(mpaAsset);
-  if (!mpaMeta.bitasset_data_id) {
-    throw new Error(`${mpaAsset} is not a market-issued asset`);
-  }
-
-  const backingAsset = await getBackingAsset(mpaAsset);
-  if (!backingAsset) {
-    throw new Error(`Could not resolve backing asset for ${mpaAsset}`);
-  }
-  if (backingAsset.symbol !== CORE_SYMBOL) {
-    throw new Error(`${mpaAsset} is backed by ${backingAsset.symbol}, not ${CORE_SYMBOL}`);
-  }
+  const { mpaAsset: mpaMeta } = await requireBtsBackedMpa(mpaAsset);
 
   const floatToBlockchainInt = getFloatToBlockchainInt();
   const settleAmountInt = floatToBlockchainInt(amount, mpaMeta.precision);
@@ -304,36 +283,19 @@ async function listenForFills(accountNameOrId: any, callback: any) {
 
   if (!accountSubscriptions.has(accountName)) {
     const callbacks: Set<Function> = new Set();
-    const bsCallback = (updates: any[] = []) => {
-      const fills = updates.filter((update) => update?.op && update.op[0] === FILL_ORDER_OPERATION_TYPE);
-      if (fills.length === 0) {
-        return;
-      }
-
-      for (const fn of Array.from(callbacks)) {
-        // The callback may be async. Run it synchronously so sync throws are
-        // caught here, and attach a catch for async rejections so a rejected
-        // handler cannot become an unhandled promise rejection (crash on
-        // Node >= 15).
-        try {
-          const result = fn(fills);
-          if (result && typeof result.then === 'function') {
-            result.catch((err: any) => {
-              console.error('listenForFills callback error:', getErrorMessage(err));
-            });
-          }
-        } catch (err: any) {
-          console.error('listenForFills callback error:', getErrorMessage(err));
-        }
-      }
-    };
-
-    BitShares.subscribe('account', bsCallback, accountName);
+    let bsCallback: Function | null = null;
+    try {
+      bsCallback = await subscribeAccountFills(accountName, callbacks);
+    } catch (err: any) {
+      throw new Error(`Failed to subscribe to account updates for ${accountName}: ${getErrorMessage(err)}`);
+    }
+    // Register only after the remote subscription succeeded so callers never
+    // believe they are subscribed when setup actually failed.
     accountSubscriptions.set(accountName, { callbacks, bsCallback });
   }
 
   const entry = accountSubscriptions.get(accountName);
-  if (!entry) {
+  if (!entry || !entry.bsCallback) {
     throw new Error(`Subscription entry not found for ${accountName}`);
   }
   entry.callbacks.add(callback);
@@ -357,5 +319,40 @@ async function listenForFills(accountNameOrId: any, callback: any) {
   };
 }
 
-export { adjustMpaCollateral, borrowMpa, buildBorrowMpaOperation, buildCancelLimitOrderOperation, buildCreateLimitOrderOperation, buildUpdateLimitOrderOperation, buildSettleMpaOperation, cancelLimitOrder, createLimitOrder, executeBatch, getMpaPosition, getOpenOrders, listenForFills, repayMpaDebt, updateLimitOrder, settleMpa }
+/**
+ * Subscribe to account history fills and fan them out to every registered
+ * callback. The underlying subscription call is async and can reject (network
+ * error, unknown account); the promise is awaited by listenForFills so a
+ * failure surfaces instead of becoming an unhandled rejection.
+ */
+async function subscribeAccountFills(accountName: string, callbacks: Set<Function>) {
+  const bsCallback = (updates: any[] = []) => {
+    const fills = updates.filter((update) => update?.op && update.op[0] === FILL_ORDER_OPERATION_TYPE);
+    if (fills.length === 0) {
+      return;
+    }
+
+    for (const fn of Array.from(callbacks)) {
+      // The callback may be async. Run it synchronously so sync throws are
+      // caught here, and attach a catch for async rejections so a rejected
+      // handler cannot become an unhandled promise rejection (crash on
+      // Node >= 15).
+      try {
+        const result = fn(fills);
+        if (result && typeof result.then === 'function') {
+          result.catch((err: any) => {
+            console.error('listenForFills callback error:', getErrorMessage(err));
+          });
+        }
+      } catch (err: any) {
+        console.error('listenForFills callback error:', getErrorMessage(err));
+      }
+    }
+  };
+
+  await BitShares.subscribe('account', bsCallback, accountName);
+  return bsCallback;
+}
+
+export { adjustMpaCollateral, borrowMpa, buildBorrowMpaOperation, buildCreateLimitOrderOperation, buildUpdateLimitOrderOperation, buildSettleMpaOperation, cancelLimitOrder, createLimitOrder, executeBatch, getMpaPosition, getOpenOrders, listenForFills, repayMpaDebt, updateLimitOrder, settleMpa }
 

package/claw/modules/chain_broadcast.ts

@@ -130,7 +130,7 @@ function resolveAccountName(options: Record<string, any> = {}) {
   return options.accountName || Config.BITSHARES_ACCOUNT || null;
 }
 
-async function createSigningClientFromCredentialDaemon(options: Record<string, any> = {}) {
+async function createSigningClientFromCredentialDaemon() {
   throw new Error(
     'The credential daemon no longer exports raw private keys. ' +
     'Use broadcastOperationViaCredentialDaemon() or executeOperationsViaCredentialDaemon() ' +
@@ -152,10 +152,7 @@ async function getSigningClient(options: Record<string, any> = {}) {
     throw new Error('Credential daemon is not ready');
   }
 
-  return createSigningClientFromCredentialDaemon({
-    ...options,
-    accountName
-  });
+  return createSigningClientFromCredentialDaemon();
 }
 
 function normalizeOperations(operations: any) {
@@ -163,6 +160,53 @@ function normalizeOperations(operations: any) {
   return ops.filter(Boolean);
 }
 
+/**
+ * Shared credential-daemon broadcast plumbing: clamps the request timeout so
+ * the daemon's inner deadline can fire first, waits for the daemon, resolves
+ * session credentials, and retries once on session/HMAC failures (SIGHUP on
+ * source-auth denials). `dispatch` performs the actual daemon call and must
+ * be idempotent-safe: it is only re-invoked after credentials are re-resolved.
+ */
+async function viaCredentialDaemon(accountName: string, options: Record<string, any>, dispatch: (creds: { sessionId: string | null; botHmacSecret: string | null }) => Promise<any>) {
+  const daemonTimeoutMs = Number.isFinite(Number(options.daemonTimeoutMs))
+    ? Number(options.daemonTimeoutMs)
+    : undefined;
+  // Clamp the broadcast request timeout up to the default outer window: the
+  // daemon's inner deadline (25s) must be allowed to fire and reply a typed
+  // BROADCAST_DEADLINE before this socket timer. A caller-supplied short
+  // timeout would time out mid-broadcast — a false uncertain.
+  const requestTimeoutMs = Number.isFinite(Number(options.daemonRequestTimeoutMs))
+    ? Math.max(Number(options.daemonRequestTimeoutMs), DEFAULT_BROADCAST_TIMEOUT_MS)
+    : undefined;
+
+  await waitForCredentialDaemon(daemonTimeoutMs, options);
+
+  const creds = await resolveSessionCredentials(accountName, options);
+  const socketOptions = {
+    socketPath: options.socketPath,
+    timeoutMs: requestTimeoutMs
+  };
+
+  try {
+    return await dispatch({ ...socketOptions, ...creds });
+  } catch (err: any) {
+    const msg = String(getErrorMessage(err) || err);
+    if (msg.includes(DAEMON_ERRORS.SOURCE_AUTH_DENIED) || msg.includes(DAEMON_ERRORS.SESSION_EXPIRED)) {
+      const isSourceAuthError = msg.includes(DAEMON_ERRORS.SOURCE_AUTH_DENIED);
+      console.warn(`[CLAW] Session/HMAC error, re-resolving credentials and retrying: ${msg}`);
+      if (isSourceAuthError) {
+        _sendSighupToDaemon();
+      }
+      const retry = await resolveSessionCredentials(accountName, options);
+      if (isSourceAuthError) {
+        await new Promise(r => setTimeout(r, 500));
+      }
+      return await dispatch({ ...socketOptions, ...retry });
+    }
+    throw err;
+  }
+}
+
 async function executeOperations(operations: any, options: Record<string, any> = {}) {
   const ops = normalizeOperations(operations);
   if (ops.length === 0) {
@@ -175,66 +219,20 @@ async function executeOperations(operations: any, options: Record<string, any> =
       throw new Error('accountName is required');
     }
 
-    const daemonTimeoutMs = Number.isFinite(Number(options.daemonTimeoutMs))
-      ? Number(options.daemonTimeoutMs)
-      : undefined;
-    // Clamp the broadcast request timeout up to the default outer window: the
-    // daemon's inner deadline (25s) must be allowed to fire and reply a typed
-    // BROADCAST_DEADLINE before this socket timer. A caller-supplied short
-    // timeout would time out mid-broadcast — a false uncertain.
-    const requestTimeoutMs = Number.isFinite(Number(options.daemonRequestTimeoutMs))
-      ? Math.max(Number(options.daemonRequestTimeoutMs), DEFAULT_BROADCAST_TIMEOUT_MS)
-      : undefined;
-
-    await waitForCredentialDaemon(daemonTimeoutMs, options);
-
-    let { sessionId, botHmacSecret } = await resolveSessionCredentials(accountName, options);
-
-    try {
-      const result = await executeOperationsViaCredentialDaemon(accountName, ops, {
-        socketPath: options.socketPath,
-        timeoutMs: requestTimeoutMs,
-        sessionId,
-        botHmacSecret,
+    const result = await viaCredentialDaemon(accountName, options, async (daemonOptions) =>
+      executeOperationsViaCredentialDaemon(accountName, ops, {
+        ...daemonOptions,
         requestType: 'broadcast',
         batchId: options.batchId || null
-      });
-
-      return {
-        ...result,
-        operation_results: result.operation_results || [],
-        raw: result.raw || null,
-        success: true
-      };
-    } catch (err: any) {
-      const msg = String(getErrorMessage(err) || err);
-      if (msg.includes(DAEMON_ERRORS.SOURCE_AUTH_DENIED) || msg.includes(DAEMON_ERRORS.SESSION_EXPIRED)) {
-        const isSourceAuthError = msg.includes(DAEMON_ERRORS.SOURCE_AUTH_DENIED);
-        console.warn(`[CLAW] Session/HMAC error, re-resolving credentials and retrying: ${msg}`);
-        if (isSourceAuthError) {
-          _sendSighupToDaemon();
-        }
-        const retry = await resolveSessionCredentials(accountName, options);
-        if (isSourceAuthError) {
-          await new Promise(r => setTimeout(r, 500));
-        }
-        const result = await executeOperationsViaCredentialDaemon(accountName, ops, {
-          socketPath: options.socketPath,
-          timeoutMs: requestTimeoutMs,
-          sessionId: retry.sessionId,
-          botHmacSecret: retry.botHmacSecret,
-          requestType: 'broadcast',
-          batchId: options.batchId || null
-        });
-        return {
-          ...result,
-          operation_results: result.operation_results || [],
-          raw: result.raw || null,
-          success: true
-        };
-      }
-      throw err;
-    }
+      })
+    );
+
+    return {
+      ...result,
+      operation_results: result.operation_results || [],
+      raw: result.raw || null,
+      success: true
+    };
   }
 
   const client = await getSigningClient(options);
@@ -290,27 +288,10 @@ async function broadcastOperation(operation: any, options: Record<string, any> =
       throw new Error('accountName is required');
     }
 
-    const daemonTimeoutMs = Number.isFinite(Number(options.daemonTimeoutMs))
-      ? Number(options.daemonTimeoutMs)
-      : undefined;
-    // Clamp the broadcast request timeout up to the default outer window: the
-    // daemon's inner deadline (25s) must be allowed to fire and reply a typed
-    // BROADCAST_DEADLINE before this socket timer. A caller-supplied short
-    // timeout would time out mid-broadcast — a false uncertain.
-    const requestTimeoutMs = Number.isFinite(Number(options.daemonRequestTimeoutMs))
-      ? Math.max(Number(options.daemonRequestTimeoutMs), DEFAULT_BROADCAST_TIMEOUT_MS)
-      : undefined;
-
-    await waitForCredentialDaemon(daemonTimeoutMs, options);
-
-    let { sessionId, botHmacSecret } = await resolveSessionCredentials(accountName, options);
-
-    async function doBroadcast(sid: string | null | undefined, secret: string | null) {
+    return viaCredentialDaemon(accountName, options, async (daemonOptions) => {
       const result = await broadcastOperationViaCredentialDaemon(accountName, operation, {
-        socketPath: options.socketPath,
-        timeoutMs: requestTimeoutMs,
-        sessionId: sid,
-        botHmacSecret: secret
+        ...daemonOptions,
+        batchId: options.batchId || null
       });
       const operationResults =
         (result && Array.isArray(result.operation_results) && result.operation_results) ||
@@ -318,26 +299,7 @@ async function broadcastOperation(operation: any, options: Record<string, any> =
         (Array.isArray(result) && result[0] && result[0].trx && Array.isArray(result[0].trx.operation_results) && result[0].trx.operation_results) ||
         [];
       return { success: true, raw: result, operation_results: operationResults };
-    }
-
-    try {
-      return await doBroadcast(sessionId, botHmacSecret);
-    } catch (err: any) {
-      const msg = String(getErrorMessage(err) || err);
-      if (msg.includes(DAEMON_ERRORS.SOURCE_AUTH_DENIED) || msg.includes(DAEMON_ERRORS.SESSION_EXPIRED)) {
-        const isSourceAuthError = msg.includes(DAEMON_ERRORS.SOURCE_AUTH_DENIED);
-        console.warn(`[CLAW] Session/HMAC error, re-resolving credentials and retrying: ${msg}`);
-        if (isSourceAuthError) {
-          _sendSighupToDaemon();
-        }
-        const retry = await resolveSessionCredentials(accountName, options);
-        if (isSourceAuthError) {
-          await new Promise(r => setTimeout(r, 500));
-        }
-        return await doBroadcast(retry.sessionId, retry.botHmacSecret);
-      }
-      throw err;
-    }
+    });
   }
 
   const client = await getSigningClient(options);
@@ -348,5 +310,5 @@ async function broadcastOperation(operation: any, options: Record<string, any> =
   }
 }
 
-export { broadcastOperation, createSigningClient, createSigningClientFromCredentialDaemon, executeOperations, getSigningClient, resolveAccountName }
+export { broadcastOperation, executeOperations, getSigningClient, resolveAccountName }
 

package/claw/modules/claw_bridge.ts

@@ -11,7 +11,8 @@ import { buildCloseShortPlan, buildOpenShortPlan, buildTakeProfitPlan, closeShor
 import { launcherRun, launcherDrystart, launcherReset, launcherDisable, launcherPm2Start, launcherPm2Stop, launcherPm2Delete, launcherPm2Restart } from './claw_launcher.js';
 
 
-import type { ClawBridgeOptions, Logger } from './types.js';
+import type { ClawBridgeOptions } from './types.js';
+import { validateMemuCommandArgs } from './memu_bridge.js';
 
 function stripPrivateKey(options: ClawBridgeOptions = {}): ClawBridgeOptions {
   const sanitized = { ...options };
@@ -21,24 +22,37 @@ function stripPrivateKey(options: ClawBridgeOptions = {}): ClawBridgeOptions {
 
 /**
  * Split a "BASE/QUOTE" pair string into { baseSymbol, quoteSymbol }.
- * Throws if the pair does not contain a '/'.
+ * Throws if the value is not a two-segment BASE/QUOTE string — extra segments
+ * are rejected instead of being silently dropped.
  */
 function splitPair(pairValue: string) {
   if (typeof pairValue !== 'string' || !pairValue.includes('/')) {
     throw new Error('pair must be provided as BASE/QUOTE');
   }
 
-  const [baseSymbol, quoteSymbol] = pairValue.split('/');
-  if (!baseSymbol || !quoteSymbol) {
+  const segments = pairValue.split('/');
+  if (segments.length !== 2 || !segments[0] || !segments[1]) {
     throw new Error('pair must be provided as BASE/QUOTE');
   }
 
   return {
-    baseSymbol: baseSymbol.trim(),
-    quoteSymbol: quoteSymbol.trim()
+    baseSymbol: segments[0].trim(),
+    quoteSymbol: segments[1].trim()
   };
 }
 
+/**
+ * Resolve explicit asset symbols or fall back to the parsed pair option.
+ * Returns null when neither is available so callers can raise their own
+ * command-specific error.
+ */
+function resolvePairSymbols(safeOptions: ClawBridgeOptions) {
+  if (!safeOptions.pair) {
+    return null;
+  }
+  return splitPair(safeOptions.pair);
+}
+
 /**
  * Extract a profile context reference string from command options.
  * Returns the first matching field: botRef, identifier, botId, or pair.
@@ -47,6 +61,25 @@ function getProfileContextRef(options: ClawBridgeOptions = {}): string | null {
   return options.botRef || options.identifier || options.botId || options.pair || null;
 }
 
+const MEMU_COMMAND_MAP: Record<string, string> = {
+  'memu-memorize': 'memorize',
+  'memu-retrieve': 'retrieve',
+  'memu-create-item': 'create-item',
+  'memu-update-item': 'update-item',
+  'memu-delete-item': 'delete-item',
+  'memu-memorize-conversation': 'memorize-conversation',
+  'memu-memorize-trading-context': 'memorize-trading-context',
+  'memu-retrieve-trading-context': 'retrieve-trading-context'
+};
+
+/**
+ * Credit runtime commands address bots by botRef or identifier only (never
+ * botId/pair, unlike profile-context).
+ */
+function getCreditRuntimeBotRef(options: ClawBridgeOptions = {}): string | null {
+  return options.botRef || options.identifier || null;
+}
+
 /**
  * Extract and validate the patch object from command options.
  * Throws if patch is missing or not a plain object.
@@ -121,12 +154,12 @@ async function runClawCommand(command: string, options: ClawBridgeOptions = {}):
 
     case 'profile-context':
       return bridge.profiles.getClawProfileContext(
-        safeOptions.botRef || safeOptions.identifier || safeOptions.botId || safeOptions.pair || null,
+        getProfileContextRef(safeOptions),
         safeOptions
       );
 
     case 'market-snapshot': {
-      const pair = safeOptions.pair ? splitPair(safeOptions.pair) : null;
+      const pair = resolvePairSymbols(safeOptions);
       const baseSymbol = safeOptions.baseSymbol || pair?.baseSymbol;
       const quoteSymbol = safeOptions.quoteSymbol || pair?.quoteSymbol;
 
@@ -173,7 +206,7 @@ async function runClawCommand(command: string, options: ClawBridgeOptions = {}):
       });
 
     case 'honest-pair': {
-      const pair = safeOptions.pair ? splitPair(safeOptions.pair) : null;
+      const pair = resolvePairSymbols(safeOptions);
       const assetA = safeOptions.assetA || pair?.baseSymbol;
       const assetB = safeOptions.assetB || pair?.quoteSymbol;
 
@@ -185,7 +218,7 @@ async function runClawCommand(command: string, options: ClawBridgeOptions = {}):
     }
 
     case 'honest-price': {
-      const pair = safeOptions.pair ? splitPair(safeOptions.pair) : null;
+      const pair = resolvePairSymbols(safeOptions);
       const assetA = safeOptions.assetA || pair?.baseSymbol;
       const assetB = safeOptions.assetB || pair?.quoteSymbol;
 
@@ -290,18 +323,14 @@ async function runClawCommand(command: string, options: ClawBridgeOptions = {}):
       return getMpaPosition(safeOptions.accountName || safeOptions.accountRef || accountName, safeOptions.mpaAsset);
 
     case 'credit-runtime-status':
-      return bridge.creditRuntime.getStatus(
-        safeOptions.botRef || safeOptions.identifier || null
-      );
+      return bridge.creditRuntime.getStatus(getCreditRuntimeBotRef(safeOptions));
 
     case 'credit-runtime-refresh':
-      return bridge.creditRuntime.refresh(
-        safeOptions.botRef || safeOptions.identifier || null
-      );
+      return bridge.creditRuntime.refresh(getCreditRuntimeBotRef(safeOptions));
 
     case 'credit-runtime-maintenance':
       return bridge.creditRuntime.runMaintenance(
-        safeOptions.botRef || safeOptions.identifier || null,
+        getCreditRuntimeBotRef(safeOptions),
         safeOptions.context || 'periodic',
         safeOptions,
         options.privateKey
@@ -309,13 +338,13 @@ async function runClawCommand(command: string, options: ClawBridgeOptions = {}):
 
     case 'credit-runtime-watchdog':
       return bridge.creditRuntime.runWatchdog(
-        safeOptions.botRef || safeOptions.identifier || null,
+        getCreditRuntimeBotRef(safeOptions),
         options.privateKey
       );
 
     case 'credit-runtime-reborrows':
       return bridge.creditRuntime.processReborrows(
-        safeOptions.botRef || safeOptions.identifier || null,
+        getCreditRuntimeBotRef(safeOptions),
         options.privateKey
       );
 
@@ -346,72 +375,23 @@ async function runClawCommand(command: string, options: ClawBridgeOptions = {}):
     case 'memu-manifest':
       return require('./memu_bridge').describeMemuBridge(safeOptions);
 
-    case 'memu-memorize': {
-      if (!safeOptions.resourceUrl || !safeOptions.modality) {
-        throw new Error('memu-memorize requires resourceUrl and modality');
-      }
-      return runMemuCommand('memorize', safeOptions);
-    }
-
-    case 'memu-retrieve': {
-      if (!safeOptions.queries) {
-        throw new Error('memu-retrieve requires queries');
-      }
-      return runMemuCommand('retrieve', safeOptions);
-    }
-
+    case 'memu-memorize':
+    case 'memu-retrieve':
     case 'memu-list-categories':
-      return runMemuCommand('list-categories', safeOptions);
-
     case 'memu-list-items':
-      return runMemuCommand('list-items', safeOptions);
-
-    case 'memu-create-item': {
-      if (!(safeOptions.categoryId || safeOptions.categoryName || safeOptions.category) || !safeOptions.summary) {
-        throw new Error('memu-create-item requires categoryId or categoryName, plus summary');
-      }
-      return runMemuCommand('create-item', safeOptions);
-    }
-
-    case 'memu-update-item': {
-      if (!safeOptions.itemId || !safeOptions.updates) {
-        throw new Error('memu-update-item requires itemId and updates');
-      }
-      return runMemuCommand('update-item', safeOptions);
-    }
-
-    case 'memu-delete-item': {
-      if (!safeOptions.itemId) {
-        throw new Error('memu-delete-item requires itemId');
-      }
-      return runMemuCommand('delete-item', safeOptions);
-    }
-
+    case 'memu-create-item':
+    case 'memu-update-item':
+    case 'memu-delete-item':
     case 'memu-clear':
-      return runMemuCommand('clear', safeOptions);
-
     case 'memu-status':
-      return runMemuCommand('status', safeOptions);
-
-    case 'memu-memorize-conversation': {
-      if (!safeOptions.messages) {
-        throw new Error('memu-memorize-conversation requires messages');
-      }
-      return runMemuCommand('memorize-conversation', safeOptions);
-    }
-
-    case 'memu-memorize-trading-context': {
-      if (!safeOptions.context) {
-        throw new Error('memu-memorize-trading-context requires context');
-      }
-      return runMemuCommand('memorize-trading-context', safeOptions);
-    }
-
+    case 'memu-memorize-conversation':
+    case 'memu-memorize-trading-context':
     case 'memu-retrieve-trading-context': {
-      if (!safeOptions.query) {
-        throw new Error('memu-retrieve-trading-context requires query');
-      }
-      return runMemuCommand('retrieve-trading-context', safeOptions);
+      const memuCommand = MEMU_COMMAND_MAP[command] || command.replace(/^memu-/, '');
+      // Shared validation with runMemuCommand/memu_mcp_server so every surface
+      // rejects missing args with the same message.
+      validateMemuCommandArgs(memuCommand, safeOptions);
+      return runMemuCommand(memuCommand, safeOptions);
     }
 
     default: