dexbot 1.4.19 → 1.4.21

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:

package/claw/modules/claw_catalog.ts

@@ -51,14 +51,6 @@ function booleanSchema(description: any) {
   };
 }
 
-function stringArraySchema(description: any) {
-  return {
-    type: 'array',
-    items: { type: 'string' },
-    ...(description ? { description } : {})
-  };
-}
-
 function pairArraySchema(description: any) {
   return {
     type: 'array',
@@ -173,6 +165,45 @@ function payloadTool(argsDesc: string, schema: any, overrides: any) {
   });
 }
 
+// Shared payload schemas for paired execute/plan tools so the two surfaces
+// cannot drift apart.
+function honestPairPayloadSchema() {
+  return objectSchema({
+    assetA: stringSchema('First asset symbol'),
+    assetB: stringSchema('Second asset symbol'),
+    pair: stringSchema('Pair such as HONEST.USD/BTS')
+  });
+}
+
+function shortLegPayloadSchema() {
+  return objectSchema({
+    accountName: stringSchema('BitShares account name'),
+    mpaAsset: stringSchema('MPA asset symbol'),
+    debtAmount: numberSchema('Debt amount to borrow'),
+    collateralAmount: numberSchema('Collateral to lock'),
+    sellPriceInBts: numberSchema('Sell price in BTS'),
+    targetCollateralRatio: numberSchema('Optional target collateral ratio')
+  }, ['mpaAsset', 'debtAmount', 'collateralAmount', 'sellPriceInBts']);
+}
+
+function takeProfitPayloadSchema() {
+  return objectSchema({
+    accountName: stringSchema('BitShares account name'),
+    mpaAsset: stringSchema('MPA asset symbol'),
+    amountToCover: numberSchema('Amount to cover'),
+    buyPriceInBts: numberSchema('Buy price in BTS')
+  }, ['mpaAsset', 'amountToCover', 'buyPriceInBts']);
+}
+
+function closeShortPayloadSchema() {
+  return objectSchema({
+    accountName: stringSchema('BitShares account name'),
+    mpaAsset: stringSchema('MPA asset symbol'),
+    amountToRepay: numberSchema('Debt amount to repay'),
+    releaseCollateralDelta: numberSchema('Optional collateral release amount')
+  }, ['mpaAsset', 'amountToRepay']);
+}
+
 function launcherTool(command: string, description: string, toolName: string, botNameDesc = 'Bot name as defined in profiles/bots.json. Omit for all active bots.') {
   return payloadTool(
     `JSON object with botName (optional), profileRoot (optional)`,
@@ -321,8 +352,8 @@ const CLAW_TOOL_CATALOG = Object.freeze([
     }),
     toolName: 'claw_honest_context'
   }),
-  payloadTool('JSON object with assetA and assetB, or pair', objectSchema({ assetA: stringSchema('First asset symbol'), assetB: stringSchema('Second asset symbol'), pair: stringSchema('Pair such as HONEST.USD/BTS') }), { command: 'honest-pair', description: 'Resolve HONEST pair context', toolName: 'claw_honest_pair' }),
-  payloadTool('JSON object with assetA and assetB, or pair', objectSchema({ assetA: stringSchema('First asset symbol'), assetB: stringSchema('Second asset symbol'), pair: stringSchema('Pair such as HONEST.USD/BTS') }), { command: 'honest-price', description: 'Resolve HONEST pair price', toolName: 'claw_honest_price' }),
+  payloadTool('JSON object with assetA and assetB, or pair', honestPairPayloadSchema(), { command: 'honest-pair', description: 'Resolve HONEST pair context', toolName: 'claw_honest_pair' }),
+  payloadTool('JSON object with assetA and assetB, or pair', honestPairPayloadSchema(), { command: 'honest-price', description: 'Resolve HONEST pair price', toolName: 'claw_honest_price' }),
   createToolDefinition({
     command: 'create-limit-order',
     description: 'Create a BitShares limit order',
@@ -480,12 +511,12 @@ const CLAW_TOOL_CATALOG = Object.freeze([
     risk: 'execute',
     toolName: 'claw_settle_mpa'
   }),
-  payloadTool('JSON object with accountName, mpaAsset, debtAmount, collateralAmount, sellPriceInBts, optional targetCollateralRatio', objectSchema({ accountName: stringSchema('BitShares account name'), mpaAsset: stringSchema('MPA asset symbol'), debtAmount: numberSchema('Debt amount to borrow'), collateralAmount: numberSchema('Collateral to lock'), sellPriceInBts: numberSchema('Sell price in BTS'), targetCollateralRatio: numberSchema('Optional target collateral ratio') }, ['mpaAsset', 'debtAmount', 'collateralAmount', 'sellPriceInBts']), { command: 'open-short-bts', description: 'Build and execute the open leg of a BTS-backed short', risk: 'execute', toolName: 'claw_open_short_bts' }),
-  payloadTool('JSON object with accountName, mpaAsset, debtAmount, collateralAmount, sellPriceInBts', objectSchema({ accountName: stringSchema('BitShares account name'), mpaAsset: stringSchema('MPA asset symbol'), debtAmount: numberSchema('Debt amount to borrow'), collateralAmount: numberSchema('Collateral to lock'), sellPriceInBts: numberSchema('Sell price in BTS') }, ['mpaAsset', 'debtAmount', 'collateralAmount', 'sellPriceInBts']), { command: 'build-open-short-plan', description: 'Build the open-short plan without broadcasting', risk: 'plan', toolName: 'claw_build_open_short_plan' }),
-  payloadTool('JSON object with accountName, mpaAsset, amountToCover, buyPriceInBts', objectSchema({ accountName: stringSchema('BitShares account name'), mpaAsset: stringSchema('MPA asset symbol'), amountToCover: numberSchema('Amount to cover'), buyPriceInBts: numberSchema('Buy price in BTS') }, ['mpaAsset', 'amountToCover', 'buyPriceInBts']), { command: 'take-profit-bts', description: 'Place the take-profit leg for a BTS-backed short', risk: 'execute', toolName: 'claw_take_profit_bts' }),
-  payloadTool('JSON object with accountName, mpaAsset, amountToCover, buyPriceInBts', objectSchema({ accountName: stringSchema('BitShares account name'), mpaAsset: stringSchema('MPA asset symbol'), amountToCover: numberSchema('Amount to cover'), buyPriceInBts: numberSchema('Buy price in BTS') }, ['mpaAsset', 'amountToCover', 'buyPriceInBts']), { command: 'build-take-profit-plan', description: 'Build the take-profit plan without broadcasting', risk: 'plan', toolName: 'claw_build_take_profit_plan' }),
-  payloadTool('JSON object with accountName, mpaAsset, amountToRepay, optional releaseCollateralDelta', objectSchema({ accountName: stringSchema('BitShares account name'), mpaAsset: stringSchema('MPA asset symbol'), amountToRepay: numberSchema('Debt amount to repay'), releaseCollateralDelta: numberSchema('Optional collateral release amount') }, ['mpaAsset', 'amountToRepay']), { command: 'close-short-bts', description: 'Close a BTS-backed short', risk: 'execute', toolName: 'claw_close_short_bts' }),
-  payloadTool('JSON object with accountName, mpaAsset, amountToRepay, optional releaseCollateralDelta', objectSchema({ accountName: stringSchema('BitShares account name'), mpaAsset: stringSchema('MPA asset symbol'), amountToRepay: numberSchema('Debt amount to repay'), releaseCollateralDelta: numberSchema('Optional collateral release amount') }, ['mpaAsset', 'amountToRepay']), { command: 'build-close-short-plan', description: 'Build the close-short plan without broadcasting', risk: 'plan', toolName: 'claw_build_close_short_plan' }),
+  payloadTool('JSON object with accountName, mpaAsset, debtAmount, collateralAmount, sellPriceInBts, optional targetCollateralRatio', shortLegPayloadSchema(), { command: 'open-short-bts', description: 'Build and execute the open leg of a BTS-backed short', risk: 'execute', toolName: 'claw_open_short_bts' }),
+  payloadTool('JSON object with accountName, mpaAsset, debtAmount, collateralAmount, sellPriceInBts, optional targetCollateralRatio', shortLegPayloadSchema(), { command: 'build-open-short-plan', description: 'Build the open-short plan without broadcasting', risk: 'plan', toolName: 'claw_build_open_short_plan' }),
+  payloadTool('JSON object with accountName, mpaAsset, amountToCover, buyPriceInBts', takeProfitPayloadSchema(), { command: 'take-profit-bts', description: 'Place the take-profit leg for a BTS-backed short', risk: 'execute', toolName: 'claw_take_profit_bts' }),
+  payloadTool('JSON object with accountName, mpaAsset, amountToCover, buyPriceInBts', takeProfitPayloadSchema(), { command: 'build-take-profit-plan', description: 'Build the take-profit plan without broadcasting', risk: 'plan', toolName: 'claw_build_take_profit_plan' }),
+  payloadTool('JSON object with accountName, mpaAsset, amountToRepay, optional releaseCollateralDelta', closeShortPayloadSchema(), { command: 'close-short-bts', description: 'Close a BTS-backed short', risk: 'execute', toolName: 'claw_close_short_bts' }),
+  payloadTool('JSON object with accountName, mpaAsset, amountToRepay, optional releaseCollateralDelta', closeShortPayloadSchema(), { command: 'build-close-short-plan', description: 'Build the close-short plan without broadcasting', risk: 'plan', toolName: 'claw_build_close_short_plan' }),
   createToolDefinition({
     command: 'mpa-position',
     description: 'Read the on-chain MPA position for an account',
@@ -778,7 +809,7 @@ function getClawToolCatalog() {
   return CLAW_TOOL_CATALOG.map(cloneTool);
 }
 
-function buildClawCommandExamples(scriptPath = 'tsx scripts/claw_bridge.ts') {
+function buildClawCommandExamples(scriptPath = 'tsx claw/scripts/claw_bridge.ts') {
   return CLAW_TOOL_CATALOG
     .filter((tool) => Array.isArray(tool.exampleArgs))
     .map((tool) => [

package/claw/modules/claw_infra.ts

@@ -15,8 +15,6 @@ import { acquireFileLock } from '../../market_adapter/utils/file_lock.js';
 import { clone } from './utils.js';
 const storage = getStorage();
 
-import { createPositionManagerWatcher, parsePositionManagerWatchArgs, runPositionManagerWatch } from './position_manager_watch.js';
-
 import type {
   RuntimeContextOptions,
   CredentialClientOptions,
@@ -27,9 +25,7 @@ import type {
 } from './types.js';
 import { getErrorMessage } from '../../modules/utils/errors.js';
 
-const CLAW_ROOT = PATHS.CLAW.DIR;
 const DEFAULT_DATA_DIR = PATHS.CLAW.DATA_DIR;
-const DEFAULT_STATE_DIR = PATHS.CLAW.STATE_DIR;
 
 
 /**
@@ -332,5 +328,5 @@ function createClawInfrastructure(options: ClawInfrastructureOptions = {}) {
   };
 }
 
-export { DEFAULT_DATA_DIR, DEFAULT_STATE_DIR, createBitsharesClient, createClawInfrastructure, createCredentialClient, createHonestEcosystemAdapter, createMarketAdapter, createOrderTools, createRuntimeContext, createStateStore, createPositionManagerWatcher, parsePositionManagerWatchArgs, runPositionManagerWatch }
+export { createClawInfrastructure, createRuntimeContext, createStateStore }