dexbot 1.4.20 → 1.4.21

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',

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 }
 

package/claw/modules/claw_launcher.ts

@@ -56,6 +56,40 @@ function getSpawn(): any {
     return _spawn;
 }
 
+/**
+ * Spawn a detached background child and wait for the spawn itself to succeed.
+ * Spawn failures (missing script, ENOENT, EACCES) are reported asynchronously
+ * via the child's 'error' event; waiting one macrotask lets those surface as a
+ * thrown error instead of callers receiving a false { started: true } result.
+ * A permanent 'error' handler remains attached so late errors are logged
+ * rather than crashing the host with an unhandled 'error' event.
+ */
+function spawnDetached(scriptPath: string, args: string[], cwd: string): Promise<any> {
+    const child = getSpawn()('node', [scriptPath, ...args], {
+        detached: true,
+        stdio: 'ignore',
+        cwd
+    });
+
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        child.on('error', (err: any) => {
+            if (!settled) {
+                settled = true;
+                reject(new Error(`Failed to spawn ${scriptPath}: ${getErrorMessage(err)}`));
+                return;
+            }
+            console.error(`[LAUNCHER] Child process error (${scriptPath}): ${getErrorMessage(err)}`);
+        });
+        setImmediate(() => {
+            if (!settled) {
+                settled = true;
+                resolve(child);
+            }
+        });
+    });
+}
+
 let _pm2: any;
 function getPM2Module(): any {
     if (_pm2 === undefined) {
@@ -88,16 +122,7 @@ async function launcherStart(botName: string | null, options: Record<string, any
     args.push(botName);
   }
 
-  const child = getSpawn()('node', [dexbotPath, ...args], {
-    detached: true,
-    stdio: 'ignore',
-    cwd: ROOT
-  });
-
-  child.on('error', (err: any) => {
-    console.error(`[LAUNCHER] Failed to spawn ${dexbotPath}: ${getErrorMessage(err)}`);
-  });
-
+  const child = await spawnDetached(dexbotPath, args, ROOT);
   child.unref();
 
   return {
@@ -124,16 +149,7 @@ async function launcherDrystart(botName: string | null, options: Record<string,
     args.push(botName);
   }
 
-  const child = getSpawn()('node', [dexbotPath, ...args], {
-    detached: true,
-    stdio: 'ignore',
-    cwd: ROOT
-  });
-
-  child.on('error', (err: any) => {
-    console.error(`[LAUNCHER] Failed to spawn ${dexbotPath}: ${getErrorMessage(err)}`);
-  });
-
+  const child = await spawnDetached(dexbotPath, args, ROOT);
   child.unref();
 
   return {
@@ -158,10 +174,10 @@ async function launcherReset(botName: string | null, options: Record<string, any
   const { config } = loadSettingsFile(PROFILES_BOTS_FILE);
   const entries = normalizeBotEntries(resolveRawBotEntries(config));
 
-  const targets = botName ? entries.filter((b: any) => b.name === botName) : entries.filter((b: any) => b.active);
+  const targets = botName ? entries.filter((b: any) => b.name === botName) : entries.filter((b: any) => b.active !== false);
 
   if (botName && targets.length === 0) {
-    throw new Error(`Bot '${botName}' not found in profiles/bots.json`);
+    throw new Error(`Bot '${botName}' not found in ${PROFILES_BOTS_FILE}`);
   }
 
   const triggered: Array<Record<string, any>> = [];
@@ -221,7 +237,7 @@ async function launcherDisable(botName: string | null, options: Record<string, a
 
   const match = entries.find((b: any) => b.name === botName);
   if (!match) {
-    throw new Error(`Bot '${botName}' not found in profiles/bots.json`);
+    throw new Error(`Bot '${botName}' not found in ${PROFILES_BOTS_FILE}`);
   }
 
   if (match.active === false) {
@@ -252,10 +268,10 @@ async function launcherPm2Start(botName: string | null, options: Record<string,
   const { config } = loadSettingsFile(PROFILES_BOTS_FILE);
   const entries = normalizeBotEntries(resolveRawBotEntries(config));
 
-  const targets = botName ? entries.filter((b: any) => b.name === botName) : entries.filter((b: any) => b.active);
+  const targets = botName ? entries.filter((b: any) => b.name === botName) : entries.filter((b: any) => b.active !== false);
 
   if (botName && targets.length === 0) {
-    throw new Error(`Bot '${botName}' not found or not active in profiles/bots.json`);
+    throw new Error(`Bot '${botName}' not found or not active in ${PROFILES_BOTS_FILE}`);
   }
 
   // Then check if daemon is ready
@@ -292,7 +308,7 @@ async function launcherPm2Start(botName: string | null, options: Record<string,
  * @param {Object} [options={}] - Options
  * @returns {Promise<Object>} { stopped: true, target }
  */
-async function launcherPm2Stop(target: string, options: Record<string, any> = {}) {
+async function launcherPm2Stop(target: string, _options: Record<string, any> = {}) {
   await getPM2Module().stopPM2Processes(target || 'all');
   return {
     stopped: true,
@@ -306,7 +322,7 @@ async function launcherPm2Stop(target: string, options: Record<string, any> = {}
  * @param {Object} [options={}] - Options
  * @returns {Promise<Object>} { deleted: true, target }
  */
-async function launcherPm2Delete(target: string, options: Record<string, any> = {}) {
+async function launcherPm2Delete(target: string, _options: Record<string, any> = {}) {
   await getPM2Module().deletePM2Processes(target || 'all');
   return {
     deleted: true,
@@ -320,7 +336,7 @@ async function launcherPm2Delete(target: string, options: Record<string, any> =
  * @param {Object} [options={}] - Options
  * @returns {Promise<Object>} { restarted: true, target }
  */
-async function launcherPm2Restart(target: string, options: Record<string, any> = {}) {
+async function launcherPm2Restart(target: string, _options: Record<string, any> = {}) {
   await getPM2Module().restartPM2Processes(target || 'all');
   return {
     restarted: true,
@@ -422,16 +438,7 @@ async function launcherClawOnly(options: Record<string, any> = {}) {
   const ROOT = normalizeRoot(options);
   const pm2ScriptPath = resolveRuntimeScript(ROOT, 'pm2.js');
 
-  const child = getSpawn()('node', [pm2ScriptPath, 'claw-only'], {
-    detached: true,
-    stdio: 'ignore',
-    cwd: ROOT
-  });
-
-  child.on('error', (err: any) => {
-    console.error(`[LAUNCHER] Failed to spawn ${pm2ScriptPath}: ${getErrorMessage(err)}`);
-  });
-
+  const child = await spawnDetached(pm2ScriptPath, ['claw-only'], ROOT);
   child.unref();
 
   return {
@@ -459,16 +466,7 @@ async function launcherUnlockStart(botName: string | null, options: Record<strin
     args.push(botName);
   }
 
-  const child = getSpawn()('node', [unlockPath, ...args], {
-    detached: true,
-    stdio: 'ignore',
-    cwd: ROOT
-  });
-
-  child.on('error', (err: any) => {
-    console.error(`[LAUNCHER] Failed to spawn ${unlockPath}: ${getErrorMessage(err)}`);
-  });
-
+  const child = await spawnDetached(unlockPath, args, ROOT);
   child.unref();
 
   return {
@@ -481,5 +479,5 @@ async function launcherUnlockStart(botName: string | null, options: Record<strin
   };
 }
 
-export { launcherRun, launcherStart, launcherDrystart, launcherReset, launcherDisable, launcherPm2Start, launcherPm2Stop, launcherPm2Delete, launcherPm2Restart }
+export { launcherRun, launcherDrystart, launcherReset, launcherDisable, launcherPm2Start, launcherPm2Stop, launcherPm2Delete, launcherPm2Restart }
 

package/claw/modules/claw_skill_md.ts

@@ -237,20 +237,17 @@ function buildRuntimeSetup(runtime: any, repoRoot: string, profileRoot: string)
 }
 
 function buildRuntimeWorkflow(runtime: any) {
-  if (runtime.runtime === 'hermes') {
-    return [
-      '- Start with `claw_manifest`, `claw_runtime`, `claw_profile_context`, `claw_market_snapshot`, `claw_account_snapshot`, or `claw_open_orders`.',
-      '- For MPA and short workflows, use `claw_build_open_short_plan`, `claw_build_take_profit_plan`, or `claw_build_close_short_plan` before executing trades.',
-      '- Use `claw_honest_context`, `claw_honest_pair`, and `claw_honest_price` when the task involves HONEST assets or discovery.',
-      '- The shared Claw MCP server registers raw tool ids such as `claw_manifest`; if Hermes shows a namespaced label in its UI, follow the label shown there.'
-    ].join('\n');
-  }
-
-  return [
+  const baseLines = [
     '- Start with `claw_manifest`, `claw_runtime`, `claw_profile_context`, `claw_market_snapshot`, `claw_account_snapshot`, or `claw_open_orders`.',
     '- For MPA and short workflows, use `claw_build_open_short_plan`, `claw_build_take_profit_plan`, or `claw_build_close_short_plan` before executing trades.',
     '- Use `claw_honest_context`, `claw_honest_pair`, and `claw_honest_price` when the task involves HONEST assets or discovery.'
-  ].join('\n');
+  ];
+
+  if (runtime.runtime === 'hermes') {
+    baseLines.push('- The shared Claw MCP server registers raw tool ids such as `claw_manifest`; if Hermes shows a namespaced label in its UI, follow the label shown there.');
+  }
+
+  return baseLines.join('\n');
 }
 
 function buildRuntimeSkillToml(runtime: any, repoRoot: string, profileRoot: string) {

package/claw/modules/credit_runtime_adapter.ts

@@ -24,7 +24,7 @@ function createCreditRuntimeAdapter(infra: any, options: Record<string, any> = {
         assetA: botEntry.assetA,
         assetB: botEntry.assetB,
       },
-      _log: (msg: string, level?: string) => {
+      _log: (msg: string) => {
         const logger = infra.runtime?.logger || console;
         if (typeof logger.info === 'function') logger.info(`[credit-runtime] ${msg}`);
         else logger.log(`[credit-runtime] ${msg}`);
@@ -100,10 +100,7 @@ function createCreditRuntimeAdapter(infra: any, options: Record<string, any> = {
       const rt = await _getRuntime(botRef);
       if (!rt) {
         try {
-          const bundle = await infra.profiles.loadBundle();
-          const bot = bundle.bots.find(
-            (b: Record<string, any>) => b.botKey === botRef || b.name === botRef,
-          );
+          const bot = await _resolveBotEntry(botRef);
           if (!bot) return { error: `bot not found: ${botRef}` };
           if (!bot.debtPolicy) return { error: `bot ${botRef} has no debtPolicy configured` };
           return { error: `unable to initialize credit runtime for ${botRef}` };
@@ -142,19 +139,6 @@ function createCreditRuntimeAdapter(infra: any, options: Record<string, any> = {
       _ensureSigningKey(rt, privateKey);
       return rt.processPendingReborrows();
     },
-
-    listRuntimes(): any[] {
-      return Array.from(_runtimes.entries())
-        .filter(([_, rt]) => rt.isEnabled())
-        .map(([key, rt]) => ({
-          botKey: key,
-          enabled: rt.isEnabled(),
-        }));
-    },
-
-    getRuntime(botRef: string): any | null {
-      return _runtimes.get(botRef) || null;
-    },
   };
 }
 

package/claw/modules/decision_loop.ts

@@ -186,6 +186,10 @@ function buildSummary(assessments: Array<Record<string, any>>) {
 function resetAnalyzers() {
   analyzers.clear();
   analyzerConfigs.clear();
+  // Premiums belong to the analyzer generation that produced them; keeping
+  // them across a reset would let the reuse path report a stale value from
+  // discarded config.
+  marketPremiums.clear();
 }
 
 export { evaluate, getOrCreateAnalyzer, resetAnalyzers }

package/claw/modules/dexbot_bridge.ts

@@ -78,5 +78,5 @@ function loadDexbotOrderSystemUtils() {
   return requireDexbot2Module('modules/order/utils/system');
 }
 
-export { getDexbot2Root, loadDexbotOrderConstants, loadDexbotOrderSubsystem, loadDexbotOrderSystemUtils, loadDexbotOrderUtils, requireDexbot2Module, resolveDexbot2Path }
+export { getDexbot2Root, loadDexbotOrderConstants, loadDexbotOrderSubsystem, loadDexbotOrderSystemUtils, loadDexbotOrderUtils, requireDexbot2Module }
 

package/claw/modules/dexbot_profiles.ts

@@ -12,7 +12,7 @@ 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';
+import type { BotSettings, ProfileOptions, ClawProfileBundle } from './types.js';
 import { getErrorMessage } from '../../modules/utils/errors.js';
 
 const DEFAULT_MANIFEST_FILE = 'config.json';
@@ -661,7 +661,7 @@ async function normalizeBotEntries(rawEntries: Record<string, any>[], options: P
     if (logger) {
       validateBotEntry(entry, index, logger);
     }
-    const normalized = { active: entry.active === undefined ? true : !!entry.active, ...entry };
+    const normalized = { ...entry, active: entry.active === undefined ? true : !!entry.active };
     results.push({ ...normalized, botIndex: index, botKey: createBotKey(normalized, index) });
   }
   return results;
@@ -1008,8 +1008,8 @@ async function loadDexbotProfileBundle(profileRoot: string | null, options: Part
  * The adapter wraps bundle loading, settings validation, and atomic writes behind
  * per-file locks so concurrent updates do not clobber each other.
  *
- * @returns {Object} Adapter with loadBundle, listBots, findBot, getBotBundle,
- *   getBotSettings, previewBotSettingsUpdate, applyBotSettingsPatch, getProfilesDir
+ * @returns {Object} Adapter with loadBundle, getBotSettings,
+ *   previewBotSettingsUpdate, applyBotSettingsPatch, updateBotSettings, getClawProfileContext
  */
 function createDexbotProfileAdapter(profileRoot: string | null, options: Partial<ProfileOptions> = {}) {
   let cachedBundle: any = null;
@@ -1025,16 +1025,6 @@ function createDexbotProfileAdapter(profileRoot: string | null, options: Partial
     return resolveProfilesDir(profileRoot || options.profileRoot);
   }
 
-  async function listBots({ activeOnly = false, forceReload = false } = {}) {
-    const bundle = await loadBundle(forceReload);
-    return activeOnly ? bundle.activeBots : bundle.bots;
-  }
-
-  async function findBot(identifier: any, forceReload = false) {
-    const bundle = await loadBundle(forceReload);
-    return bundle.bots.find((bot: any) => matchBotIdentifier(bot, identifier)) || null;
-  }
-
   async function getBotBundle(identifier: any, forceReload = false) {
     const bundle = await loadBundle(forceReload);
     const bot = bundle.bots.find((entry: any) => matchBotIdentifier(entry, identifier)) || null;
@@ -1272,20 +1262,14 @@ function createDexbotProfileAdapter(profileRoot: string | null, options: Partial
   }
 
   return {
-    buildClawProfileContext: (bundle: any, contextOptions = {}) => buildClawProfileContext(bundle, contextOptions),
     applyBotSettingsPatch,
-    findBot,
-    getBotBundle,
     getBotSettings,
     getClawProfileContext,
-    getProfilesDir,
-    listBots,
     loadBundle,
     previewBotSettingsUpdate,
-    resolveProfilesDir: () => resolveProfilesDir(profileRoot || options.profileRoot),
     updateBotSettings
   };
 }
 
-export { buildBotSettingsView, createBotKey, createDexbotProfileAdapter, buildClawProfileContext, describeBotSettingMutability, loadDexbotProfileBundle, matchBotIdentifier, normalizeBotSettings, normalizeBotEntries, readTriggerFile, resolveProfilesDir, resolveRawBotEntries, sanitizeKey, validateBotEntry, validateBotSettingsPatch, validateBotSettingsState, writeJsonFileAtomic }
+export { createBotKey, createDexbotProfileAdapter, matchBotIdentifier, normalizeBotEntries, resolveProfilesDir, resolveRawBotEntries, validateBotEntry, writeJsonFileAtomic }
 

package/claw/modules/honest_ecosystem.ts

@@ -88,7 +88,11 @@ async function fetchLivePoolReserves(poolId: string = HARDCODED_POOL_ID) {
     };
     _poolReservesCache = { poolId, ts: Date.now(), value: result };
     return result;
-  } catch {
+  } catch (err: any) {
+    // Never cache failures, but surface them: silently serving the hardcoded
+    // fallback snapshot hides a degraded node and produces confidently-wrong
+    // bridge prices with no telemetry trail.
+    console.warn(`[honest-ecosystem] live pool reserves fetch failed for ${poolId}, using hardcoded fallback: ${err?.message || err}`);
     return null;
   }
 }
@@ -217,10 +221,15 @@ async function resolveHonestPairContext(assetA: any, assetB: any, options: Recor
   };
 }
 
-async function loadHonestAssets({ prefix = DEFAULT_PREFIX, batchSize = 100, maxPages = 100, startSymbol = DEFAULT_PREFIX }: Record<string, any> = {}) {
-  const all = [];
+/**
+ * Paginate list_assets with the shared dedup/boundary rules used across the
+ * HONEST tooling. `onPage` receives each de-duplicated page and accumulates
+ * whatever it needs; returning `false` stops pagination early (e.g. crossing
+ * a prefix boundary).
+ */
+async function paginateListAssets({ batchSize = 100, maxPages = 100, startSymbol = '' }: Record<string, any> = {}, onPage: (pageItems: any[], batch: any[]) => boolean | void) {
   let lowerBound = startSymbol;
-  let previousLastSymbol = null;
+  let previousLastSymbol: string | null = null;
 
   for (let page = 0; page < maxPages; page += 1) {
     const batch = await listAssets(lowerBound, batchSize);
@@ -237,17 +246,24 @@ async function loadHonestAssets({ prefix = DEFAULT_PREFIX, batchSize = 100, maxP
       break;
     }
 
-    const matching = pageItems.filter((asset) => isHonestAsset(asset) && asset.symbol.startsWith(prefix));
-    all.push(...matching);
+    const keepGoing = await onPage(pageItems, batch);
 
     previousLastSymbol = pageItems[pageItems.length - 1].symbol;
     lowerBound = previousLastSymbol;
 
-    if (batch.length < batchSize) {
+    if (keepGoing === false || batch.length < batchSize) {
       break;
     }
   }
+}
 
+async function loadHonestAssets({ prefix = DEFAULT_PREFIX, batchSize = 100, maxPages = 100, startSymbol = DEFAULT_PREFIX }: Record<string, any> = {}) {
+  const all: any[] = [];
+
+  await paginateListAssets({ batchSize, maxPages, startSymbol }, (pageItems) => {
+    const matching = pageItems.filter((asset) => isHonestAsset(asset) && asset.symbol.startsWith(prefix));
+    all.push(...matching);
+  });
   const mpas = [];
   for (const asset of all) {
     if (!isMpa(asset)) {
@@ -357,5 +373,5 @@ function createHonestEcosystemAdapter(options: Record<string, any> = {}) {
   };
 }
 
-export { CORE_SYMBOL, DEFAULT_PREFIX, REFERENCE_SYMBOL, buildHonestEcosystemContext, createHonestEcosystemAdapter, getHardcodedHonestMoneyBridge, loadHonestAssets, isHardcodedHonestMoneyBtsPair, resolveHardcodedHonestMoneyPrice, resolveHonestPairContext, resolveHonestPairPrice }
+export { buildHonestEcosystemContext, createHonestEcosystemAdapter, getHardcodedHonestMoneyBridge, getHonestMoneyBridge, isMpa, loadHonestAssets, paginateListAssets, resolveHardcodedHonestMoneyPrice, resolveHonestPairContext, resolveHonestPairPrice }
 

package/claw/modules/liquidity_pools.ts

@@ -1,7 +1,7 @@
 
 
 import * as client from './bitshares_client.js';
-import { getDexbot2Root, loadDexbotOrderSystemUtils, requireDexbot2Module } from './dexbot_bridge.js';
+import { loadDexbotOrderSystemUtils, requireDexbot2Module } from './dexbot_bridge.js';
 function getDexbotSystem() {
   return loadDexbotOrderSystemUtils();
 }
@@ -13,9 +13,16 @@ function derivePoolPrice(assetA: any, assetB: any, poolRef?: string | null | Rec
     try {
       const { withPoolRef: wrapWithPoolRef } = requireDexbot2Module('modules/order/utils/withPoolRef') as any;
       const override = wrapWithPoolRef(client.BitShares, resolvedPoolRef);
-      if (override) return override.derivePoolPrice(assetA, assetB);
+      // The caller pinned a specific pool: honoring the pin or failing is
+      // correct, silently deriving from a different auto-selected pool is not.
+      if (!override) {
+        console.warn(`[liquidity-pools] derivePoolPrice could not pin pool ${resolvedPoolRef}`);
+        return null;
+      }
+      return override.derivePoolPrice(assetA, assetB);
     } catch (e: any) {
       console.warn(`[liquidity-pools] derivePoolPrice with poolRef failed: ${e?.message || e}`);
+      return null;
     }
   }
   return system.derivePoolPrice(client.BitShares, assetA, assetB);
@@ -47,5 +54,5 @@ function createDexbotPoolHelper() {
   };
 }
 
-export { derivePoolPrice, derivePrice, createDexbotPoolHelper, getDexbot2Root, requireDexbot2Module }
+export { derivePoolPrice, derivePrice, createDexbotPoolHelper }