dexbot 1.1.10

package/claw/scripts/memu_runner.py

@@ -0,0 +1,385 @@
+#!/usr/bin/env python3
+"""
+memU Runner - Python subprocess bridge for DEXBot2 claw integration.
+
+This script is called by the Node.js memu_bridge.js module to execute
+memU memory operations. It handles argument parsing, service initialization,
+and JSON output for the Node.js caller.
+
+Usage:
+    python3 memu_runner.py <command> [options]
+
+Commands:
+    memorize          Store a resource as memory
+    retrieve          Query stored memories
+    list-categories   List memory categories
+    list-items        List memory items
+    create-item       Create a memory item directly
+    update-item       Update a memory item
+    delete-item       Delete a memory item
+    clear             Clear all memory
+    status            Get memU service status
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+try:
+    from memu import MemoryService
+except ImportError:
+    print(
+        json.dumps({
+            "error": "memU package not found. Install with: pip install memu-py",
+            "hint": "See https://github.com/NevaMind-AI/memU for installation instructions"
+        }),
+        file=sys.stderr
+    )
+    sys.exit(1)
+
+
+def parse_llm_profiles(raw: str | None) -> dict | None:
+    """Parse LLM profiles from JSON string."""
+    if not raw:
+        return None
+    return json.loads(raw)
+
+
+def parse_db_config(raw: str | None) -> dict | None:
+    """Parse database config from JSON string."""
+    if not raw:
+        return None
+    return json.loads(raw)
+
+
+def parse_user(raw: str | None) -> dict | None:
+    """Parse user scope from JSON string."""
+    if not raw:
+        return None
+    return json.loads(raw)
+
+
+def parse_where(raw: str | None) -> dict | None:
+    """Parse generic scope filters from JSON string."""
+    if not raw:
+        return None
+    return json.loads(raw)
+
+
+async def resolve_category_refs(
+    service: MemoryService,
+    category_refs: list[str] | None,
+    where: dict | None = None,
+) -> list[str] | None:
+    """Resolve memU category ids or names to the category names expected by CRUD APIs."""
+    if category_refs is None:
+        return None
+    if not category_refs:
+        return []
+
+    result = await service.list_memory_categories(where=where)
+    categories = result.get("categories", [])
+    by_id = {}
+    by_name = {}
+    for category in categories:
+        category_id = category.get("id")
+        category_name = category.get("name")
+        if isinstance(category_id, str) and category_id:
+            by_id[category_id] = category_name
+        if isinstance(category_name, str) and category_name:
+            by_name[category_name.strip().lower()] = category_name
+
+    resolved: list[str] = []
+    seen: set[str] = set()
+    unresolved: list[str] = []
+    for ref in category_refs:
+        if not isinstance(ref, str):
+            unresolved.append(str(ref))
+            continue
+        normalized = ref.strip()
+        if not normalized:
+            unresolved.append(ref)
+            continue
+        category_name = by_id.get(normalized) or by_name.get(normalized.lower())
+        if not category_name:
+            unresolved.append(ref)
+            continue
+        if category_name not in seen:
+            resolved.append(category_name)
+            seen.add(category_name)
+
+    if unresolved:
+        raise ValueError(f"Unknown memU categories: {', '.join(unresolved)}")
+    return resolved
+
+
+def create_service(args: argparse.Namespace) -> MemoryService:
+    """Create a MemoryService instance from CLI arguments."""
+    llm_profiles = parse_llm_profiles(getattr(args, 'llm_profile', None))
+    db_config = parse_db_config(getattr(args, 'db_config', None))
+
+    service_kwargs: dict = {}
+
+    if llm_profiles:
+        service_kwargs["llm_profiles"] = llm_profiles
+
+    if db_config:
+        service_kwargs["database_config"] = db_config
+    elif hasattr(args, 'memu_dir') and args.memu_dir:
+        db_path = Path(args.memu_dir) / "memu.db"
+        service_kwargs["database_config"] = {
+            "metadata_store": {
+                "provider": "sqlite",
+                "dsn": f"sqlite:///{db_path}"
+            },
+        }
+    else:
+        service_kwargs["database_config"] = {
+            "metadata_store": {"provider": "inmemory"},
+        }
+
+    if hasattr(args, 'memu_dir') and args.memu_dir:
+        blob_dir = Path(args.memu_dir) / "blob"
+        blob_dir.mkdir(parents=True, exist_ok=True)
+        service_kwargs["blob_config"] = {
+            "resources_dir": str(blob_dir)
+        }
+
+    return MemoryService(**service_kwargs)
+
+
+async def cmd_memorize(args: argparse.Namespace) -> dict:
+    """Execute memorize command."""
+    service = create_service(args)
+    user = parse_user(getattr(args, 'user', None))
+
+    result = await service.memorize(
+        resource_url=args.resource_url,
+        modality=args.modality,
+        user=user,
+    )
+    return result
+
+
+async def cmd_retrieve(args: argparse.Namespace) -> dict:
+    """Execute retrieve command."""
+    service = create_service(args)
+    queries = json.loads(args.queries)
+    where = parse_user(getattr(args, 'where', None))
+    method = getattr(args, 'method', 'rag')
+
+    if method == 'llm':
+        service.retrieve_config.method = 'llm'
+
+    result = await service.retrieve(
+        queries=queries,
+        where=where,
+    )
+    return result
+
+
+async def cmd_list_categories(args: argparse.Namespace) -> dict:
+    """List memory categories."""
+    service = create_service(args)
+    where = parse_user(getattr(args, 'where', None))
+
+    result = await service.list_memory_categories(where=where)
+    return {**result, "count": len(result.get("categories", []))}
+
+
+async def cmd_list_items(args: argparse.Namespace) -> dict:
+    """List memory items."""
+    service = create_service(args)
+    where = parse_user(getattr(args, 'where', None))
+
+    result = await service.list_memory_items(where=where)
+    return {**result, "count": len(result.get("items", []))}
+
+
+async def cmd_create_item(args: argparse.Namespace) -> dict:
+    """Create a memory item directly."""
+    service = create_service(args)
+    user = parse_user(getattr(args, 'user', None))
+    categories = await resolve_category_refs(service, [args.category_ref], where=user)
+
+    return await service.create_memory_item(
+        memory_type=args.memory_type,
+        memory_content=args.summary,
+        memory_categories=categories or [],
+        user=user,
+    )
+
+
+async def cmd_update_item(args: argparse.Namespace) -> dict:
+    """Update a memory item."""
+    service = create_service(args)
+    updates = json.loads(args.updates)
+    user = updates.get("user")
+    memory_categories = updates.get("memory_categories")
+    if memory_categories is not None:
+        memory_categories = await resolve_category_refs(service, memory_categories, where=user)
+
+    return await service.update_memory_item(
+        memory_id=args.item_id,
+        memory_type=updates.get("memory_type"),
+        memory_content=updates.get("summary") or updates.get("memory_content"),
+        memory_categories=memory_categories,
+        user=user,
+    )
+
+
+async def cmd_delete_item(args: argparse.Namespace) -> dict:
+    """Delete a memory item."""
+    service = create_service(args)
+
+    result = await service.delete_memory_item(memory_id=args.item_id)
+    return {**result, "item_id": args.item_id}
+
+
+async def cmd_clear(args: argparse.Namespace) -> dict:
+    """Clear all memory."""
+    service = create_service(args)
+    where = parse_where(getattr(args, 'where', None))
+
+    result = await service.clear_memory(where=where)
+    return {**result, "cleared": True}
+
+
+async def cmd_status(args: argparse.Namespace) -> dict:
+    """Get memU service status."""
+    service = create_service(args)
+    where = parse_where(getattr(args, 'where', None))
+    categories_result = await service.list_memory_categories(where=where)
+    items_result = await service.list_memory_items(where=where)
+    resources = service.database.resource_repo.list_resources(where or {})
+    category_count = len(categories_result.get("categories", []))
+    item_count = len(items_result.get("items", []))
+    resource_count = len(resources)
+
+    return {
+        "status": "ready",
+        "categories_ready": service._context.categories_ready or category_count > 0,
+        "category_count": category_count,
+        "item_count": item_count,
+        "resource_count": resource_count,
+        "llm_profiles": list(service.llm_profiles.profiles.keys()) if service.llm_profiles else [],
+        "metadata_store": service.database_config.metadata_store.provider,
+    }
+
+
+COMMANDS = {
+    "memorize": cmd_memorize,
+    "retrieve": cmd_retrieve,
+    "list-categories": cmd_list_categories,
+    "list-items": cmd_list_items,
+    "create-item": cmd_create_item,
+    "update-item": cmd_update_item,
+    "delete-item": cmd_delete_item,
+    "clear": cmd_clear,
+    "status": cmd_status,
+}
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build argument parser for all commands."""
+    parser = argparse.ArgumentParser(description="memU Runner for DEXBot2")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    memorize_parser = subparsers.add_parser("memorize", help="Store a resource as memory")
+    memorize_parser.add_argument("--resource-url", required=True)
+    memorize_parser.add_argument("--modality", required=True)
+    memorize_parser.add_argument("--user", default=None)
+    memorize_parser.add_argument("--memu-dir", default=None)
+    memorize_parser.add_argument("--llm-profile", default=None)
+    memorize_parser.add_argument("--db-config", default=None)
+
+    retrieve_parser = subparsers.add_parser("retrieve", help="Query stored memories")
+    retrieve_parser.add_argument("--queries", required=True)
+    retrieve_parser.add_argument("--where", default=None)
+    retrieve_parser.add_argument("--method", default="rag")
+    retrieve_parser.add_argument("--memu-dir", default=None)
+    retrieve_parser.add_argument("--llm-profile", default=None)
+    retrieve_parser.add_argument("--db-config", default=None)
+
+    list_cat_parser = subparsers.add_parser("list-categories", help="List memory categories")
+    list_cat_parser.add_argument("--where", default=None)
+    list_cat_parser.add_argument("--memu-dir", default=None)
+    list_cat_parser.add_argument("--llm-profile", default=None)
+    list_cat_parser.add_argument("--db-config", default=None)
+
+    list_items_parser = subparsers.add_parser("list-items", help="List memory items")
+    list_items_parser.add_argument("--where", default=None)
+    list_items_parser.add_argument("--memu-dir", default=None)
+    list_items_parser.add_argument("--llm-profile", default=None)
+    list_items_parser.add_argument("--db-config", default=None)
+
+    create_parser = subparsers.add_parser("create-item", help="Create a memory item")
+    create_parser.add_argument("--category-id", "--category-name", dest="category_ref", required=True)
+    create_parser.add_argument("--summary", required=True)
+    create_parser.add_argument("--memory-type", default="knowledge")
+    create_parser.add_argument("--user", default=None)
+    create_parser.add_argument("--memu-dir", default=None)
+    create_parser.add_argument("--llm-profile", default=None)
+    create_parser.add_argument("--db-config", default=None)
+
+    update_parser = subparsers.add_parser("update-item", help="Update a memory item")
+    update_parser.add_argument("--item-id", required=True)
+    update_parser.add_argument("--updates", required=True)
+    update_parser.add_argument("--memu-dir", default=None)
+    update_parser.add_argument("--llm-profile", default=None)
+    update_parser.add_argument("--db-config", default=None)
+
+    delete_parser = subparsers.add_parser("delete-item", help="Delete a memory item")
+    delete_parser.add_argument("--item-id", required=True)
+    delete_parser.add_argument("--memu-dir", default=None)
+    delete_parser.add_argument("--llm-profile", default=None)
+    delete_parser.add_argument("--db-config", default=None)
+
+    clear_parser = subparsers.add_parser("clear", help="Clear all memory")
+    clear_parser.add_argument("--where", default=None)
+    clear_parser.add_argument("--memu-dir", default=None)
+    clear_parser.add_argument("--llm-profile", default=None)
+    clear_parser.add_argument("--db-config", default=None)
+
+    status_parser = subparsers.add_parser("status", help="Get memU status")
+    status_parser.add_argument("--where", default=None)
+    status_parser.add_argument("--memu-dir", default=None)
+    status_parser.add_argument("--db-config", default=None)
+
+    return parser
+
+
+def main() -> None:
+    """Main entry point."""
+    parser = build_parser()
+    args = parser.parse_args()
+
+    command_fn = COMMANDS.get(args.command)
+    if not command_fn:
+        print(
+            json.dumps({"error": f"Unknown command: {args.command}"}),
+            file=sys.stderr
+        )
+        sys.exit(1)
+
+    try:
+        result = asyncio.run(command_fn(args))
+        print(json.dumps(result, default=str))
+    except Exception as e:
+        print(
+            json.dumps({
+                "error": str(e),
+                "command": args.command,
+                "type": type(e).__name__
+            }),
+            file=sys.stderr
+        )
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/claw/skills/bitshares-guide/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: bitshares-guide
+description: Presentation-only BitShares skill pack guide.
+---
+
+# BitShares Guide
+
+Use this skill for the public-facing BitShares guide layer only.
+
+Treat the guide reference material as layout and tone reference. Keep the section rhythm centered on `BitShares Overview`, `BitShares Network Metadata`, `Configuration Reference`, and `Resources & Links`.
+
+Keep it presentation-only: no runtime instructions, secrets, operational claims, or duplicate source pointers.
+
+Use the companion reference files for the section order, guardrails, and minimal shell fragments instead of expanding this file.

package/claw/skills/bitshares-guide/references/example-skill-shells.md

@@ -0,0 +1,18 @@
+# Example Skill Shells
+
+## Hero/Title Block
+
+```md
+# BitShares Guide
+
+Public-facing guide layer only.
+```
+
+## Resources/Footer Block
+
+```md
+## Resources & Links
+
+- Guide references
+- Shared safety labels
+```

package/claw/skills/bitshares-guide/references/presentation-patterns.md

@@ -0,0 +1,19 @@
+# Presentation Patterns
+
+Structure-only guidance for the guide branch.
+
+## Section Order
+
+1. Hero banner / top nav
+2. `BitShares Overview`
+3. `BitShares Network Metadata`
+4. `Configuration Reference`
+5. `Resources & Links`
+
+## Cues
+
+- Keep the header fixed, concise, and navigation-first.
+- Make the hero feel polished and public-facing, not operational.
+- Use `BitShares Network Metadata` as a compact framing section, not a source-of-truth dump.
+- Keep `Configuration Reference` illustrative and reference-driven.
+- End with `Resources & Links` as a footer-style link grid.

package/claw/skills/bitshares-guide/references/scope-guardrails.md

@@ -0,0 +1,9 @@
+# Scope Guardrails
+
+- presentation-only
+- no runtime instructions
+- no secrets
+- no unsupported operational claims
+- historical labels required when citing legacy BitShares material
+
+Presentation reference material is reference-only: use it for layout, tone, and framing, not as operational guidance.

package/claw/skills/launcher-ops/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: launcher-ops
+description: DEXBot2 launcher and orchestration workflows for PM2, unlock, claw-only mode, and Docker-friendly startup.
+---
+
+# Launcher Ops
+
+Use this skill for DEXBot2 startup orchestration, PM2 startup, and credential-daemon-only launcher flow.
+
+## What To Do
+
+- Read the companion reference for the exact command matrix.
+- Keep launcher parsing in `modules/launcher/launch_modes.ts`.
+- Keep daemon lifecycle handling in `modules/launcher/credential_daemon.ts`.
+- Keep `unlock` as the direct single-prompt path for Docker and local use.
+- Keep `claw-only` independent of bot config and BitShares connection checks.
+
+Use this skill when the task is about launcher behavior, but use the reference for exact commands and validation.

package/claw/skills/launcher-ops/references/launcher-workflow.md

@@ -0,0 +1,23 @@
+# Launcher Workflow
+
+Use this reference for DEXBot2 startup and PM2 orchestration work.
+
+## Commands
+
+- `tsx unlock` - single-prompt local startup.
+- `tsx unlock --claw-only` - credential daemon only, no bot startup.
+- `tsx pm2` - PM2 startup for all active bots.
+- `tsx pm2 <bot-name>` - PM2 startup for one active bot.
+- `tsx pm2 claw-only` - PM2 credential daemon only.
+
+## Rules
+
+- Keep `claw-only` free of bot config and BitShares connectivity checks.
+- Keep parsing in `modules/launcher/launch_modes.ts`.
+- Keep daemon lifecycle in `modules/launcher/credential_daemon.ts`.
+
+## Validation
+
+- `node --import tsx tests/test_launcher_exports.ts`
+- `node --import tsx tests/test_pm2_logic.ts`
+- `npm test`

package/claw/skills/margin-trading/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: margin-trading
+description: Margin trading concepts and position management for BitShares MPAs.
+---
+
+# Margin Trading
+
+Reference skill for margin position management on BitShares DEX.
+
+Covers the trading concepts available through the claw bridge, the mechanics of MPA debt positions, the HONEST.Asset ecosystem properties that shape how positions behave, and the position management principles that govern capital deployment.
+
+The practical control model is split into:
+
+- structural settings that are usually kept fixed (`incrementPercent`, `targetSpreadPercent`, `activeOrders`)
+- adaptive settings layered on top of AMA (`weightDistribution`, min/max range ratio, debt/collateral actions)
+
+## Reference Files
+
+- `references/honest-asset-list.md` — All 46 HONEST MPAs with on-chain IDs, precision, and categories
+- `references/honest-assets.md` — HONEST ecosystem properties: fees, MCR, feed price mechanics
+- `references/trading-concepts.md` — Short/long position lifecycles, collateral operations, claw bridge commands
+- `references/position-management.md` — CR zones, capital efficiency, unified planner model, loss/profit principles
+- Shared trend and signal tuning lives in `../trend-detection/SKILL.md`

package/claw/skills/margin-trading/references/honest-asset-list.md

@@ -0,0 +1,74 @@
+# HONEST MPA Assets
+
+Market Pegged Assets backed by collateral with on-chain price feeds. They can be borrowed, shorted, and traded on the order book. These are the assets the margin trading system operates on.
+
+For fee structure, MCR, and ecosystem properties, see `honest-assets.md`. This file lists only asset IDs, precisions, and short variants.
+
+Liquidity pools exist for many of these pairs but are handled by arbitrage bots — the margin trading system only uses limit orders on the book.
+
+## Crypto Assets (BTS-backed)
+
+| Symbol | ID | Precision | Short Variant |
+|---|---|---|---|
+| HONEST.BTC | 1.3.5650 | 8 | HONEST.BTCSHORT |
+| HONEST.ETH | 1.3.5659 | 6 | HONEST.ETHSHORT |
+| HONEST.LTC | 1.3.6306 | 8 | HONEST.LTCSHORT |
+| HONEST.XRP | 1.3.5660 | 6 | HONEST.XRPSHORT |
+| HONEST.XMR | 1.3.6308 | 8 | HONEST.XMRSHORT |
+| HONEST.SOL | 1.3.6307 | 8 | HONEST.SOLSHORT |
+| HONEST.DOT | 1.3.6305 | 8 | HONEST.DOTSHORT |
+| HONEST.ADA | 1.3.6304 | 8 | HONEST.ADASHORT |
+| HONEST.ATOM | 1.3.6309 | 8 | HONEST.ATOMSHORT |
+| HONEST.ALGO | 1.3.6311 | 8 | HONEST.ALGOSHORT |
+| HONEST.XLM | 1.3.6310 | 8 | HONEST.XLMSHORT |
+| HONEST.FIL | 1.3.6312 | 8 | HONEST.FILSHORT |
+| HONEST.EOS | 1.3.6313 | 8 | HONEST.EOSSHORT |
+
+## Fiat Currencies (BTS-backed)
+
+| Symbol | ID | Precision | Short Variant | Note |
+|---|---|---|---|---|
+| HONEST.USD | 1.3.5649 | 4 | HONEST.USDSHORT | 0.2% taker fee |
+| HONEST.CNY | 1.3.5641 | 4 | HONEST.CNYSHORT | |
+| HONEST.EUR | 1.3.6315 | 4 | HONEST.EURSHORT | |
+| HONEST.GBP | 1.3.6316 | 4 | HONEST.GBPSHORT | |
+| HONEST.JPY | 1.3.6317 | 4 | HONEST.JPYSHORT | |
+| HONEST.KRW | 1.3.6318 | 4 | HONEST.KRWSHORT | |
+| HONEST.RUB | 1.3.6314 | 4 | HONEST.RUBSHORT | |
+
+## Commodities (BTS-backed)
+
+| Symbol | ID | Precision | Short Variant |
+|---|---|---|---|
+| HONEST.XAU | 1.3.5651 | 8 | HONEST.XAUSHORT |
+| HONEST.XAG | 1.3.5652 | 8 | HONEST.XAGSHORT |
+
+## Cross-Backed (HONEST.BTC-backed)
+
+These use HONEST.BTC as collateral instead of BTS — different collateral dynamics.
+
+| Symbol | ID | Precision | Backing |
+|---|---|---|---|
+| HONEST.ETH1 | 1.3.5662 | 6 | HONEST.BTC |
+| HONEST.XRP1 | 1.3.5661 | 6 | HONEST.BTC |
+
+## Reference Asset
+
+| Symbol | ID | Type | Note |
+|---|---|---|---|
+| HONEST.MONEY | 1.3.6301 | ASSET | Internal reference asset, not an MPA |
+
+## Summary
+
+- 46 MPAs total: 22 base assets + 22 SHORT inverse tokens + 2 cross-backed
+- Every base crypto/fiat/commodity has a corresponding SHORT inverse token
+- SHORT tokens allow inverse exposure without a direct short position
+- Cross-backed assets (ETH1, XRP1) have HONEST.BTC collateral dynamics instead of BTS
+
+## Live Discovery
+
+```bash
+tsx scripts/honest_assets_report.ts --json
+```
+
+Filter by `type === 'MPA'` for margin-tradeable assets. The `honest_ecosystem.ts` module's `isMpa()` function checks for `bitasset_data_id`.

package/claw/skills/margin-trading/references/honest-assets.md

@@ -0,0 +1,44 @@
+# HONEST.Asset Ecosystem
+
+HONEST.Assets are Market Pegged Assets (MPAs) on the BitShares DEX backed by BTS collateral with price feeds published by the HONEST committee.
+
+## Fee Structure
+
+| Parameter | HONEST.Assets (standard) | HONEST.USD (exception) |
+|---|---|---|
+| Maker fee | 0% | 0% |
+| Taker fee | 0.1% | 0.2% |
+
+All HONEST.Assets share the same parameters except HONEST.USD which has a higher taker fee.
+
+Order operation fees (create, update, cancel) are approximately 0.1 BTS each.
+
+## Collateral
+
+- Maintenance Collateral Ratio (MCR): 1.4
+
+The collateral ratio is:
+
+```
+CR = collateral_amount / (debt_amount × feed_price)
+```
+
+Collateral ratio zones are defined in `references/position-management.md`. Green zone starts at CR 2.0.
+
+## Feed Price
+
+Each HONEST.Asset has an on-chain settlement feed price published by feed producers. This feed anchors the asset to its external reference value.
+
+The relationship between market price and feed price defines the premium or discount:
+
+```
+premium_percent = ((market_price - feed_price) / feed_price) × 100
+```
+
+- Positive: market trades at a premium (MPA is overvalued relative to feed)
+- Negative: market trades at a discount (MPA is undervalued relative to feed)
+- Near zero: market tracks the peg
+
+## Reference Asset
+
+HONEST.MONEY serves as the internal reference bridge asset. The HONEST.MONEY/BTS liquidity pool (1.19.305) provides cross-pricing between HONEST.Assets and BTS.