PyPI - primecli - Versions diffs - 0.7.3__tar.gz → 0.7.5__tar.gz - Mend

primecli 0.7.3tar.gz → 0.7.5tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (24) hide show

{primecli-0.7.3 → primecli-0.7.5}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: primecli
-Version: 0.7.3
+Version: 0.7.5
 Summary: Agent-friendly CLI tools for the DeltaPrime (Avalanche + Arbitrum) and DegenPrime (Base) lending and leverage protocols. Preview-by-default; no Etherscan key required.
 Author: Mnemosyne-quest contributors
 License: MIT
@@ -47,7 +47,7 @@ Built for agent use:
 - RedStone-signed solvency math handled internally, with a regression test pinning the half-boundary `toFixed(8)` encoding.
 - ParaSwap calldata validated client-side against the on-chain executor allowlist before broadcast.
-**Current version:** 0.7.3 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
+**Current version:** 0.7.5 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
 > **Breaking change in 0.5.0:** there is no longer a default signing key. Earlier versions silently fell back to a baked-in agent when no key was configured; that fallback has been removed. With no key configured, every command now fails closed with `No signing key found...`. Set a key explicitly (see [Configuration](#configuration)).

{primecli-0.7.3 → primecli-0.7.5}/README.md RENAMED Viewed

@@ -16,7 +16,7 @@ Built for agent use:
 - RedStone-signed solvency math handled internally, with a regression test pinning the half-boundary `toFixed(8)` encoding.
 - ParaSwap calldata validated client-side against the on-chain executor allowlist before broadcast.
-**Current version:** 0.7.3 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
+**Current version:** 0.7.5 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
 > **Breaking change in 0.5.0:** there is no longer a default signing key. Earlier versions silently fell back to a baked-in agent when no key was configured; that fallback has been removed. With no key configured, every command now fails closed with `No signing key found...`. Set a key explicitly (see [Configuration](#configuration)).

{primecli-0.7.3 → primecli-0.7.5}/primecli/arbprime.py RENAMED Viewed

@@ -262,6 +262,7 @@ AGENTS = {
 }
 _SELECTED_AGENT = None        # set by the --as CLI flag in main()
 _CLI_KEY = None               # set by the --key CLI flag in main()
+_OWNER_ADDRESS = None          # set by --owner for keyless read-only commands (main())
 # Core protocol addresses — the LIVE Arbitrum deployment (DeploymentConstants.sol),
 # on-chain verified 2026-06-03. The stale *TUP.json deployment (factory 0x97f4C81…)
 # has only ETH+USDC pools — NOT used here.
@@ -847,6 +848,14 @@ def resolve_private_key():
     )
 def get_account() -> Account:
+    # --owner provides a keyless read-only account (address only, cannot sign) for
+    # monitoring/sim reads that need the wallet owner (e.g. to locate a Prime Account)
+    # but never broadcast. Write paths are blocked in main() when --owner is set.
+    if _OWNER_ADDRESS:
+        class _ReadOnlyAccount:
+            def __init__(self, address):
+                self.address = Web3.to_checksum_address(address)
+        return _ReadOnlyAccount(_OWNER_ADDRESS)
     return Account.from_key(resolve_private_key())
 def to_wei_units(amount, decimals):
@@ -5587,7 +5596,7 @@ def main():
     check_version()
     args = sys.argv[1:] if len(sys.argv) > 1 else []
     # Global wallet selector: --as <agent>, stripped before command dispatch.
-    global _SELECTED_AGENT, _CLI_KEY
+    global _SELECTED_AGENT, _CLI_KEY, _OWNER_ADDRESS
     if "--as" in args:
         i = args.index("--as")
         if i + 1 >= len(args):
@@ -5603,11 +5612,27 @@ def main():
             return
         _CLI_KEY = args[i + 1]
         del args[i:i + 2]
+    # Public owner-address selector for read-only commands. Lets monitoring/sim jobs
+    # inspect a wallet's Prime Account / positions without resolving or loading a key.
+    if "--owner" in args:
+        i = args.index("--owner")
+        if i + 1 >= len(args):
+            print("--owner requires an EVM address. Example: --owner 0xabc...")
+            return
+        try:
+            _OWNER_ADDRESS = Web3.to_checksum_address(args[i + 1])
+        except Exception:
+            print(f"Invalid --owner address: {args[i + 1]}")
+            return
+        del args[i:i + 2]
     if not args or args[0] in ("-h", "--help"):
         print(__doc__)
         return
     cmd = args[0]
+    if _OWNER_ADDRESS and cmd not in {"defi", "lb-positions"}:
+        print("--owner is only supported for read-only commands: defi, lb-positions")
+        return
     if cmd == "pool-info":
         # First positional after `pool-info` is the pool name; --json is an opt-in flag
         # that switches output from human tables to a compact JSON shape (one object for

{primecli-0.7.3 → primecli-0.7.5}/primecli/degenprime.py RENAMED Viewed

@@ -218,35 +218,141 @@ AERODROME_SEL_DECREASE = bytes.fromhex("ca15558b")      # inferred: decreaseLiqu
 AERODROME_SEL_BURN = bytes.fromhex("92b5a47e")          # inferred: burn
 AERODROME_SEL_COLLECT = bytes.fromhex("92b5a47e")       # same as burn (inferred)
-# Whitelisted Aerodrome CL pools exposed as tool keys. Each key carries the known
-# token pair, fee tier (tickSpacing in bps), and the expected token addresses.
-# tickSpacing maps: 1 = 0.01%, 5 = 0.05%, 10 = 0.1%, 30 = 0.3%, 100 = 1%.
-# Most pools use the canonical (WETH/stablecoin) ordering from the CL Factory.
+# Whitelisted Aerodrome CL pools exposed as tool keys — the authoritative set of
+# ~31 DegenPrime-supported SlipStream pools. Every entry was verified on-chain
+# (2026-06-13): token0/token1/tickSpacing read from the pool, decimals/symbol from
+# each token, and the pool address cross-checked against the SlipStream factory's
+# getPool(token0, token1, tickSpacing) (0x5e7BB104d84c7CB9B682AaC2F3d509f5F406809A).
+# token0/token1 follow the pool's canonical on-chain ordering; the key is a curated
+# label (symbol0 stores WETH as "ETH" to match the lending-pool convention, so WETH
+# pairs are keyed "weth-*").
+# tickSpacing tiers in use: 1, 50, 100, 200, 2000. gauge_alive=False marks pools
+# whose Aerodrome gauge is dead (no AERO emissions; still tradeable/LP-able).
 AERODROME_POOLS = {
-    "weth-usdc-100":  {"token0": "0x4200000000000000000000000000000000000006",
-                        "token1": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-                        "tickSpacing": 100, "symbol0": "ETH", "symbol1": "USDC",
-                        "decimals0": 18, "decimals1": 6},
-    "weth-usdc-5":    {"token0": "0x4200000000000000000000000000000000000006",
-                        "token1": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-                        "tickSpacing": 5, "symbol0": "ETH", "symbol1": "USDC",
-                        "decimals0": 18, "decimals1": 6},
-    "weth-cbbtc-100": {"token0": "0x4200000000000000000000000000000000000006",
-                        "token1": "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
-                        "tickSpacing": 100, "symbol0": "ETH", "symbol1": "cbBTC",
-                        "decimals0": 18, "decimals1": 8},
-    "weth-cbbtc-30":  {"token0": "0x4200000000000000000000000000000000000006",
-                        "token1": "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
-                        "tickSpacing": 30, "symbol0": "ETH", "symbol1": "cbBTC",
-                        "decimals0": 18, "decimals1": 8},
-    "weth-aero-200":  {"token0": "0x940181a94A35A4569E4529A3CDfB74e38FD98631",
-                        "token1": "0x4200000000000000000000000000000000000006",
-                        "tickSpacing": 200, "symbol0": "AERO", "symbol1": "ETH",
-                        "decimals0": 18, "decimals1": 18},
-    "aero-usdc-100":  {"token0": "0x940181a94A35A4569E4529A3CDfB74e38FD98631",
-                        "token1": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-                        "tickSpacing": 100, "symbol0": "AERO", "symbol1": "USDC",
-                        "decimals0": 18, "decimals1": 6},
+    "weth-usdc-100":    {"token0": "0x4200000000000000000000000000000000000006",
+                         "token1": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+                         "tickSpacing": 100, "symbol0": "ETH", "symbol1": "USDC",
+                         "decimals0": 18, "decimals1": 6, "gauge_alive": True},
+    "weth-cbbtc-100":   {"token0": "0x4200000000000000000000000000000000000006",
+                         "token1": "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+                         "tickSpacing": 100, "symbol0": "ETH", "symbol1": "cbBTC",
+                         "decimals0": 18, "decimals1": 8, "gauge_alive": True},
+    "weth-aero-200":    {"token0": "0x4200000000000000000000000000000000000006",
+                         "token1": "0x940181a94A35A4569E4529A3CDfB74e38FD98631",
+                         "tickSpacing": 200, "symbol0": "ETH", "symbol1": "AERO",
+                         "decimals0": 18, "decimals1": 18, "gauge_alive": False},
+    "aero-usdc-2000":   {"token0": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+                         "token1": "0x940181a94A35A4569E4529A3CDfB74e38FD98631",
+                         "tickSpacing": 2000, "symbol0": "USDC", "symbol1": "AERO",
+                         "decimals0": 6, "decimals1": 18, "gauge_alive": True},
+    "aero-cbbtc-200":   {"token0": "0x940181a94A35A4569E4529A3CDfB74e38FD98631",
+                         "token1": "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+                         "tickSpacing": 200, "symbol0": "AERO", "symbol1": "cbBTC",
+                         "decimals0": 18, "decimals1": 8, "gauge_alive": True},
+    "avnt-usdc-1":      {"token0": "0x696F9436B67233384889472Cd7cD58A6fB5DF4f1",
+                         "token1": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+                         "tickSpacing": 1, "symbol0": "AVNT", "symbol1": "USDC",
+                         "decimals0": 18, "decimals1": 6, "gauge_alive": True},
+    "avnt-usdc-200":    {"token0": "0x696F9436B67233384889472Cd7cD58A6fB5DF4f1",
+                         "token1": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+                         "tickSpacing": 200, "symbol0": "AVNT", "symbol1": "USDC",
+                         "decimals0": 18, "decimals1": 6, "gauge_alive": True},
+    "cbbtc-lbtc-1":     {"token0": "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+                         "token1": "0xecAc9C5F704e954931349Da37F60E39f515c11c1",
+                         "tickSpacing": 1, "symbol0": "cbBTC", "symbol1": "LBTC",
+                         "decimals0": 8, "decimals1": 8, "gauge_alive": True},
+    "cbbtc-cbdoge-100": {"token0": "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+                         "token1": "0xcbD06E5A2B0C65597161de254AA074E489dEb510",
+                         "tickSpacing": 100, "symbol0": "cbBTC", "symbol1": "cbDOGE",
+                         "decimals0": 8, "decimals1": 8, "gauge_alive": False},
+    "clanker-weth-200": {"token0": "0x1bc0c42215582d5A085795f4baDbaC3ff36d1Bcb",
+                         "token1": "0x4200000000000000000000000000000000000006",
+                         "tickSpacing": 200, "symbol0": "CLANKER", "symbol1": "ETH",
+                         "decimals0": 18, "decimals1": 18, "gauge_alive": True},
+    "weth-aixbt-200":   {"token0": "0x4200000000000000000000000000000000000006",
+                         "token1": "0x4F9Fd6Be4a90f2620860d680c0d4d5Fb53d1A825",
+                         "tickSpacing": 200, "symbol0": "ETH", "symbol1": "AIXBT",
+                         "decimals0": 18, "decimals1": 18, "gauge_alive": True},
+    "weth-brett-200":   {"token0": "0x4200000000000000000000000000000000000006",
+                         "token1": "0x532f27101965dd16442E59d40670FaF5eBB142E4",
+                         "tickSpacing": 200, "symbol0": "ETH", "symbol1": "BRETT",
+                         "decimals0": 18, "decimals1": 18, "gauge_alive": True},
+    "weth-degen-200":   {"token0": "0x4200000000000000000000000000000000000006",
+                         "token1": "0x4ed4E862860beD51a9570b96d89aF5E1B0Efefed",
+                         "tickSpacing": 200, "symbol0": "ETH", "symbol1": "DEGEN",
+                         "decimals0": 18, "decimals1": 18, "gauge_alive": True},
+    "weth-euroc-100":   {"token0": "0x4200000000000000000000000000000000000006",
+                         "token1": "0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42",
+                         "tickSpacing": 100, "symbol0": "ETH", "symbol1": "EURC",
+                         "decimals0": 18, "decimals1": 6, "gauge_alive": False},
+    "weth-kaito-100":   {"token0": "0x4200000000000000000000000000000000000006",
+                         "token1": "0x98d0baa52b2D063E780DE12F615f963Fe8537553",
+                         "tickSpacing": 100, "symbol0": "ETH", "symbol1": "KAITO",
+                         "decimals0": 18, "decimals1": 18, "gauge_alive": True},
+    "weth-spx-200":     {"token0": "0x4200000000000000000000000000000000000006",
+                         "token1": "0x50dA645f148798F68EF2d7dB7C1CB22A6819bb2C",
+                         "tickSpacing": 200, "symbol0": "ETH", "symbol1": "SPX",
+                         "decimals0": 18, "decimals1": 8, "gauge_alive": True},
+    "weth-toshi-200":   {"token0": "0x4200000000000000000000000000000000000006",
+                         "token1": "0xAC1Bd2486aAf3B5C0fc3Fd868558b082a531B2B4",
+                         "tickSpacing": 200, "symbol0": "ETH", "symbol1": "TOSHI",
+                         "decimals0": 18, "decimals1": 18, "gauge_alive": True},
+    "weth-cbdoge-2000": {"token0": "0x4200000000000000000000000000000000000006",
+                         "token1": "0xcbD06E5A2B0C65597161de254AA074E489dEb510",
+                         "tickSpacing": 2000, "symbol0": "ETH", "symbol1": "cbDOGE",
+                         "decimals0": 18, "decimals1": 8, "gauge_alive": True},
+    "weth-cbltc-200":   {"token0": "0x4200000000000000000000000000000000000006",
+                         "token1": "0xcb17C9Db87B595717C857a08468793f5bAb6445F",
+                         "tickSpacing": 200, "symbol0": "ETH", "symbol1": "cbLTC",
+                         "decimals0": 18, "decimals1": 8, "gauge_alive": True},
+    "weth-cbxrp-2000":  {"token0": "0x4200000000000000000000000000000000000006",
+                         "token1": "0xcb585250f852C6c6bf90434AB21A00f02833a4af",
+                         "tickSpacing": 2000, "symbol0": "ETH", "symbol1": "cbXRP",
+                         "decimals0": 18, "decimals1": 6, "gauge_alive": False},
+    "euroc-usdc-1":     {"token0": "0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42",
+                         "token1": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+                         "tickSpacing": 1, "symbol0": "EURC", "symbol1": "USDC",
+                         "decimals0": 6, "decimals1": 6, "gauge_alive": False},
+    "euroc-usdc-50":    {"token0": "0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42",
+                         "token1": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+                         "tickSpacing": 50, "symbol0": "EURC", "symbol1": "USDC",
+                         "decimals0": 6, "decimals1": 6, "gauge_alive": True},
+    "usdc-cbbtc-100":   {"token0": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+                         "token1": "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+                         "tickSpacing": 100, "symbol0": "USDC", "symbol1": "cbBTC",
+                         "decimals0": 6, "decimals1": 8, "gauge_alive": True},
+    "usdc-usdt-1":      {"token0": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+                         "token1": "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2",
+                         "tickSpacing": 1, "symbol0": "USDC", "symbol1": "USDT",
+                         "decimals0": 6, "decimals1": 6, "gauge_alive": True},
+    "virtual-weth-100": {"token0": "0x0b3e328455c4059EEb9e3f84b5543F74E24e7E1b",
+                         "token1": "0x4200000000000000000000000000000000000006",
+                         "tickSpacing": 100, "symbol0": "VIRTUAL", "symbol1": "ETH",
+                         "decimals0": 18, "decimals1": 18, "gauge_alive": True},
+    "virtual-weth-200": {"token0": "0x0b3e328455c4059EEb9e3f84b5543F74E24e7E1b",
+                         "token1": "0x4200000000000000000000000000000000000006",
+                         "tickSpacing": 200, "symbol0": "VIRTUAL", "symbol1": "ETH",
+                         "decimals0": 18, "decimals1": 18, "gauge_alive": True},
+    "zora-usdc-100":    {"token0": "0x1111111111166b7FE7bd91427724B487980aFc69",
+                         "token1": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+                         "tickSpacing": 100, "symbol0": "ZORA", "symbol1": "USDC",
+                         "decimals0": 18, "decimals1": 6, "gauge_alive": True},
+    "cbltc-cbbtc-100":  {"token0": "0xcb17C9Db87B595717C857a08468793f5bAb6445F",
+                         "token1": "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+                         "tickSpacing": 100, "symbol0": "cbLTC", "symbol1": "cbBTC",
+                         "decimals0": 8, "decimals1": 8, "gauge_alive": True},
+    "cbxrp-cbbtc-100":  {"token0": "0xcb585250f852C6c6bf90434AB21A00f02833a4af",
+                         "token1": "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+                         "tickSpacing": 100, "symbol0": "cbXRP", "symbol1": "cbBTC",
+                         "decimals0": 6, "decimals1": 8, "gauge_alive": False},
+    "weeth-weth-1":     {"token0": "0x04C0599Ae5A44757c0af6F9eC3b93da8976c150A",
+                         "token1": "0x4200000000000000000000000000000000000006",
+                         "tickSpacing": 1, "symbol0": "weETH", "symbol1": "ETH",
+                         "decimals0": 18, "decimals1": 18, "gauge_alive": True},
+    "ezeth-weth-1":     {"token0": "0x2416092f143378750bb29b79eD961ab195CcEea5",
+                         "token1": "0x4200000000000000000000000000000000000006",
+                         "tickSpacing": 1, "symbol0": "ezETH", "symbol1": "ETH",
+                         "decimals0": 18, "decimals1": 18, "gauge_alive": True},
 }
 # ParaSwap v6 / Velora aggregator on Base. The Degen Account's ParaSwapFacet.paraSwapV6

{primecli-0.7.3 → primecli-0.7.5}/primecli/deltaprime.py RENAMED Viewed

@@ -269,6 +269,7 @@ AGENTS = {
 }
 _SELECTED_AGENT = None        # set by the --as CLI flag in main()
 _CLI_KEY = None               # set by the --key CLI flag in main()
+_OWNER_ADDRESS = None          # set by --owner for keyless read-only commands (main())
 SNOWTRACE = "https://api.snowtrace.io/api"
 FACTORY_PROXY = "0x3Ea9D480295A73fd2aF95b4D96c2afF88b21B03D"
 # On-chain registry of active pools. getPoolAddress(bytes32 asset) is the source
@@ -842,6 +843,14 @@ def resolve_private_key():
     )
 def get_account() -> Account:
+    # --owner provides a keyless read-only account (address only, cannot sign) for
+    # monitoring/sim reads that need the wallet owner (e.g. to locate a Prime Account)
+    # but never broadcast. Write paths are blocked in main() when --owner is set.
+    if _OWNER_ADDRESS:
+        class _ReadOnlyAccount:
+            def __init__(self, address):
+                self.address = Web3.to_checksum_address(address)
+        return _ReadOnlyAccount(_OWNER_ADDRESS)
     return Account.from_key(resolve_private_key())
 def to_wei_units(amount, decimals):
@@ -5358,7 +5367,7 @@ def main():
     check_version()
     args = sys.argv[1:] if len(sys.argv) > 1 else []
     # Global wallet selector: --as <agent>, stripped before command dispatch.
-    global _SELECTED_AGENT, _CLI_KEY
+    global _SELECTED_AGENT, _CLI_KEY, _OWNER_ADDRESS
     if "--as" in args:
         i = args.index("--as")
         if i + 1 >= len(args):
@@ -5374,11 +5383,27 @@ def main():
             return
         _CLI_KEY = args[i + 1]
         del args[i:i + 2]
+    # Public owner-address selector for read-only commands. Lets monitoring/sim jobs
+    # inspect a wallet's Prime Account / positions without resolving or loading a key.
+    if "--owner" in args:
+        i = args.index("--owner")
+        if i + 1 >= len(args):
+            print("--owner requires an EVM address. Example: --owner 0xabc...")
+            return
+        try:
+            _OWNER_ADDRESS = Web3.to_checksum_address(args[i + 1])
+        except Exception:
+            print(f"Invalid --owner address: {args[i + 1]}")
+            return
+        del args[i:i + 2]
     if not args or args[0] in ("-h", "--help"):
         print(__doc__)
         return
     cmd = args[0]
+    if _OWNER_ADDRESS and cmd not in {"defi", "lb-positions"}:
+        print("--owner is only supported for read-only commands: defi, lb-positions")
+        return
     if cmd == "pool-info":
         # First positional after `pool-info` is the pool name; --json is an opt-in flag
         # that switches output from human tables to a compact JSON shape (one object for

{primecli-0.7.3 → primecli-0.7.5}/primecli/health_monitor.py RENAMED Viewed

@@ -214,6 +214,22 @@ def append_history(state_dir: str, entry: dict):
         path.write_text("\n".join(lines[-1000:]) + "\n")
+NOTIFY_SCRIPT = os.path.expanduser("/root/.openclaw/workspace/scripts/notify.sh")
+def _notify(text: str):
+    """Send a Telegram notification via the notify.sh script."""
+    if not os.path.exists(NOTIFY_SCRIPT):
+        return
+    try:
+        subprocess.run(
+            ["bash", NOTIFY_SCRIPT, text],
+            capture_output=True, timeout=30,
+        )
+    except Exception:
+        pass
 def load_baseline_equity(state_dir: str) -> float | None:
     """Load baseline equity for stop-loss tracking."""
     path = Path(state_dir) / "baseline-equity"
@@ -325,7 +341,46 @@ def run_tick(
     # 3. Compute health
     health = compute_health(defi_data, max_mult)
     health["tier"] = tier
+    # 4. Load strategy (do this early so rebalance mode is known before equity checks)
+    strategy = load_strategy(strategy_path)
+    mode = strategy.get("mode", "observer")
+    health["mode"] = mode
+    result.update(health)
+    result["mode"] = mode
+    # 5. Check for unfunded or unpriced accounts
     if health.get("error") == "equity near zero":
+        # Check if there are actual token balances without USD prices (RedStone off?)
+        has_balances = False
+        groups = defi_data.get("groups", [])
+        if groups:
+            for g in groups:
+                for s in g.get("supplied", []):
+                    bal = s.get("balance", 0)
+                    try:
+                        if float(bal) > 0:
+                            has_balances = True
+                            break
+                    except (ValueError, TypeError):
+                        pass
+                if has_balances:
+                    break
+        else:
+            for s in defi_data.get("supplied", []):
+                bal = s.get("balance", 0)
+                try:
+                    if float(bal) > 0:
+                        has_balances = True
+                        break
+                except (ValueError, TypeError):
+                    pass
+        if has_balances:
+            # Positions exist but USD prices unavailable — skip this tick
+            result["action"] = "skip (unpriced positions)"
+            return result
         # Only escalate if there's actual debt — an empty unfunded wallet is not an emergency
         if health.get("debt_usd", 0) and health["debt_usd"] > 0.5:
             write_escalation(state_dir, "equity-near-zero", {
@@ -338,17 +393,9 @@ def run_tick(
             result["mode"] = "escalated"
         else:
             result["action"] = "none (unfunded account)"
-        result.update(health)
         return result
-    # 4. Load strategy (position/market/side are optional hints now — auto-detected from defi_data)
-    strategy = load_strategy(strategy_path)
-    mode = strategy.get("mode", "observer")
-    health["mode"] = mode
-    result.update(health)
-    result["mode"] = mode
-    # 5. Health swing detection (always)
+    # 6. Health swing detection (always)
     last_pct = load_last_health(state_dir)
     if last_pct is not None and health["health_pct"] is not None:
         diff = abs(health["health_pct"] - last_pct)
@@ -363,7 +410,7 @@ def run_tick(
             result["escalation"] = "health_swing"
     save_last_health(state_dir, health["health_pct"] or 0.0)
-    # 6. Append to history
+    # 7. Append to history
     entry = {
         "ts": now_iso, "mode": mode,
         "pct": health["health_pct"],
@@ -373,7 +420,7 @@ def run_tick(
     }
     append_history(state_dir, entry)
-    # 7. Rebalance mode logic
+    # 8. Rebalance mode logic
     if mode == "rebalance":
         # Valuation gate: never auto-lever/de-lever on incomplete or untrustworthy data
         # (missing RedStone feed → unpriced position → wrong equity/debt/health). Escalate
@@ -399,6 +446,7 @@ def run_tick(
         position_type = strategy.get("position", "")
         market = strategy.get("market", "avax-usdc")
         side = strategy.get("side", "short")
+        swap_target = strategy.get("swap_target", "")
         low, high = target_range[0], target_range[1]
         pct = health["health_pct"]
@@ -465,16 +513,73 @@ def run_tick(
                     return result
             if repay_amt > raw_usdc:
-                # Need to withdraw from position first — escalate
-                write_escalation(state_dir, "repay-no-usdc", {
-                    "reason": "repay_needs_position_close",
-                    "repay_needed": repay_amt,
-                    "raw_usdc": raw_usdc,
-                    "health_pct": pct,
-                    "label": label,
-                })
-                result["action"] = "escalate (need close)"
-                return result
+                # Build supply_rows from defi_data for potential swap source
+                supply_rows = []
+                groups = defi_data.get("groups", [])
+                if groups:
+                    for g in groups:
+                        supply_rows.extend(g.get("supplied", []))
+                else:
+                    supply_rows.extend(defi_data.get("supplied", []))
+                # Need more USDC — try to swap from swap_target if configured
+                if swap_target:
+                    for s in list(supply_rows):
+                        sym = s.get("symbol", "")
+                        usd_val = s.get("usd", 0) or 0
+                        if sym.upper() == swap_target.upper() and usd_val > 1:
+                            raw_amt = s.get("amount", 0)
+                            swap_token_amt = raw_amt * 0.95
+                            if swap_token_amt < 0.001:
+                                break
+                            try:
+                                sr = subprocess.run(
+                                    [sys.executable, tool_path, "swap",
+                                     "--from", swap_target,
+                                     "--to", "USDC",
+                                     "--amount", f"{swap_token_amt:.6f}",
+                                     "--slippage", "1.0",
+                                     "--execute"],
+                                    capture_output=True, text=True, timeout=180,
+                                )
+                                if sr.returncode == 0:
+                                    result["swap"] = f"swapped {swap_token_amt:.4f} {swap_target} -> USDC"
+                                else:
+                                    write_escalation(state_dir, "repay-swap-failed", {
+                                        "reason": "repay_swap_failed",
+                                        "swap_source": swap_target,
+                                        "swap_amount": swap_token_amt,
+                                        "stderr": sr.stderr[:200],
+                                        "health_pct": pct,
+                                        "label": label,
+                                    })
+                                    result["error"] = f"swap failed: {sr.stderr[:200]}"
+                                    result["action"] = "escalate (swap failed)"
+                                    return result
+                            except Exception as e:
+                                result["error"] = f"swap error: {e}"
+                                return result
+                            break
+                    else:
+                        write_escalation(state_dir, "repay-no-usdc", {
+                            "reason": "repay_needs_position_close",
+                            "repay_needed": repay_amt,
+                            "raw_usdc": raw_usdc,
+                            "health_pct": pct,
+                            "label": label,
+                        })
+                        result["action"] = "escalate (need close)"
+                        return result
+                else:
+                    write_escalation(state_dir, "repay-no-usdc", {
+                        "reason": "repay_needs_position_close",
+                        "repay_needed": repay_amt,
+                        "raw_usdc": raw_usdc,
+                        "health_pct": pct,
+                        "label": label,
+                    })
+                    result["action"] = "escalate (need close)"
+                    return result
             if dry_run:
                 result["action"] = f"would repay ${repay_amt:.2f} USDC"
@@ -490,6 +595,7 @@ def run_tick(
                 if r.returncode == 0:
                     cooldown_file.write_text(str(int(time.time())))
                     result["action"] = f"repaid ${repay_amt:.2f}"
+                    _notify(f"🔄 Rebalance: {label} repaid ${repay_amt:.2f} USDC (health was {pct}%)")
                 else:
                     result["error"] = f"repay failed: {r.stderr[:200]}"
             except Exception as e:
@@ -527,99 +633,126 @@ def run_tick(
                 result["error"] = f"borrow error: {e}"
                 return result
-            # Deploy into whatever positions are open (detected dynamically from defi_data)
-            has_gmx = health.get("has_gmx", False)
-            has_lb = health.get("has_lb", False)
-            has_aero = health.get("has_aero", False)
-            open_positions = []
-            if has_gmx: open_positions.append("gmx")
-            if has_lb:  open_positions.append("lb")
-            if has_aero: open_positions.append("aero")
-            if not open_positions:
-                # No open positions — just borrow and leave as USDC (or deploy to default)
-                result["action"] = f"borrowed ${borrow_amt:.2f} (no positions to deploy into)"
-                cooldown_file.write_text(str(int(time.time())))
+            # If swap_target is set, deploy by swapping borrowed USDC to that token
+            if swap_target and swap_target.upper() != "USDC":
+                split_amt = borrow_amt
+                try:
+                    sr = subprocess.run(
+                        [sys.executable, tool_path, "swap",
+                         "--from", "USDC",
+                         "--to", swap_target,
+                         "--amount", f"{split_amt:.2f}",
+                         "--slippage", "1.0",
+                         "--execute"],
+                        capture_output=True, text=True, timeout=180,
+                    )
+                    if sr.returncode == 0:
+                        cooldown_file.write_text(str(int(time.time())))
+                        result["action"] = f"borrowed ${borrow_amt:.2f}, swapped {split_amt:.2f} USDC -> {swap_target}"
+                        _notify(f"🔄 Rebalance: {label} borrowed ${borrow_amt:.2f} USDC \u2192 swapped to {swap_target} (health was {pct}%)")
+                    else:
+                        result["warning"] = f"swap to {swap_target} failed after borrow: {sr.stderr[:200]}"
+                        cooldown_file.write_text(str(int(time.time())))
+                except Exception as e:
+                    result["error"] = f"borrow+swap error: {e}"
+                    cooldown_file.write_text(str(int(time.time())))
             else:
-                # Split borrow amount proportionally across open positions
-                split_amt = borrow_amt / len(open_positions)
-                deployed_ok = 0
-                deployed_fail = 0
-                for pos_type in open_positions:
-                    if pos_type == "gmx":
-                        # Use market/side from strategy as hint, fall back to sensible defaults
-                        mkt = strategy.get("market", "avax-usdc") if tool_path else "avax-usdc"
-                        sd = strategy.get("side", "long") if tool_path else "long"
-                        try:
-                            r = subprocess.run(
-                                [sys.executable, tool_path, "gmx-deposit",
-                                 "--market", mkt, "--amount", f"{split_amt:.2f}",
-                                 "--side", sd, "--fee-buffer", "1.5", "--execute"],
-                                capture_output=True, text=True, timeout=120,
-                            )
-                            if r.returncode == 0:
-                                deployed_ok += 1
-                            else:
-                                result["warning"] = f"gmx deposit failed: {r.stderr[:200]}"
-                                deployed_fail += 1
-                        except Exception as e:
-                            result["error"] = f"gmx deposit error: {e}"
-                            deployed_fail += 1
-                    elif pos_type == "lb":
-                        # Detect LB pair from defi data (look for "TraderJoe V2 LB" group)
-                        lb_pairs = []
-                        for g in defi_data.get("groups", []):
-                            if g.get("type") == "TraderJoe V2 LB":
-                                for item in g.get("items", []):
-                                    label = item.get("label", "")
-                                    m = re.match(r'\[([^\]]+)\]', label)
-                                    if m:
-                                        lb_pairs.append(m.group(1))
-                        # Skip if tool doesn't support lb-add (degenprime)
-                        tool_bn = os.path.basename(tool_path) if tool_path else ""
-                        if "degenprime" in tool_bn:
-                            result["action"] = f"lb-add not available on degenprime — leaving ${split_amt:.2f} as USDC"
-                            deployed_fail += 1
-                        elif not lb_pairs:
-                            result["warning"] = f"has_lb=True but no LB pair found in defi data — leaving ${split_amt:.2f} as USDC"
-                            deployed_fail += 1
-                        else:
-                            pair_key = lb_pairs[0]
+                # Deploy into whatever positions are open (detected dynamically from defi_data)
+                has_gmx = health.get("has_gmx", False)
+                has_lb = health.get("has_lb", False)
+                has_aero = health.get("has_aero", False)
+                open_positions = []
+                if has_gmx: open_positions.append("gmx")
+                if has_lb:  open_positions.append("lb")
+                if has_aero: open_positions.append("aero")
+                if not open_positions:
+                    # No open positions — just borrow and leave as USDC (or deploy to default)
+                    result["action"] = f"borrowed ${borrow_amt:.2f} (no positions to deploy into)"
+                    cooldown_file.write_text(str(int(time.time())))
+                    _notify(f"🔄 Rebalance: {label} borrowed ${borrow_amt:.2f} USDC (no positions to deploy, health was {pct}%)")
+                else:
+                    # Split borrow amount proportionally across open positions
+                    split_amt = borrow_amt / len(open_positions)
+                    deployed_ok = 0
+                    deployed_fail = 0
+                    for pos_type in open_positions:
+                        if pos_type == "gmx":
+                            # Use market/side from strategy as hint, fall back to sensible defaults
+                            mkt = strategy.get("market", "avax-usdc") if tool_path else "avax-usdc"
+                            sd = strategy.get("side", "long") if tool_path else "long"
                             try:
                                 r = subprocess.run(
-                                    [sys.executable, tool_path, "lb-add",
-                                     "--pair", pair_key,
-                                     "--amount-x", "0",
-                                     "--amount-y", f"{split_amt:.2f}",
-                                     "--shape", "spot",
-                                     "--range", "15",
-                                     "--execute"],
+                                    [sys.executable, tool_path, "gmx-deposit",
+                                     "--market", mkt, "--amount", f"{split_amt:.2f}",
+                                     "--side", sd, "--fee-buffer", "1.5", "--execute"],
                                     capture_output=True, text=True, timeout=120,
                                 )
                                 if r.returncode == 0:
                                     deployed_ok += 1
                                 else:
-                                    result["warning"] = f"lb-add failed: {r.stderr[:200]}"
+                                    result["warning"] = f"gmx deposit failed: {r.stderr[:200]}"
                                     deployed_fail += 1
                             except Exception as e:
-                                result["error"] = f"lb-add error: {e}"
+                                result["error"] = f"gmx deposit error: {e}"
                                 deployed_fail += 1
-                    elif pos_type == "aero":
-                        # Aerodrome CL: degenprime has read-only aerodrome-positions,
-                        # but no deposit/withdraw commands yet (write paths deferred to
-                        # v2 — on-chain signatures vary by Aerodrome version).
-                        # Use `degenprime aerodrome-positions` to list your NFT tokenIds.
-                        result["action"] = f"aero deposit not yet supported (read-only via aerodrome-positions, writes deferred to v2) — leaving ${split_amt:.2f} as USDC"
+                        elif pos_type == "lb":
+                            # Detect LB pair from defi data (look for "TraderJoe V2 LB" group)
+                            lb_pairs = []
+                            for g in defi_data.get("groups", []):
+                                if g.get("type") == "TraderJoe V2 LB":
+                                    for item in g.get("items", []):
+                                        label = item.get("label", "")
+                                        m = re.match(r'\[([^\]]+)\]', label)
+                                        if m:
+                                            lb_pairs.append(m.group(1))
+                            # Skip if tool doesn't support lb-add (degenprime)
+                            tool_bn = os.path.basename(tool_path) if tool_path else ""
+                            if "degenprime" in tool_bn:
+                                result["action"] = f"lb-add not available on degenprime — leaving ${split_amt:.2f} as USDC"
+                                deployed_fail += 1
+                            elif not lb_pairs:
+                                result["warning"] = f"has_lb=True but no LB pair found in defi data — leaving ${split_amt:.2f} as USDC"
+                                deployed_fail += 1
+                            else:
+                                pair_key = lb_pairs[0]
+                                try:
+                                    r = subprocess.run(
+                                        [sys.executable, tool_path, "lb-add",
+                                         "--pair", pair_key,
+                                         "--amount-x", "0",
+                                         "--amount-y", f"{split_amt:.2f}",
+                                         "--shape", "spot",
+                                         "--range", "15",
+                                         "--execute"],
+                                        capture_output=True, text=True, timeout=120,
+                                    )
+                                    if r.returncode == 0:
+                                        deployed_ok += 1
+                                    else:
+                                        result["warning"] = f"lb-add failed: {r.stderr[:200]}"
+                                        deployed_fail += 1
+                                except Exception as e:
+                                    result["error"] = f"lb-add error: {e}"
+                                    deployed_fail += 1
-                if deployed_ok > 0:
-                    cooldown_file.write_text(str(int(time.time())))
-                    result["action"] = f"borrowed ${borrow_amt:.2f}, deployed ${split_amt:.2f} to {deployed_ok} position(s)"
-                else:
-                    result["warning"] = f"borrow ok but all deposits failed"
+                        elif pos_type == "aero":
+                            # Aerodrome CL: degenprime has read-only aerodrome-positions,
+                            # but no deposit/withdraw commands yet (write paths deferred to
+                            # v2 — on-chain signatures vary by Aerodrome version).
+                            # Use `degenprime aerodrome-positions` to list your NFT tokenIds.
+                            result["action"] = f"aero deposit not yet supported (read-only via aerodrome-positions, writes deferred to v2) — leaving ${split_amt:.2f} as USDC"
+                    if deployed_ok > 0:
+                        cooldown_file.write_text(str(int(time.time())))
+                        result["action"] = f"borrowed ${borrow_amt:.2f}, deployed ${split_amt:.2f} to {deployed_ok} position(s)"
+                        _notify(f"🔄 Rebalance: {label} borrowed ${borrow_amt:.2f} USDC, deployed {split_amt:.2f} to {deployed_ok} position(s) (health was {pct}%)")
+                    else:
+                        result["warning"] = f"borrow ok but all deposits failed"
     return result

{primecli-0.7.3 → primecli-0.7.5}/primecli.egg-info/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: primecli
-Version: 0.7.3
+Version: 0.7.5
 Summary: Agent-friendly CLI tools for the DeltaPrime (Avalanche + Arbitrum) and DegenPrime (Base) lending and leverage protocols. Preview-by-default; no Etherscan key required.
 Author: Mnemosyne-quest contributors
 License: MIT
@@ -47,7 +47,7 @@ Built for agent use:
 - RedStone-signed solvency math handled internally, with a regression test pinning the half-boundary `toFixed(8)` encoding.
 - ParaSwap calldata validated client-side against the on-chain executor allowlist before broadcast.
-**Current version:** 0.7.3 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
+**Current version:** 0.7.5 The 0.x line is pre-1.0, so breaking changes are possible. See [Releases](https://github.com/Mnemosyne-quest/primecli/releases).
 > **Breaking change in 0.5.0:** there is no longer a default signing key. Earlier versions silently fell back to a baked-in agent when no key was configured; that fallback has been removed. With no key configured, every command now fails closed with `No signing key found...`. Set a key explicitly (see [Configuration](#configuration)).

{primecli-0.7.3 → primecli-0.7.5}/pyproject.toml RENAMED Viewed

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "primecli"
-version = "0.7.3"
+version = "0.7.5"
 description = "Agent-friendly CLI tools for the DeltaPrime (Avalanche + Arbitrum) and DegenPrime (Base) lending and leverage protocols. Preview-by-default; no Etherscan key required."
 readme = "README.md"
 requires-python = ">=3.10"