dexbot 1.4.15 → 1.4.17

package/claw/modules/claw_manifest.ts

@@ -16,7 +16,15 @@ function groupCommandsByRisk(tools: any[]) {
 
 function describeClawBridge(options: Record<string, any> = {}) {
   const tools = getClawToolCatalog();
-  const focusedRuntime = getSupportedClawRuntime(options.runtimeName || options.runtime);
+  // options.runtime may be a string (runtime name) or an object
+  // (e.g. { name: 'openfang', ... } from createClawInfrastructure). Normalize
+  // both so an object never stringifies to "[object Object]".
+  const runtimeName =
+    options.runtimeName ||
+    (typeof options.runtime === 'object' && options.runtime !== null
+      ? options.runtime.name
+      : options.runtime);
+  const focusedRuntime = getSupportedClawRuntime(runtimeName);
 
   return {
     compatibility: {

package/claw/modules/claw_skill_md.ts

@@ -1,15 +1,33 @@
 
 import { getStorage } from '../../modules/storage/index.js';
 import { path } from '../../modules/path_api.js';
+import { PATHS } from '../../modules/paths.js';
 import { getClawToolCatalog } from './claw_catalog.js';
 import { getSupportedClawRuntime } from './claw_runtime_matrix.js';
-import { buildBridgeCommand, buildSkillTomlLines, createTool, normalizeRepoRoot, normalizeProfileRoot } from './skill_utils.js';
+import { buildSkillTomlLines, createTool, normalizeRepoRoot, normalizeProfileRoot, shellQuote } from './skill_utils.js';
 const storage = getStorage();
 
 function normalizeClawRepoRoot(repoRoot: string) {
   return normalizeRepoRoot(repoRoot);
 }
 
+// Generated docs must reference scripts that actually exist. Prefer the built
+// .js (dist layout); fall back to the .ts source run through tsx.
+function resolveScriptInvocation(repoRoot: string, name: string) {
+  const jsPath = path.join(repoRoot, 'scripts', `${name}.js`);
+  if (storage.exists(jsPath)) {
+    return { command: 'node', script: jsPath };
+  }
+  return { command: 'npx tsx', script: path.join(repoRoot, 'scripts', `${name}.ts`) };
+}
+
+function buildBridgeInvocation(repoRoot: string, profileRoot: string, command: string, extraArgs: any[] = []) {
+  const { command: runner, script } = resolveScriptInvocation(repoRoot, 'claw_bridge');
+  return [runner, script, command, '--profile-root', profileRoot, ...extraArgs]
+    .map((part, index) => (index === 0 ? String(part) : shellQuote(part)))
+    .join(' ');
+}
+
 function buildToolSummary(runtimeName: string) {
   const tools = getClawToolCatalog().filter((tool: any) => tool.runtimes.includes(runtimeName));
   const byRisk = tools.reduce((groups: Record<string, any>, tool: any) => {
@@ -29,9 +47,12 @@ function buildToolSummary(runtimeName: string) {
 }
 
 function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string) {
-  const mcpScriptPath = path.join(repoRoot, 'scripts', 'claw_mcp_server.js').replace(/\\/g, '/');
-  const mcpCommand = `node ${mcpScriptPath}`;
-  const mcpArgs = `["${mcpScriptPath}", "--profile-root", "${profileRoot}"]`;
+  const { command, script: mcpScriptPath } = resolveScriptInvocation(repoRoot, 'claw_mcp_server');
+  // command is 'node' or 'npx tsx'; split so the config blocks can set the
+  // executable and args correctly for both the built and source layouts.
+  const runnerParts = command.split(' ');
+  const mcpExec = runnerParts[0];
+  const mcpArgs = `[${[...runnerParts.slice(1), mcpScriptPath, '--profile-root', profileRoot].map((part: any) => JSON.stringify(part)).join(', ')}]`;
 
   switch (runtime.runtime) {
     case 'hermes':
@@ -45,7 +66,7 @@ function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string)
         '```yaml',
         'mcp_servers:',
         '  claw:',
-        '    command: "node"',
+        `    command: "${mcpExec}"`,
         `    args: ${mcpArgs}`,
         '```',
         '',
@@ -72,7 +93,7 @@ function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string)
         '  "tools": {',
         '    "mcpServers": {',
         '      "claw": {',
-        `        "command": "node",`,
+        `        "command": "${mcpExec}",`,
         `        "args": ${mcpArgs}`,
         '      }',
         '    }',
@@ -100,7 +121,7 @@ function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string)
         '        "claw": {',
         '          "enabled": true,',
         '          "type": "stdio",',
-        '          "command": "node",',
+        `          "command": "${mcpExec}",`,
         `          "args": ${mcpArgs}`,
         '        }',
         '      }',
@@ -129,7 +150,7 @@ function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string)
         '.claude/skills/bitshares-claw/SKILL.md',
         '```',
         '',
-        'Use the local JSON bridge in `scripts/claw_bridge.js --runtime nanoclaw` when you want the NanoClaw runtime to talk to DEXBot2.',
+        'Use the local JSON bridge in `scripts/claw_bridge --runtime nanoclaw` when you want the NanoClaw runtime to talk to DEXBot2.',
         '',
         `Set \`DEXBOT_PROFILE_ROOT=${profileRoot}\` if you want a default profile root outside tool args.`
       ].join('\n');
@@ -146,7 +167,7 @@ function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string)
         '~/.openfang/skills/bitshares-claw/SKILL.md',
         '```',
         '',
-        'Use the local JSON bridge in `scripts/claw_bridge.js --runtime openfang` when you want the OpenFang runtime to talk to DEXBot2.',
+        'Use the local JSON bridge in `scripts/claw_bridge --runtime openfang` when you want the OpenFang runtime to talk to DEXBot2.',
         '',
         `Set \`DEXBOT_PROFILE_ROOT=${profileRoot}\` if you want a default profile root outside tool args.`
       ].join('\n');
@@ -187,7 +208,7 @@ function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string)
         'Start the memU MCP server:',
         '',
         '```bash',
-        `tsx ${path.join(repoRoot, 'scripts', 'memu_mcp_server.ts').replace(/\\/g, '/')} --memu-dir ${path.join(repoRoot, 'data', 'memu').replace(/\\/g, '/')}`,
+        `tsx ${path.join(repoRoot, 'scripts', 'memu_mcp_server.ts').replace(/\\/g, '/')} --memu-dir ${PATHS.CLAW.MEMU_DIR.replace(/\\/g, '/')}`,
         '```',
         '',
         'Or use the npm script:',
@@ -209,7 +230,7 @@ function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string)
         '',
         `Use the native ${runtime.nativeIntegration} path for ${runtime.runtime}.`,
         '',
-        `Preferred bridge command: \`${mcpCommand} --profile-root ${profileRoot}\``
+        `Preferred bridge command: \`${command} ${mcpScriptPath} --profile-root ${profileRoot}\``
       ].join('\n');
   }
 }
@@ -237,8 +258,8 @@ function buildRuntimeSkillToml(runtime: any, repoRoot: string, profileRoot: stri
     .map((tool: any) => createTool(
       tool.toolName,
       tool.description,
-      buildBridgeCommand(
-        path.join(repoRoot, 'scripts', 'claw_bridge.js').replace(/\\/g, '/'),
+      buildBridgeInvocation(
+        repoRoot,
         profileRoot,
         tool.command,
         tool.extraArgs

package/claw/modules/credit_runtime_adapter.ts

@@ -1,18 +1,17 @@
 
-import { path } from '../../modules/path_api.js';
-import { Config } from '../../modules/config.js';
+import { PATHS } from '../../modules/paths.js';
 import CreditRuntime from '../../modules/credit_runtime.js';
 import { getErrorMessage } from '../../modules/utils/errors.js';
 'use strict';
 
 
-const DEFAULT_CREDIT_RUNTIME_DIR = 'profiles/credit_runtime';
-
 function createCreditRuntimeAdapter(infra: any, options: Record<string, any> = {}) {
   const _runtimes = new Map<string, any>();
-  const _stateDir: string =
-    options.stateDir ||
-    path.join(infra.runtime?.profileRoot || Config.CWD, DEFAULT_CREDIT_RUNTIME_DIR);
+  // Mirror the bot-side credit runtime state dir (PATHS.CREDIT_RUNTIME_DIR),
+  // so claw status/maintenance/watchdog see the same persisted state. The old
+  // `profileRoot/profiles/credit_runtime` join double-counted the profiles
+  // segment and ignored the resolver.
+  const _stateDir: string = options.stateDir || PATHS.CREDIT_RUNTIME_DIR;
 
   function _buildBotShim(botEntry: Record<string, any>): any {
     return {
@@ -38,6 +37,19 @@ function createCreditRuntimeAdapter(infra: any, options: Record<string, any> = {
     };
   }
 
+  // Config fingerprint so debtPolicy / asset / account edits are picked up
+  // instead of being masked by a permanently cached runtime instance.
+  function _botFingerprint(botEntry: Record<string, any>): string {
+    return JSON.stringify({
+      assetA: botEntry.assetA,
+      assetB: botEntry.assetB,
+      botKey: botEntry.botKey,
+      debtPolicy: botEntry.debtPolicy,
+      name: botEntry.name,
+      preferredAccount: botEntry.preferredAccount,
+    });
+  }
+
   async function _resolveBotEntry(botRef: string | null): Promise<Record<string, any> | null> {
     if (!botRef) return null;
     try {
@@ -54,16 +66,22 @@ function createCreditRuntimeAdapter(infra: any, options: Record<string, any> = {
   async function _getRuntime(botRef: string | null): Promise<any> {
     if (!botRef) return null;
     const cacheKey = botRef;
-    let runtime = _runtimes.get(cacheKey);
-    if (runtime) return runtime;
-
     const botEntry = await _resolveBotEntry(botRef);
     if (!botEntry) return null;
-    if (!botEntry.debtPolicy) return null;
+    if (!botEntry.debtPolicy) {
+      // Config now has no debtPolicy; drop any stale cached runtime.
+      _runtimes.delete(cacheKey);
+      return null;
+    }
+
+    const fingerprint = _botFingerprint(botEntry);
+    const cached = _runtimes.get(cacheKey);
+    if (cached && cached._fingerprint === fingerprint) return cached;
 
     const botShim = _buildBotShim(botEntry);
-    runtime = new CreditRuntime(botShim, { stateDir: _stateDir });
+    const runtime = new CreditRuntime(botShim, { stateDir: _stateDir });
     await runtime.loadState();
+    (runtime as any)._fingerprint = fingerprint;
     _runtimes.set(cacheKey, runtime);
     return runtime;
   }

package/claw/modules/decision_loop.ts

@@ -41,6 +41,9 @@ function getTrendAnalyzer() {
  */
 const analyzers = new Map();
 const analyzerConfigs = new Map();
+// Cached premium per market so the same-market reuse path reports the same
+// premium that the fresh path computed instead of a null placeholder.
+const marketPremiums = new Map();
 
 function configChanged(mpaSymbol: string, config: Record<string, any>) {
   const prev = analyzerConfigs.get(mpaSymbol);
@@ -80,6 +83,7 @@ async function evaluate(accountName: string, options: Record<string, any> = {})
       evaluatedAt: new Date().toISOString(),
       positionCount: 0,
       positions: [],
+      summary: buildSummary([]),
     };
   }
 
@@ -98,7 +102,10 @@ async function evaluate(accountName: string, options: Record<string, any> = {})
         const trendInput = await fetchTrendInput(mpa);
         if (trendInput.marketPrice != null && trendInput.feedPrice != null) {
           const analyzer = getOrCreateAnalyzer(mpa, analyzerConfig);
-          const result = analyzer.update(trendInput.marketPrice, trendInput.feedPrice);
+          // KalmanTrendAnalyzer.update accepts a single price series; the feed
+          // price is tracked separately (and surfaced via premium below).
+          const result = analyzer.update(trendInput.marketPrice);
+          marketPremiums.set(mpa, trendInput.premium);
           trendSignal = {
             trend: result.trend,
             confidence: result.confidence,
@@ -116,7 +123,8 @@ async function evaluate(accountName: string, options: Record<string, any> = {})
         trendSignal = {
           trend: snapshot.trend,
           confidence: snapshot.confidence,
-          premium: snapshot.premium?.percent || null,
+          // TrendAnalysis has no premium field; reuse the cached market premium.
+          premium: marketPremiums.get(mpa) ?? null,
         };
       }
     }

package/claw/modules/dexbot_profiles.ts

@@ -9,6 +9,7 @@ import { writeJsonFileAtomic as baseWriteJsonFileAtomic } from '../../modules/bo
 import { acquireFileLock } from '../../market_adapter/utils/file_lock.js';
 import { assertNoDuplicateBotKeys } from '../../modules/bot_settings.js';
 import { clone } from './utils.js';
+import { createBotKey, sanitizeKey } from '../../modules/account_orders.js';
 const storage = getStorage();
 
 import type { BotSettings, ProfileOptions, Logger, ClawProfileBundle } from './types.js';
@@ -601,30 +602,6 @@ function buildBotSettingsView(bot: Record<string, any> | null, bundle: ClawProfi
   };
 }
 
-/**
- * Sanitize an arbitrary value into a lowercase, hyphenated bot-key string.
- */
-function sanitizeKey(source: any) {
-  if (!source) return 'bot';
-  return String(source)
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '') || 'bot';
-}
-
-function createBotKey(bot: any, index: any) {
-  if (bot && bot.name) {
-    return sanitizeKey(bot.name);
-  }
-  const identifier = bot && bot.assetA && bot.assetB
-    ? `${bot.assetA}/${bot.assetB}`
-    : bot && bot.assetAId && bot.assetBId
-      ? `${bot.assetAId}/${bot.assetBId}`
-      : `bot-${index}`;
-  return `${sanitizeKey(identifier)}-${index}`;
-}
-
 /**
  * Extract raw bot entries from a bots.json settings object.
  * Handles both array format ({ bots: [...] }) and single-bot object format.
@@ -759,7 +736,10 @@ function resolveProfilesDir(profileRoot: any) {
     return root;
   }
 
-  return Config.CWD ? path.resolve(Config.CWD, 'profiles') : PATHS.PROFILES_DIR;
+  // Fresh default: the central resolver (home for fresh/npm installs, with
+  // legacy repo/cwd migration and DEXBOT_PROFILE_ROOT override). Do not fall
+  // back to a bare CWD/profiles — that ignored a migrated home config.
+  return PATHS.PROFILES_DIR;
 }
 
 function readJsonFile(filePath: any) {

package/claw/modules/feed_price_source.ts

@@ -11,7 +11,7 @@
 
 import { getAsset, getBackingAsset, getBitassetData, dbCall } from './chain_queries.js';
 import { computeBtsPerMpa } from './mpa_utils.js';
-import { roundTo } from '../../modules/utils/math_utils.js';
+import { roundTo } from '../../modules/order/utils/math.js';
 'use strict';
 
 

package/claw/modules/honest_ecosystem.ts

@@ -24,6 +24,11 @@ const HARDCODED_HONEST_MONEY_BTS_POOL = {
   withdrawalFeePercent: 0
 };
 
+// Live pool reserves are cached briefly so repeated snapshot calls do not
+// hammer the node; failures are never cached so the fallback retries.
+const POOL_RESERVES_CACHE_TTL_MS = 60_000;
+let _poolReservesCache: { poolId: string; ts: number; value: any } | null = null;
+
 
 function isMpa(asset: any) {
   return Boolean(asset && asset.bitasset_data_id);
@@ -34,22 +39,38 @@ function isHonestAsset(asset: any) {
 }
 
 async function fetchLivePoolReserves(poolId: string = HARDCODED_POOL_ID) {
+  if (_poolReservesCache && _poolReservesCache.poolId === poolId &&
+      Date.now() - _poolReservesCache.ts < POOL_RESERVES_CACHE_TTL_MS) {
+    // Clone on read so consumers mutating the returned object cannot poison
+    // the shared cache for the remaining TTL window.
+    return clone(_poolReservesCache.value);
+  }
+
   try {
     const objects = await getObjects([poolId]);
     const pool = objects && objects[0];
     if (!pool || pool.asset_a == null || pool.asset_b == null) return null;
 
-    const [assetAObj, assetBObj] = await Promise.all([
+    const [assetAObj, assetBObj, shareAssetObj] = await Promise.all([
       getAsset(pool.asset_a),
-      getAsset(pool.asset_b)
+      getAsset(pool.asset_b),
+      getAsset(pool.share_asset).catch(() => null),
     ]);
 
+    // Only report pools that actually trade HONEST.MONEY against BTS as the
+    // reference bridge; a relisted/remapped pool must fall back, not leak
+    // mismatched symbols into the context.
+    const poolSymbols = [assetAObj?.symbol, assetBObj?.symbol];
+    if (!poolSymbols.includes(REFERENCE_SYMBOL) || !poolSymbols.includes(CORE_SYMBOL)) {
+      return null;
+    }
+
     const precisionA = assetAObj?.precision ?? 0;
     const precisionB = assetBObj?.precision ?? 0;
     const balanceA = Number(pool.balance_a) || 0;
     const balanceB = Number(pool.balance_b) || 0;
 
-    return {
+    const result = {
       assetA: {
         amount: precisionA > 0 ? balanceA / Math.pow(10, precisionA) : balanceA,
         symbol: assetAObj?.symbol || CORE_SYMBOL
@@ -59,11 +80,14 @@ async function fetchLivePoolReserves(poolId: string = HARDCODED_POOL_ID) {
         symbol: assetBObj?.symbol || REFERENCE_SYMBOL
       },
       id: poolId,
-      poolSymbol: pool.share_asset || HARDCODED_HONEST_MONEY_BTS_POOL.poolSymbol,
+      // share_asset is an asset ID; prefer its human-readable symbol when resolvable.
+      poolSymbol: shareAssetObj?.symbol || pool.share_asset || HARDCODED_HONEST_MONEY_BTS_POOL.poolSymbol,
       takerFeePercent: pool.taker_fee_percent ?? HARDCODED_HONEST_MONEY_BTS_POOL.takerFeePercent,
       withdrawalFeePercent: pool.withdrawal_fee_percent ?? HARDCODED_HONEST_MONEY_BTS_POOL.withdrawalFeePercent,
       source: 'live-liquidity-pool'
     };
+    _poolReservesCache = { poolId, ts: Date.now(), value: result };
+    return result;
   } catch {
     return null;
   }
@@ -168,8 +192,8 @@ async function resolveHonestPairContext(assetA: any, assetB: any, options: Recor
   }
 
   const bridge = await getHonestMoneyBridge();
-  const assetAEntry = bridge.liquidityPool.reserves.find((entry) => entry.symbol === assetASymbol) || null;
-  const assetBEntry = bridge.liquidityPool.reserves.find((entry) => entry.symbol === assetBSymbol) || null;
+  const assetAEntry = bridge.liquidityPool.reserves.find((entry: any) => entry.symbol === assetASymbol) || null;
+  const assetBEntry = bridge.liquidityPool.reserves.find((entry: any) => entry.symbol === assetBSymbol) || null;
 
   return {
     assetA: {
@@ -184,12 +208,12 @@ async function resolveHonestPairContext(assetA: any, assetB: any, options: Recor
     },
     pool: {
       ...bridge.liquidityPool,
-      source: 'hardcoded-liquidity-pool'
+      source: bridge.source,
     },
     priceBPerA: pairPrice,
     reserveA: assetAEntry ? assetAEntry.amount : null,
     reserveB: assetBEntry ? assetBEntry.amount : null,
-    source: 'hardcoded-liquidity-pool'
+    source: bridge.source
   };
 }
 

package/claw/modules/kibana_price_source.ts

@@ -43,7 +43,10 @@ async function resolveAsset(symbolOrId: string) {
 async function fetchMarketCandles(mpaSymbol: string, config: Record<string, any> = {}) {
   const btsAsset = await resolveAsset('BTS');
   const mpaAsset = await resolveAsset(mpaSymbol);
-  return getMarketCandles(btsAsset, mpaAsset, config);
+  // getMarketCandles(assetA, assetB) prices in B-per-A, so requesting
+  // (mpa, bts) yields BTS-per-MPA to match the live feed_price_source
+  // convention (price = how many BTS for 1 MPA).
+  return getMarketCandles(mpaAsset, btsAsset, config);
 }
 
 /**
@@ -56,7 +59,8 @@ async function fetchMarketCandles(mpaSymbol: string, config: Record<string, any>
 async function fetchMarketClosePrices(mpaSymbol: string, config: Record<string, any> = {}) {
   const btsAsset = await resolveAsset('BTS');
   const mpaAsset = await resolveAsset(mpaSymbol);
-  return getMarketClosePrices(btsAsset, mpaAsset, config);
+  // See fetchMarketCandles: (mpa, bts) yields BTS-per-MPA.
+  return getMarketClosePrices(mpaAsset, btsAsset, config);
 }
 
 // ─── LP Pool Candles (liquidity_pool_exchange) ───────────────────────────────

package/claw/modules/launcher_mode_detector.ts

@@ -1,7 +1,6 @@
 
 import { path } from '../../modules/path_api.js';
 import { getStorage } from '../../modules/storage/index.js';
-import { PATHS } from '../../modules/paths.js';
 import { loadSettingsFile, resolveRawBotEntries } from '../../modules/bot_settings.js';
 import { normalizeProfileDir } from './launcher_paths.js';
 'use strict';
@@ -10,7 +9,7 @@ const storage = getStorage();
 const { ensureDir, readJSON, writeJSON } = storage;
 
 function normalizeMode(mode: string | null | undefined) {
-  const value = typeof mode === 'string' ? mode.trim() : '';
+  const value = typeof mode === 'string' ? mode.trim().toLowerCase() : '';
   return value;
 }
 
@@ -75,20 +74,18 @@ function saveConfig(config: Record<string, any>, options: Record<string, any> =
  * @returns {boolean} True if at least one active bot exists
  */
 function hasActiveBots(options: Record<string, any> = {}) {
-  const BOTS_FILE = PATHS.PROFILES.BOTS_JSON;
+  const BOTS_FILE = path.join(normalizeProfileDir(options), 'bots.json');
 
-  try {
-    if (!storage.exists(BOTS_FILE)) {
-      // No bots.json file yet — user hasn't configured any bots
-      return false;
-    }
-
-    const { config } = loadSettingsFile(BOTS_FILE);
-    const entries = resolveRawBotEntries(config);
-    return entries.some((b: any) => b.active !== false);
-  } catch (err: any) {
+  if (!storage.exists(BOTS_FILE)) {
+    // No bots.json file yet — user hasn't configured any bots
     return false;
   }
+
+  // Parse errors are NOT treated as "no bots": a corrupt config should surface
+  // as a launcher/detection failure instead of silently picking claw-only mode.
+  const { config } = loadSettingsFile(BOTS_FILE);
+  const entries = resolveRawBotEntries(config);
+  return entries.some((b: any) => b.active !== false);
 }
 
 /**

package/claw/modules/launcher_paths.ts

@@ -54,7 +54,10 @@ function normalizeProfileDir(options: Record<string, any> = {}) {
   if (options.profileRoot) {
     return path.resolve(options.profileRoot);
   }
-  return path.join(DEFAULT_ROOT, 'profiles');
+  // Follow the runtime-resolved profiles dir so the launcher config
+  // (launcher.config.json) lives with the rest of user state — including the
+  // home default for fresh checkouts / global npm installs.
+  return PATHS.PROFILES_DIR;
 }
 
 function resolveRuntimeScript(root: string, ...segments: string[]) {

package/claw/modules/liquidity_pools.ts

@@ -11,7 +11,7 @@ function derivePoolPrice(assetA: any, assetB: any, poolRef?: string | null | Rec
   const resolvedPoolRef = typeof poolRef === 'string' ? poolRef : (poolRef && typeof poolRef.poolRef === 'string' ? poolRef.poolRef : null);
   if (resolvedPoolRef) {
     try {
-      const { withPoolRef: wrapWithPoolRef } = requireDexbot2Module('order/utils/withPoolRef') as any;
+      const { withPoolRef: wrapWithPoolRef } = requireDexbot2Module('modules/order/utils/withPoolRef') as any;
       const override = wrapWithPoolRef(client.BitShares, resolvedPoolRef);
       if (override) return override.derivePoolPrice(assetA, assetB);
     } catch (e: any) {
@@ -25,7 +25,7 @@ function derivePrice(assetA: any, assetB: any, mode: any, poolRef?: string | nul
   const system = getDexbotSystem();
   if (poolRef) {
     try {
-      const { derivePriceWithPoolRef: wrapPriceWithPoolRef } = requireDexbot2Module('order/utils/withPoolRef') as any;
+      const { derivePriceWithPoolRef: wrapPriceWithPoolRef } = requireDexbot2Module('modules/order/utils/withPoolRef') as any;
       return wrapPriceWithPoolRef(client.BitShares, assetA, assetB, mode, poolRef);
     } catch (e: any) {
       console.warn(`[liquidity-pools] derivePrice with poolRef failed: ${e?.message || e}`);

package/claw/modules/mcp_utils.ts

@@ -2,6 +2,15 @@ import { hasProcess } from '../../modules/env.js';
 import { Config } from '../../modules/config.js';
 import { runtime } from '../../modules/runtime.js';
 
+// Transport contract: this is a CUSTOM newline-delimited JSON transport, NOT
+// the official LSP-style Content-Length framing from the MCP 2024-11-05 spec.
+// Messages are single-line JSON-RPC 2.0 objects separated by `\n`. Clients
+// that speak the official spec must be configured for this JSONL variant (see
+// claw_runtime_matrix.ts). `protocolVersion` is echoed from the client and is
+// only informational here.
+
+const MAX_PENDING_MESSAGES = 256;
+
 function writeMessage(message: any) {
   if (!hasProcess()) {
     return Promise.reject(new Error('MCP stdio transport not available in this environment'));
@@ -34,13 +43,29 @@ export function failure(id: any, code: any, message: any, data = undefined) {
   });
 }
 
-export function createMessageParser(onMessage: any) {
+export function createMessageParser(onMessage: any, onDrain?: () => void) {
   if (!hasProcess()) {
     throw new Error('MCP stdio transport not available in this environment');
   }
   const decoder = new TextDecoder('utf-8');
   let buffer: Uint8Array = new Uint8Array(0);
   let queue = Promise.resolve();
+  let pending = 0;
+
+  function enqueue(handler: () => any) {
+    pending += 1;
+    queue = queue
+      .then(handler)
+      .catch((error) => {
+        runtime.stderr.write(`${error && error.stack ? error.stack : String(error)}\n`);
+      })
+      .finally(() => {
+        pending -= 1;
+        if (pending === 0 && typeof onDrain === 'function') {
+          onDrain();
+        }
+      });
+  }
 
   function processBuffer() {
     while (true) {
@@ -63,9 +88,7 @@ export function createMessageParser(onMessage: any) {
         continue;
       }
 
-      queue = queue.then(() => onMessage(message)).catch((error) => {
-        runtime.stderr.write(`${error && error.stack ? error.stack : String(error)}\n`);
-      });
+      enqueue(() => onMessage(message));
     }
   }
 
@@ -82,6 +105,11 @@ export function createMessageParser(onMessage: any) {
       buffer = appendUint8(buffer, incoming);
       processBuffer();
       return queue;
+    },
+    // Number of not-yet-settled messages; the caller can pause the input stream
+    // when this grows too large so memory stays bounded.
+    pending() {
+      return pending;
     }
   };
 }
@@ -91,11 +119,24 @@ export async function runMcpServer(parseArgs: (argv: string[]) => Record<string,
     throw new Error('MCP stdio transport not available in this environment');
   }
   const defaults = parseArgs(Config.ARGS);
-  const parser = createMessageParser((message: any) => handleRequest(message, defaults));
+  let stdinPaused = false;
+  const parser = createMessageParser((message: any) => handleRequest(message, defaults), () => {
+    // Queue drained: resume a paused input stream so the process keeps reading.
+    if (stdinPaused) {
+      stdinPaused = false;
+      runtime.stdin!.resume();
+    }
+  });
   let lastQueue = Promise.resolve();
 
   runtime.stdin!.on('data', (chunk) => {
     lastQueue = parser.push(chunk);
+    // Backpressure: if the handler is falling behind, pause stdin until the
+    // queue drains to a safe level.
+    if (!stdinPaused && parser.pending() > MAX_PENDING_MESSAGES) {
+      stdinPaused = true;
+      runtime.stdin!.pause();
+    }
   });
   runtime.stdin!.resume();
 

package/claw/modules/memu_bridge.ts

@@ -8,6 +8,7 @@ import { PATHS } from '../../modules/paths.js';
 import { runtime } from '../../modules/runtime.js';
 import { getErrorMessage } from '../../modules/utils/errors.js';
 import { Config } from '../../modules/config.js';
+import { describeClawBridge } from './claw_manifest.js';
 const storage = getStorage();
 const { ensureDir, unlink: safeUnlink } = storage;
 
@@ -29,6 +30,16 @@ function getSpawn(): any {
 const DEFAULT_MEMU_DIR = PATHS.CLAW.MEMU_DIR;
 const DEFAULT_PYTHON = Config.MEMU_PYTHON;
 
+// Mirror the repo version instead of hardcoding; falls back to a literal only
+// if package.json is somehow unavailable.
+const DEXBOT_VERSION = (() => {
+  try {
+    return require(path.join(PATHS.PROJECT_ROOT, 'package.json')).version;
+  } catch {
+    return '0.1.0';
+  }
+})();
+
 function resolveMemuScript() {
   const candidates = [
     PATHS.CLAW.MEMU_RUNNER_SCRIPT,
@@ -386,9 +397,14 @@ function createMemuBridge(options: Record<string, any> = {}) {
 }
 
 function describeMemuBridge(options: Record<string, any> = {}) {
+  // Merge the standard claw manifest fields so consumers get the same
+  // commands/options/surfaces/tools shape as the other runtimes instead of
+  // special-casing memu.
+  const clawManifest = describeClawBridge(options);
   return {
+    ...clawManifest,
     runtime: 'memu',
-    version: '0.1.0',
+    version: DEXBOT_VERSION,
     description: 'memU proactive memory integration for DEXBot2',
     nativeIntegration: 'subprocess-bridge',
     preferredTransport: 'local-cli-json-or-mcp',

package/claw/modules/position_discovery.ts

@@ -11,7 +11,7 @@
 
 import { loadDexbotOrderUtils } from './dexbot_bridge.js';
 import { computeBtsPerMpa } from './mpa_utils.js';
-import { roundTo } from '../../modules/utils/math_utils.js';
+import { roundTo } from '../../modules/order/utils/math.js';
 'use strict';
 
 import { getAsset, getBackingAsset, getBitassetData, getFullAccount } from './chain_queries.js';