dexbot 1.4.12 → 1.4.13

package/claw/tests/test_memu_bridge.ts

@@ -0,0 +1,189 @@
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { getStorage } = require('../../modules/storage');
+const { ensureDir } = getStorage();
+
+function writeFakeMemuPackage(tmpRoot) {
+  const memuDir = path.join(tmpRoot, 'memu');
+  ensureDir(memuDir);
+  fs.writeFileSync(path.join(memuDir, '__init__.py'), `
+from types import SimpleNamespace
+
+
+class _FakeMemoryItemRepo:
+    def __init__(self):
+        self.items = {}
+
+
+class _FakeResourceRepo:
+    def __init__(self):
+        self.resources = {}
+
+    def list_resources(self, where=None):
+        return {
+            "res-1": {"id": "res-1", "where": where},
+            "res-2": {"id": "res-2", "where": where},
+            "res-3": {"id": "res-3", "where": where},
+        }
+
+
+class _FakeDatabase:
+    def __init__(self):
+        self.memory_item_repo = _FakeMemoryItemRepo()
+        self.resource_repo = _FakeResourceRepo()
+
+
+class MemoryService:
+    def __init__(self, **kwargs):
+        provider = kwargs.get("database_config", {}).get("metadata_store", {}).get("provider", "sqlite")
+        self.database = _FakeDatabase()
+        self.database_config = SimpleNamespace(metadata_store=SimpleNamespace(provider=provider))
+        self.llm_profiles = SimpleNamespace(profiles={"default": object(), "embedding": object()})
+        self.retrieve_config = SimpleNamespace(method="rag")
+        self._context = SimpleNamespace(categories_ready=False, category_ids=[])
+
+    async def memorize(self, *, resource_url, modality, user=None):
+        return {"resource_url": resource_url, "modality": modality, "user": user}
+
+    async def retrieve(self, queries, where=None):
+        return {"queries": queries, "where": where, "method": self.retrieve_config.method}
+
+    async def list_memory_categories(self, where=None):
+        return {
+            "categories": [
+                {"id": "cat-1", "name": "preferences", "where": where},
+                {"id": "cat-2", "name": "knowledge", "where": where},
+            ]
+        }
+
+    async def list_memory_items(self, where=None):
+        return {
+            "items": [
+                {"id": "item-1", "where": where},
+                {"id": "item-2", "where": where},
+            ]
+        }
+
+    async def create_memory_item(self, *, memory_type, memory_content, memory_categories, user=None):
+        return {
+            "memory_type": memory_type,
+            "memory_content": memory_content,
+            "memory_categories": memory_categories,
+            "user": user,
+        }
+
+    async def update_memory_item(self, *, memory_id, memory_type=None, memory_content=None, memory_categories=None, user=None):
+        return {
+            "memory_id": memory_id,
+            "memory_type": memory_type,
+            "memory_content": memory_content,
+            "memory_categories": memory_categories,
+            "user": user,
+        }
+
+    async def delete_memory_item(self, *, memory_id):
+        return {"deleted": True, "memory_id": memory_id}
+
+    async def clear_memory(self, where=None):
+        return {"cleared_where": where}
+`);
+}
+
+function runMemuRunner(args) {
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'dexbot2-memu-test-'));
+  const candidatePaths = [
+    path.resolve(__dirname, '..', 'scripts', 'memu_runner.py'),
+    path.resolve(__dirname, '..', '..', '..', 'claw', 'scripts', 'memu_runner.py'),
+  ];
+  const scriptPath = candidatePaths.find((candidate) => fs.existsSync(candidate)) || candidatePaths[0];
+
+  try {
+    writeFakeMemuPackage(tmpRoot);
+    const run = spawnSync('python3', [scriptPath, ...args], {
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        PYTHONPATH: tmpRoot
+      }
+    });
+
+    return {
+      code: run.status,
+      stdout: run.stdout,
+      stderr: run.stderr
+    };
+  } finally {
+    fs.rmSync(tmpRoot, { recursive: true, force: true });
+  }
+}
+
+function parseRun(run, label) {
+  assert.strictEqual(run.code, 0, `${label} failed:\nSTDERR:\n${run.stderr}\nSTDOUT:\n${run.stdout}`);
+  return JSON.parse(run.stdout.trim());
+}
+
+function testCreateItemResolvesCategoryIdsAndDefaultsMemoryType() {
+  const result = parseRun(runMemuRunner([
+    'create-item',
+    '--category-id', 'cat-1',
+    '--summary', 'Prefers 2% spacing',
+    '--user', '{"user_id":"trader-123"}'
+  ]), 'create-item');
+
+  assert.strictEqual(result.memory_type, 'knowledge');
+  assert.deepStrictEqual(result.memory_categories, ['preferences']);
+  assert.deepStrictEqual(result.user, { user_id: 'trader-123' });
+}
+
+function testUpdateItemResolvesCategoryIds() {
+  const result = parseRun(runMemuRunner([
+    'update-item',
+    '--item-id', 'item-1',
+    '--updates', '{"summary":"Updated note","memory_categories":["cat-2"],"user":{"user_id":"trader-123"}}'
+  ]), 'update-item');
+
+  assert.strictEqual(result.memory_id, 'item-1');
+  assert.strictEqual(result.memory_content, 'Updated note');
+  assert.deepStrictEqual(result.memory_categories, ['knowledge']);
+  assert.deepStrictEqual(result.user, { user_id: 'trader-123' });
+}
+
+function testClearPassesScope() {
+  const result = parseRun(runMemuRunner([
+    'clear',
+    '--where', '{"user_id":"trader-123"}'
+  ]), 'clear');
+
+  assert.strictEqual(result.cleared, true);
+  assert.deepStrictEqual(result.cleared_where, { user_id: 'trader-123' });
+}
+
+function testStatusUsesPersistedCountsInsteadOfFreshCaches() {
+  const result = parseRun(runMemuRunner([
+    'status',
+    '--where', '{"user_id":"trader-123"}',
+    '--db-config', '{"metadata_store":{"provider":"sqlite","dsn":"sqlite:////tmp/memu-test.db"}}'
+  ]), 'status');
+
+  assert.strictEqual(result.category_count, 2);
+  assert.strictEqual(result.item_count, 2);
+  assert.strictEqual(result.resource_count, 3);
+  assert.strictEqual(result.categories_ready, true);
+  assert.strictEqual(result.metadata_store, 'sqlite');
+  assert.deepStrictEqual(result.llm_profiles, ['default', 'embedding']);
+}
+
+function main() {
+  testCreateItemResolvesCategoryIdsAndDefaultsMemoryType();
+  testUpdateItemResolvesCategoryIds();
+  testClearPassesScope();
+  testStatusUsesPersistedCountsInsteadOfFreshCaches();
+  console.log('memu bridge regression test passed');
+}
+
+main();

package/claw/tests/test_nullclaw_tmp_integration.ts

@@ -0,0 +1,58 @@
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs/promises');
+const os = require('os');
+const { getErrorMessage } = require('../../modules/utils/errors');
+const path = require('path');
+const { createClawBridge, runClawCommand } = require('../modules/claw_bridge');
+const { buildRuntimeSkillMarkdown, writeRuntimeSkillMarkdown } = require('../modules/claw_skill_md');
+
+async function main() {
+  const repoRoot = path.resolve(__dirname, '..');
+  const tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'nullclaw-integration-'));
+  const homeRoot = path.join(tmpRoot, 'home');
+  const dexbotRoot = path.join(tmpRoot, 'dexbot');
+  const workspaceSkillDir = path.join(homeRoot, '.nullclaw', 'workspace', 'skills', 'bitshares-claw');
+  const outputPath = path.join(workspaceSkillDir, 'SKILL.toml');
+
+  await fs.mkdir(dexbotRoot, { recursive: true });
+
+  await writeRuntimeSkillMarkdown(outputPath, 'nullclaw', {
+    profileRoot: dexbotRoot,
+    repoRoot
+  });
+
+  const skillText = await fs.readFile(outputPath, 'utf8');
+  assert.ok(skillText.includes('name = "bitshares-claw"'));
+  assert.ok(skillText.includes('NullClaw bridge to the AI-Bot / DEXBot2 BitShares layer'));
+  assert.ok(skillText.includes('nullclaw'));
+  assert.ok(skillText.includes('claw_bridge.js'));
+
+  const bridge = createClawBridge({
+    runtime: {
+      name: 'nullclaw-test'
+    }
+  });
+  assert.strictEqual(bridge.runtime.name, 'nullclaw-test');
+
+  const manifest = await runClawCommand('manifest', { runtimeName: 'nullclaw', profileRoot: dexbotRoot });
+  const runtime = await runClawCommand('runtime', { runtimeName: 'nullclaw', profileRoot: dexbotRoot });
+
+  assert.strictEqual(manifest.options.runtimeName, 'nullclaw');
+  assert.strictEqual(manifest.options.profileRoot, dexbotRoot);
+  assert.strictEqual(manifest.compatibility.recommendedTransport, 'skill-toml-or-mcp');
+  assert.ok(manifest.commandExamples.some((example) => example.includes('claw_bridge.ts')));
+  assert.ok(Array.isArray(manifest.tools.catalog));
+  assert.strictEqual(runtime.name, 'nullclaw');
+  assert.strictEqual(runtime.profileRoot, dexbotRoot);
+  assert.strictEqual(runtime.accountName, null);
+
+  console.log('nullclaw tmp integration test passed');
+}
+
+main().catch((err) => {
+  console.error(err && err.stack ? err.stack : getErrorMessage(err));
+  process.exit(1);
+});
+export {};

package/claw/tests/test_position_health.ts

@@ -0,0 +1,419 @@
+/**
+ * Tests for position_health.ts
+ *
+ * Validates the 3-zone CR classification and two-layer action system.
+ */
+
+'use strict';
+
+const assert = require('assert');
+const {
+  CR_ZONES,
+  classifyCrZone,
+  checkTrendAlignment,
+  assessPosition,
+  classifyPriceRangeRatio,
+  computePriceRangeRatioPlan,
+  computeOrderWeightBias,
+  crWeight,
+  trendWeight,
+} = require('../modules/position_health');
+const sharedPlanner = require('../../modules/cr_planner');
+
+// --- classifyCrZone ---
+
+function testCrZoneBoundaries() {
+  console.log('  classifyCrZone boundaries...');
+
+  // Red low: below 1.7
+  assert.strictEqual(classifyCrZone(1.0).zone, 'red_low');
+  assert.strictEqual(classifyCrZone(1.4).zone, 'red_low');
+  assert.strictEqual(classifyCrZone(1.69).zone, 'red_low');
+
+  // Green: 1.7 – 3.0 (acceptable range)
+  assert.strictEqual(classifyCrZone(1.7).zone, 'green');
+  assert.strictEqual(classifyCrZone(1.85).zone, 'green');
+  assert.strictEqual(classifyCrZone(2.0).zone, 'green');
+  assert.strictEqual(classifyCrZone(2.25).zone, 'green');
+  assert.strictEqual(classifyCrZone(2.5).zone, 'green');
+  assert.strictEqual(classifyCrZone(2.75).zone, 'green');
+  assert.strictEqual(classifyCrZone(2.99).zone, 'green');
+
+  // Red high: above 3.0
+  assert.strictEqual(classifyCrZone(3.0).zone, 'red_high');
+  assert.strictEqual(classifyCrZone(5.0).zone, 'red_high');
+  assert.strictEqual(classifyCrZone(100).zone, 'red_high');
+
+  // Edge: invalid
+  assert.strictEqual(classifyCrZone(null).zone, 'unknown');
+  assert.strictEqual(classifyCrZone(0).zone, 'unknown');
+  assert.strictEqual(classifyCrZone(-1).zone, 'unknown');
+  assert.strictEqual(classifyCrZone(NaN).zone, 'unknown');
+  assert.strictEqual(classifyCrZone(Infinity).zone, 'unknown');
+
+  console.log('    PASS');
+}
+
+function testCrZoneStatuses() {
+  console.log('  classifyCrZone statuses...');
+
+  assert.strictEqual(classifyCrZone(3.5).status, 'over_collateralized');
+  assert.strictEqual(classifyCrZone(2.7).status, 'safe');
+  assert.strictEqual(classifyCrZone(2.2).status, 'safe');
+  assert.strictEqual(classifyCrZone(2.0).status, 'safe');
+  assert.strictEqual(classifyCrZone(1.8).status, 'safe');
+  assert.strictEqual(classifyCrZone(1.5).status, 'not_acceptable');
+  assert.strictEqual(classifyCrZone(null).status, 'no_data');
+
+  console.log('    PASS');
+}
+
+// --- checkTrendAlignment ---
+
+function testTrendAlignment() {
+  console.log('  checkTrendAlignment...');
+
+  assert.strictEqual(checkTrendAlignment('short', 'DOWN'), 'aligned');
+  assert.strictEqual(checkTrendAlignment('short', 'UP'), 'opposed');
+  assert.strictEqual(checkTrendAlignment('short', 'NEUTRAL'), 'neutral');
+  assert.strictEqual(checkTrendAlignment('long', 'UP'), 'aligned');
+  assert.strictEqual(checkTrendAlignment('long', 'DOWN'), 'opposed');
+  assert.strictEqual(checkTrendAlignment('long', 'NEUTRAL'), 'neutral');
+
+  console.log('    PASS');
+}
+
+// --- assessPosition: two-layer actions ---
+
+function makePosition(cr, debtAmount = 100) {
+  return {
+    id: 'test_pos',
+    status: 'debt_open',
+    onChain: {
+      btsPerMpa: 50,
+      collateralAmount: cr && debtAmount ? cr * debtAmount * 50 : 0,
+      collateralRatio: cr,
+      debtAmount
+    },
+  };
+}
+
+function testAssessRedLow() {
+  console.log('  assessPosition red_low (two-layer)...');
+
+  const result = assessPosition(makePosition(1.5));
+  assert.strictEqual(result.collateral.zone, 'red_low');
+  assert.strictEqual(result.actions.length, 2);
+  assert.strictEqual(result.actions[0].action, 'reduce_debt');
+  assert.strictEqual(result.actions[0].priority, 'immediate');
+  assert.strictEqual(result.actions[1].action, 'add_collateral');
+  assert.strictEqual(result.actions[1].priority, 'fallback');
+
+  console.log('    PASS');
+}
+
+function testAssessGreen() {
+  console.log('  assessPosition green (acceptable range, no actions)...');
+
+  const result = assessPosition(makePosition(1.85));
+  assert.strictEqual(result.collateral.zone, 'green');
+  assert.strictEqual(result.actions.length, 0);
+  const result2 = assessPosition(makePosition(2.0));
+  assert.strictEqual(result2.collateral.zone, 'green');
+  assert.strictEqual(result2.actions.length, 0);
+  const result3 = assessPosition(makePosition(2.7));
+  assert.strictEqual(result3.collateral.zone, 'green');
+  assert.strictEqual(result3.actions.length, 0);
+
+  console.log('    PASS');
+}
+
+function testAssessRedHigh() {
+  console.log('  assessPosition red_high (two-layer)...');
+
+  const result = assessPosition(makePosition(3.5));
+  assert.strictEqual(result.collateral.zone, 'red_high');
+  assert.strictEqual(result.actions.length, 2);
+  assert.strictEqual(result.actions[0].action, 'increase_debt');
+  assert.strictEqual(result.actions[0].priority, 'immediate');
+  assert.strictEqual(result.actions[1].action, 'withdraw_collateral');
+  assert.strictEqual(result.actions[1].priority, 'fallback');
+
+  console.log('    PASS');
+}
+
+function testAssessNoDebt() {
+  console.log('  assessPosition no debt (no CR actions)...');
+
+  const result = assessPosition(makePosition(1.5, 0));
+  assert.strictEqual(result.hasDebt, false);
+  assert.strictEqual(result.actions.length, 0);
+
+  console.log('    PASS');
+}
+
+// --- assessPosition: trend actions ---
+
+function testAssessTrendOpposed() {
+  console.log('  assessPosition trend opposed adds review action...');
+
+  const trend = { trend: 'UP', confidence: 70, premium: 1.5 };
+  const result = assessPosition(makePosition(2.2), trend);
+  assert.strictEqual(result.trend.alignment, 'opposed');
+  const reviewAction = result.actions.find(a => a.action === 'review_direction');
+  assert.ok(reviewAction, 'should have review_direction action');
+  assert.strictEqual(reviewAction.priority, 'evaluate');
+
+  console.log('    PASS');
+}
+
+function testAssessTrendAligned() {
+  console.log('  assessPosition trend aligned no extra action...');
+
+  const trend = { trend: 'DOWN', confidence: 80, premium: -1.0 };
+  const result = assessPosition(makePosition(2.0), trend);
+  assert.strictEqual(result.trend.alignment, 'aligned');
+  assert.strictEqual(result.actions.length, 0);
+
+  console.log('    PASS');
+}
+
+function testAssessTrendLowConfidence() {
+  console.log('  assessPosition trend opposed but low confidence...');
+
+  const trend = { trend: 'UP', confidence: 30, premium: 0.5 };
+  const result = assessPosition(makePosition(2.0), trend);
+  assert.strictEqual(result.trend.alignment, 'opposed');
+  assert.strictEqual(result.actions.length, 0, 'low confidence should not trigger review');
+
+  console.log('    PASS');
+}
+
+// --- collateral calculations ---
+
+function testCollateralForTargetCr() {
+  console.log('  collateralForTargetCr...');
+
+  // 100 MPA debt * 50 BTS/MPA * 2.0 CR = 10000 BTS
+  assert.strictEqual(sharedPlanner.collateralForTargetCr(100, 50, 2.0), 10000);
+  assert.strictEqual(sharedPlanner.collateralForTargetCr(100, 50, 2.5), 12500);
+  assert.strictEqual(sharedPlanner.collateralForTargetCr(0, 50, 2.0), 0);
+  assert.strictEqual(sharedPlanner.collateralForTargetCr(-1, 50, 2.0), 0);
+
+  console.log('    PASS');
+}
+
+function testCollateralDelta() {
+  console.log('  collateralDeltaForTargetCr...');
+
+  // Need 10000, have 8000 → add 2000
+  assert.strictEqual(sharedPlanner.collateralDeltaForTargetCr(8000, 100, 50, 2.0), 2000);
+  // Need 10000, have 12000 → remove 2000
+  assert.strictEqual(sharedPlanner.collateralDeltaForTargetCr(12000, 100, 50, 2.0), -2000);
+  // Need 10000, have 10000 → no change
+  assert.strictEqual(sharedPlanner.collateralDeltaForTargetCr(10000, 100, 50, 2.0), 0);
+
+  console.log('    PASS');
+}
+
+function testDebtForTargetCr() {
+  console.log('  debtForTargetCr...');
+
+  assert.strictEqual(sharedPlanner.debtForTargetCr(10000, 50, 2.0), 100);
+  assert.strictEqual(sharedPlanner.debtForTargetCr(12000, 50, 2.0), 120);
+  assert.strictEqual(sharedPlanner.debtForTargetCr(0, 50, 2.0), 0);
+  assert.strictEqual(sharedPlanner.debtForTargetCr(10000, 0, 2.0), 0);
+
+  console.log('    PASS');
+}
+
+function testDebtDeltaForTargetCr() {
+  console.log('  debtDeltaForTargetCr...');
+
+  assert.strictEqual(sharedPlanner.debtDeltaForTargetCr(8000, 100, 50, 2.0), -20);
+  assert.strictEqual(sharedPlanner.debtDeltaForTargetCr(12000, 100, 50, 2.0), 20);
+  assert.strictEqual(sharedPlanner.debtDeltaForTargetCr(10000, 100, 50, 2.0), 0);
+
+  console.log('    PASS');
+}
+
+function testPlanCrAdjustment() {
+  console.log('  planCrAdjustment...');
+
+  const lowCr = sharedPlanner.planCrAdjustment(8000, 100, 50, 2.0);
+  assert.strictEqual(lowCr.primaryAction, 'reduce_debt');
+  assert.strictEqual(lowCr.fallbackAction, 'add_collateral');
+  assert.strictEqual(lowCr.debtDelta, -20);
+  assert.strictEqual(lowCr.collateralDelta, 2000);
+
+  const highCr = sharedPlanner.planCrAdjustment(12000, 100, 50, 2.0);
+  assert.strictEqual(highCr.primaryAction, 'increase_debt');
+  assert.strictEqual(highCr.fallbackAction, 'withdraw_collateral');
+  assert.strictEqual(highCr.debtDelta, 20);
+  assert.strictEqual(highCr.collateralDelta, -2000);
+
+  const onTarget = sharedPlanner.planCrAdjustment(10000, 100, 50, 2.0);
+  assert.strictEqual(onTarget.primaryAction, 'hold');
+  assert.strictEqual(onTarget.fallbackAction, 'hold');
+  assert.strictEqual(onTarget.debtDelta, 0);
+  assert.strictEqual(onTarget.collateralDelta, 0);
+
+  console.log('    PASS');
+}
+
+// --- CR_ZONES constant ---
+
+function testCrZonesConstant() {
+  console.log('  CR_ZONES constant values...');
+
+  assert.strictEqual(CR_ZONES.RED_HIGH, 3.0);
+  assert.strictEqual(CR_ZONES.RED_LOW, 1.7);
+
+  // Deep frozen
+  assert.throws(() => { CR_ZONES.RED_HIGH = 999; }, TypeError);
+
+  console.log('    PASS');
+}
+
+// --- Weight factor ---
+
+function testTrendWeight() {
+  console.log('  trendWeight...');
+
+  assert.strictEqual(trendWeight('UP', 90), 1.0);
+  assert.strictEqual(trendWeight('DOWN', 80), 1.0);
+  assert.strictEqual(trendWeight('UP', 70), 0.7);
+  assert.strictEqual(trendWeight('DOWN', 60), 0.7);
+  assert.strictEqual(trendWeight('UP', 50), 0.4);
+  assert.strictEqual(trendWeight('DOWN', 40), 0.4);
+  assert.strictEqual(trendWeight('UP', 30), 0.2);
+  assert.strictEqual(trendWeight('DOWN', 0), 0.2);
+  // NEUTRAL always 0.4 regardless of confidence
+  assert.strictEqual(trendWeight('NEUTRAL', 100), 0.4);
+  assert.strictEqual(trendWeight('NEUTRAL', 0), 0.4);
+
+  console.log('    PASS');
+}
+
+function testCrWeight() {
+  console.log('  crWeight...');
+
+  assert.strictEqual(crWeight('red_high'), 1.5);
+  assert.strictEqual(crWeight('green'), 1.0);
+  assert.strictEqual(crWeight('red_low'), 0.0);
+  assert.strictEqual(crWeight('unknown'), 1.0);
+
+  console.log('    PASS');
+}
+
+function testComputeOrderWeightBias() {
+  console.log('  computeOrderWeightBias...');
+
+  const down = computeOrderWeightBias('DOWN', 80);
+  assert.strictEqual(down.profile, 'mountain_valley');
+  assert.strictEqual(down.buyBias, 1.0);
+  assert.strictEqual(down.sellBias, -1.0);
+
+  const up = computeOrderWeightBias('UP', 60);
+  assert.strictEqual(up.profile, 'mountain_valley');
+  assert.strictEqual(up.buyBias, -0.7);
+  assert.strictEqual(up.sellBias, 0.7);
+
+  const neutral = computeOrderWeightBias('NEUTRAL', 90);
+  assert.strictEqual(neutral.profile, 'balanced');
+  assert.strictEqual(neutral.buyBias, 0);
+  assert.strictEqual(neutral.sellBias, 0);
+  assert.strictEqual(neutral.strength, 0);
+
+  console.log('    PASS');
+}
+
+function testClassifyPriceRangeRatio() {
+  console.log('  classifyPriceRangeRatio...');
+
+  assert.strictEqual(classifyPriceRangeRatio(1.8), 'very_competitive');
+  assert.strictEqual(classifyPriceRangeRatio(2.0), 'competitive');
+  assert.strictEqual(classifyPriceRangeRatio(2.7), 'competitive');
+  assert.strictEqual(classifyPriceRangeRatio(3.0), 'conservative');
+  assert.strictEqual(classifyPriceRangeRatio(4.0), 'very_conservative');
+
+  console.log('    PASS');
+}
+
+function testComputePriceRangeRatioPlan() {
+  console.log('  computePriceRangeRatioPlan...');
+
+  const widen = computePriceRangeRatioPlan(
+    {
+      minPrice: '3x',
+      maxPrice: '3x'
+    },
+    {
+      rangeContext: {
+        observedMaxPrice: 145,
+        observedMinPrice: 70
+      },
+      referencePrice: 100
+    }
+  );
+
+  assert.strictEqual(widen.currentRatio, 3);
+  assert.strictEqual(widen.observedRatio, 1.45);
+  assert.strictEqual(widen.recommendedRatio, 1.6);
+  assert.strictEqual(widen.classification, 'very_competitive');
+  assert.strictEqual(widen.reason, 'historical_range_supports_tighter_bounds');
+  assert.strictEqual(widen.shouldUpdate, true);
+
+  const keep = computePriceRangeRatioPlan(
+    {
+      minPrice: '2x',
+      maxPrice: '2x'
+    },
+    {
+      rangeContext: {
+        observedMaxPrice: 195,
+        observedMinPrice: 55
+      },
+      referencePrice: 100
+    }
+  );
+
+  assert.strictEqual(keep.currentRatio, 2);
+  assert.strictEqual(keep.recommendedRatio, 2.15);
+  assert.strictEqual(keep.classification, 'competitive');
+  assert.strictEqual(keep.shouldUpdate, false);
+
+  console.log('    PASS');
+}
+
+// --- Run all ---
+
+function main() {
+  console.log('position_health tests\n');
+
+  testCrZonesConstant();
+  testCrZoneBoundaries();
+  testCrZoneStatuses();
+  testTrendAlignment();
+  testAssessRedLow();
+  testAssessGreen();
+  testAssessRedHigh();
+  testAssessNoDebt();
+  testAssessTrendOpposed();
+  testAssessTrendAligned();
+  testAssessTrendLowConfidence();
+  testCollateralForTargetCr();
+  testCollateralDelta();
+  testDebtForTargetCr();
+  testDebtDeltaForTargetCr();
+  testPlanCrAdjustment();
+  testTrendWeight();
+  testCrWeight();
+  testComputeOrderWeightBias();
+  testClassifyPriceRangeRatio();
+  testComputePriceRangeRatioPlan();
+
+  console.log('\n=== All 21 tests passed ===');
+}
+
+main();