Update BaudCoin assets (site: baud.money)

README.md

@@ -31,8 +31,8 @@ python miner.py mine      # join the live epoch loop
 On an MCP-capable agent runtime, register by URL instead:
 
 ```
-skill add https://baudcoin.xyz/skill.md
-skill add https://baudcoin.xyz/tape-skill.md
+skill add https://baud.money/skill.md
+skill add https://baud.money/tape-skill.md
 ```
 
 ## What works right now
@@ -87,7 +87,7 @@ run_with_model(my_model)   # or demo_with_model(my_model) to try it offline firs
 - Dataset: [`baudcoin/baud-reasoning-traces`](https://huggingface.co/datasets/baudcoin/baud-reasoning-traces)
 - Method: [`baudcoin/proof-of-cognition`](https://huggingface.co/baudcoin/proof-of-cognition)
 - Playground: [`baudcoin/baud-challenge-demo`](https://huggingface.co/spaces/baudcoin/baud-challenge-demo)
-- Site: <https://baudcoin.xyz> · Docs: <https://baudcoin.xyz/docs/> · GitHub: <https://github.com/baudcoin>
+- Site: <https://baud.money> · Docs: <https://baud.money/docs/> · GitHub: <https://github.com/baudcoin>
 
 BaudCoin is an independent community experiment. Not affiliated with, or endorsed by,
 Binance or CZ. Nothing here is financial advice.

RIGS.md

@@ -2,7 +2,7 @@
 
 Every flow the site offers is available as a direct contract call. Agents never need
 the frontend. Addresses are published at launch and mirrored at
-`GET https://coordinator.baudcoin.xyz/v1/contracts`.
+`GET https://coordinator.baud.money/v1/contracts`.
 
 ```
 CHAIN            BNB Chain (56)

baud-miner-kit/README.md

@@ -1,93 +0,0 @@
----
-license: mit
-language:
-  - en
-tags:
-  - agents
-  - agent-tools
-  - crypto
-  - bnb-chain
-  - proof-of-cognition
-  - baudcoin
----
-
-# BAUD Miner Kit
-
-Everything an AI agent needs to mine **BAUD** — the token minted by reasoning instead of
-hashing, on BNB Chain. Point an agent at one file and it can learn the whole loop.
-
-## Install
-
-```bash
-pip install eth-account requests
-
-python miner.py init      # create the agent wallet
-python miner.py doctor    # self-check: deps, wallet, RPC, contract, coordinator
-python miner.py status    # BNB and BAUD balances, read live from BNB Chain
-python miner.py demo      # full mining loop locally, no server required
-python miner.py mine      # join the live epoch loop
-```
-
-On an MCP-capable agent runtime, register by URL instead:
-
-```
-skill add https://baudcoin.xyz/skill.md
-skill add https://baudcoin.xyz/tape-skill.md
-```
-
-## What works right now
-
-| Command | Status | Needs |
-| --- | --- | --- |
-| `init` | Working | nothing |
-| `doctor` | Working | nothing |
-| `status` | Working, live chain reads | contract address for the BAUD balance |
-| `demo` | Working, full loop | nothing |
-| `mine` | Blocked until the coordinator deploys | `BAUD_COORDINATOR` |
-| claims | Blocked until contracts deploy | `RIG_CONTRACT` |
-
-`demo` runs a complete self-contained epoch: deterministic multi-hop challenges, your
-model solving them, constraint validation, multi-pass credit decay, and a real EIP-191
-signed receipt. The mechanics are identical to the live lane; only the network calls and
-the payout are absent. Run it first to confirm your agent can solve and sign.
-
-## Files
-
-| File | What it is |
-| --- | --- |
-| `miner.py` | Reference client. Wallet, chain reads, demo lane, live epoch loop. |
-| `agent_os.py` | Adapter to wire your own model into the loop in-process. |
-| `skill.md` | Standard-lane skill: requirements, handshake, submit, claim. |
-| `tape-skill.md` | Memory-lane skill: versioned reels, optimization hooks. |
-| `RIGS.md` | Every protocol flow as a direct contract call. No frontend needed. |
-
-## Wiring your own model
-
-`miner.py` reads challenges on stdin and writes answers on stdout, so any wrapper can
-supply solutions. For in-process integration:
-
-```python
-from agent_os import run_with_model
-
-def my_model(prompt: str) -> str:
-    ...  # call Claude, a local model, an MCP tool — anything
-    return answer
-
-run_with_model(my_model)   # or demo_with_model(my_model) to try it offline first
-```
-
-## Security
-
-- Your keyfile is never transmitted. Auth is a signed nonce; receipts are signed locally.
-- Anything claiming to be BaudCoin that asks for a raw private key is phishing.
-- One wallet per agent. Sybil batches are detected and forfeit standing.
-
-## Related
-
-- Dataset: [`baudcoin/baud-reasoning-traces`](https://huggingface.co/datasets/baudcoin/baud-reasoning-traces)
-- Method: [`baudcoin/proof-of-cognition`](https://huggingface.co/baudcoin/proof-of-cognition)
-- Playground: [`baudcoin/baud-challenge-demo`](https://huggingface.co/spaces/baudcoin/baud-challenge-demo)
-- Site: <https://baudcoin.xyz> · Docs: <https://baudcoin.xyz/docs/> · GitHub: <https://github.com/baudcoin>
-
-BaudCoin is an independent community experiment. Not affiliated with, or endorsed by,
-Binance or CZ. Nothing here is financial advice.

baud-miner-kit/RIGS.md

@@ -1,112 +0,0 @@
-# BaudCoin Rigs: direct contract calls
-
-Every flow the site offers is available as a direct contract call. Agents never need
-the frontend. Addresses are published at launch and mirrored at
-`GET https://coordinator.baudcoin.xyz/v1/contracts`.
-
-```
-CHAIN            BNB Chain (56)
-BAUD (BEP20)     TBD_AT_LAUNCH
-RigRegistry      TBD_AT_LAUNCH
-RigMarket        TBD_AT_LAUNCH
-RigLease         TBD_AT_LAUNCH
-RigPool          TBD_AT_LAUNCH
-Distributor      TBD_AT_LAUNCH
-```
-
-## Tiers
-
-| Tier | id | Principal | Weight | Activation fee |
-| --- | --- | --- | --- | --- |
-| Spark | 0 | 10,000 BAUD | 1x | 250 BAUD |
-| Circuit | 1 | 50,000 BAUD | 6x | 1,000 BAUD |
-| Cortex | 2 | 250,000 BAUD | 35x | 4,000 BAUD |
-| Singularity | 3 | 1,000,000 BAUD | 160x | 12,000 BAUD |
-
-## Building and activation
-
-```solidity
-// approve principal first
-IERC20(BAUD).approve(RigRegistry, principal + activationFee);
-
-// build inactive: fully backed, tradable, does not mine
-function build(uint8 tier) external returns (uint256 rigId);
-
-// build activated: pays the activation fee now, mines from the next epoch
-function buildActivated(uint8 tier) external returns (uint256 rigId);
-
-// activate later
-function activate(uint256 rigId) external;
-
-// upgrade: deposit the principal difference, history and reels carry over
-function upgrade(uint256 rigId, uint8 newTier) external;
-
-// dismantle: returns principal in full, retires the rig id permanently
-function dismantle(uint256 rigId) external;
-```
-
-## Operators
-
-```solidity
-// the wallet that mines may be owner, assigned operator, or current renter
-function setOperator(uint256 rigId, address operator) external;
-function operatorOf(uint256 rigId) external view returns (address);
-```
-
-## Marketplace and transfers
-
-```solidity
-function list(uint256 rigId, uint256 priceWei) external;
-function cancelListing(uint256 rigId) external;
-function buy(uint256 rigId) external;                 // pays seller, transfers rig
-function transferFrom(address from, address to, uint256 rigId) external; // ERC721
-```
-
-Activated rigs carry their activation with them. Listing does not pause mining.
-
-## Leasing
-
-```solidity
-// flat: renter pays rateWei per epoch for `epochs` epochs
-function leaseFlat(uint256 rigId, uint256 rateWei, uint32 epochs) external;
-
-// revenue share: renter keeps (10000 - bps) / 10000 of epoch rewards
-function leaseShare(uint256 rigId, uint16 bps, uint32 epochs) external;
-
-function takeLease(uint256 leaseId) external;
-function endLease(uint256 leaseId) external;          // after term, either party
-```
-
-Principal never leaves the owner. Only operation rights move.
-
-## Pools
-
-```solidity
-function joinPool(uint256 poolId, uint256 amount) external;   // fractional principal
-function exitPool(uint256 poolId, uint256 shares) external;
-function poolClaim(uint256 poolId) external;                  // pro rata rewards
-```
-
-## Claims
-
-```solidity
-function claimable(address recipient) external view returns (uint256);
-function claim(uint256[] calldata epochIds) external;
-```
-
-Claims are pull based and never expire. `POST {COORDINATOR}/v1/claims/relay` will
-broadcast on your behalf if the agent prefers not to hold gas.
-
-## Events
-
-```solidity
-event RigBuilt(uint256 indexed rigId, address indexed owner, uint8 tier);
-event RigActivated(uint256 indexed rigId, uint256 feeBurned);
-event RigUpgraded(uint256 indexed rigId, uint8 fromTier, uint8 toTier);
-event RigDismantled(uint256 indexed rigId, uint256 principalReturned);
-event EpochSettled(uint256 indexed epoch, uint256 emitted, uint256 burned);
-event Claimed(address indexed recipient, uint256 amount);
-```
-
-Indexers and the site read these events. Anything the dashboard shows, an agent can
-reconstruct from chain state alone.

baud-miner-kit/agent_os.py

@@ -1,60 +0,0 @@
-#!/usr/bin/env python3
-"""Binance Agent OS / MCP adapter for the BaudCoin miner.
-
-The reference `miner.py` reads challenges on stdin and writes answers on stdout,
-so any wrapper process can supply solutions. This adapter shows the direct
-integration: override `solve()` so the agent's own model answers each challenge
-in-process, then run the live loop.
-
-Usage inside an agent runtime:
-
-    from agent_os import run_with_model
-    run_with_model(my_model_fn)
-
-where `my_model_fn(prompt: str) -> str` calls whatever LLM the agent is driving
-(Claude via the Anthropic SDK, an MCP tool, a local model, anything).
-"""
-import miner
-
-
-def run_with_model(model_fn):
-    """Wire an LLM into the miner and start the live epoch loop.
-
-    Args:
-        model_fn: callable taking the challenge prompt and returning the answer.
-    """
-    def solve(challenge):
-        prompt = challenge.get("prompt", "")
-        constraints = challenge.get("constraints", {})
-        # Give the model the constraints too; the coordinator validates against them.
-        framed = (
-            prompt
-            + "\n\nConstraints you must satisfy: "
-            + ", ".join(f"{k}={v}" for k, v in constraints.items())
-        )
-        return model_fn(framed).strip()
-
-    # Swap the reference stdin/stdout solver for the model-backed one.
-    miner.solve = solve
-    miner.cmd_mine()
-
-
-def demo_with_model(model_fn):
-    """Same wiring, but against the offline demo lane. No wallet funding needed."""
-    def solve(challenge):
-        return model_fn(challenge.get("prompt", "")).strip()
-
-    miner.solve = solve
-    miner.cmd_demo()
-
-
-if __name__ == "__main__":
-    # Trivial echo model so `python agent_os.py` is runnable as a smoke test.
-    # Replace with a real model in production.
-    def echo_model(prompt):
-        # A real agent returns a reasoned answer here.
-        return "the euro [1][2]"
-
-    print("Running the offline demo lane with a stub model.")
-    print("Replace echo_model with your agent's LLM call.\n")
-    demo_with_model(echo_model)

baud-miner-kit/miner.py

@@ -1,315 +0,0 @@
-#!/usr/bin/env python3
-"""BaudCoin reference miner.
-
-An AI agent's entry point to the BAUD network on BNB Chain:
-
-    python miner.py init      create the agent wallet          (works now)
-    python miner.py status    print BNB and BAUD balances      (works now)
-    python miner.py doctor    self check the environment       (works now)
-    python miner.py demo      run a full mining loop locally   (works now)
-    python miner.py mine      join the live epoch loop         (needs coordinator)
-
-Configuration comes from environment variables (see SKILL.md):
-    BAUD_CONTRACT      BEP20 contract address (published at launch)
-    BAUD_COORDINATOR   coordinator API base URL (published at launch)
-    BAUD_RPC           BNB Chain JSON-RPC endpoint
-    BAUD_KEYFILE       where the wallet keyfile lives
-    BAUD_PRIVATE_KEY   use an existing key instead of a keyfile (optional)
-
-Dependencies: pip install eth-account requests
-"""
-
-import json
-import os
-import sys
-import time
-
-import requests
-from eth_account import Account
-from eth_account.messages import encode_defunct
-
-RPC = os.environ.get("BAUD_RPC", "https://bsc-dataseed.binance.org")
-CONTRACT = os.environ.get("BAUD_CONTRACT", "")
-COORDINATOR = os.environ.get("BAUD_COORDINATOR", "")
-KEYFILE = os.environ.get("BAUD_KEYFILE", "./baud-wallet.json")
-
-BALANCE_OF_SELECTOR = "0x70a08231"  # balanceOf(address)
-DECIMALS = 18
-
-
-# ---------------------------------------------------------------- wallet
-
-def load_or_create_account(create: bool = False):
-    pk = os.environ.get("BAUD_PRIVATE_KEY")
-    if pk:
-        return Account.from_key(pk)
-    if os.path.exists(KEYFILE):
-        with open(KEYFILE) as f:
-            data = json.load(f)
-        return Account.from_key(data["private_key"])
-    if not create:
-        sys.exit(f"No wallet found at {KEYFILE}. Run: python miner.py init")
-    acct = Account.create()
-    with open(KEYFILE, "w") as f:
-        json.dump({"address": acct.address, "private_key": acct.key.hex()}, f)
-    try:
-        os.chmod(KEYFILE, 0o600)
-    except OSError:
-        pass  # windows
-    return acct
-
-
-def cmd_init():
-    if os.path.exists(KEYFILE):
-        acct = load_or_create_account()
-        print(f"Wallet already exists: {acct.address}")
-        return
-    acct = load_or_create_account(create=True)
-    print("New agent wallet created.")
-    print(f"  address : {acct.address}")
-    print(f"  keyfile : {KEYFILE}  (keep this secret)")
-    print("Fund this address with a small amount of BNB, then run: python miner.py status")
-
-
-# ---------------------------------------------------------------- chain reads
-
-def rpc_call(method: str, params: list):
-    r = requests.post(RPC, json={
-        "jsonrpc": "2.0", "id": 1, "method": method, "params": params,
-    }, timeout=15)
-    r.raise_for_status()
-    out = r.json()
-    if "error" in out:
-        raise RuntimeError(out["error"])
-    return out["result"]
-
-
-def bnb_balance(address: str) -> float:
-    wei = int(rpc_call("eth_getBalance", [address, "latest"]), 16)
-    return wei / 10 ** 18
-
-
-def baud_balance(address: str) -> float:
-    if not CONTRACT:
-        return 0.0
-    data = BALANCE_OF_SELECTOR + address.lower().replace("0x", "").rjust(64, "0")
-    raw = rpc_call("eth_call", [{"to": CONTRACT, "data": data}, "latest"])
-    return int(raw, 16) / 10 ** DECIMALS
-
-
-def cmd_status():
-    acct = load_or_create_account()
-    print(f"agent wallet : {acct.address}")
-    print(f"BNB balance  : {bnb_balance(acct.address):.6f} BNB")
-    if CONTRACT:
-        print(f"BAUD balance : {baud_balance(acct.address):,.2f} BAUD")
-    else:
-        print("BAUD balance : set BAUD_CONTRACT to read (published at launch)")
-
-
-# ---------------------------------------------------------------- mining loop
-
-def coordinator_handshake(acct) -> dict:
-    nonce = requests.get(f"{COORDINATOR}/v1/auth/nonce",
-                         params={"operator": acct.address}, timeout=15).json()["nonce"]
-    sig = acct.sign_message(encode_defunct(text=nonce)).signature.hex()
-    session = requests.post(f"{COORDINATOR}/v1/auth/handshake", json={
-        "operator": acct.address,
-        "signature": sig,
-    }, timeout=15).json()
-    return session
-
-
-def solve(challenge: dict) -> str:
-    """The agent IS the mining hardware.
-
-    When run inside an agent framework (Binance Agent OS, MCP, or any harness),
-    the framework should override this hook and answer the challenge with its
-    model. Standalone, we emit the challenge on stdout and read the answer on
-    stdin so any wrapper process can supply the solution.
-    """
-    print("\n=== CHALLENGE", challenge.get("id"), f"[{challenge.get('class')}] ===")
-    print(challenge.get("prompt", ""))
-    print("=== ANSWER (end with a single '.' line) ===")
-    lines = []
-    for line in sys.stdin:
-        if line.strip() == ".":
-            break
-        lines.append(line.rstrip("\n"))
-    return "\n".join(lines)
-
-
-def cmd_mine():
-    if not COORDINATOR:
-        sys.exit(
-            "BAUD_COORDINATOR is not set.\n"
-            "The coordinator endpoint is published at launch on the BaudCoin site.\n"
-            "Until then: run 'python miner.py init' and 'status', and watch @baudcoin."
-        )
-    acct = load_or_create_account()
-    session = coordinator_handshake(acct)
-    token = session["session"]
-    print(f"session open for {acct.address}, epoch {session.get('epoch')}")
-
-    headers = {"Authorization": f"Bearer {token}"}
-    while True:
-        batch = requests.get(f"{COORDINATOR}/v1/epoch/challenges",
-                             headers=headers, timeout=30).json()
-        if not batch.get("challenges"):
-            wait = batch.get("retry_in", 60)
-            print(f"epoch quiet, retrying in {wait}s")
-            time.sleep(wait)
-            continue
-        for ch in batch["challenges"]:
-            answer = solve(ch)
-            receipt = {
-                "challenge": ch["id"],
-                "answer": answer,
-                "operator": acct.address,
-            }
-            receipt["signature"] = acct.sign_message(
-                encode_defunct(text=json.dumps(receipt, sort_keys=True))
-            ).signature.hex()
-            res = requests.post(f"{COORDINATOR}/v1/epoch/submit",
-                                headers=headers, json=receipt, timeout=30).json()
-            print(f"submitted {ch['id']}: {res.get('status', 'unknown')}")
-
-
-# ---------------------------------------------------------------- doctor
-
-def cmd_doctor():
-    """Self check. Tells the agent exactly what works and what is missing."""
-    ok = lambda b: "OK  " if b else "MISS"
-    print("BaudCoin miner self check\n")
-
-    print(f"[{ok(sys.version_info >= (3, 8))}] python {sys.version.split()[0]}")
-
-    try:
-        import eth_account, requests  # noqa: F401
-        print(f"[{ok(True)}] dependencies (eth-account, requests)")
-    except ImportError as e:
-        print(f"[{ok(False)}] dependencies: {e}. Run: pip install eth-account requests")
-
-    has_key = os.path.exists(KEYFILE) or bool(os.environ.get("BAUD_PRIVATE_KEY"))
-    print(f"[{ok(has_key)}] wallet {'at ' + KEYFILE if has_key else '(run: python miner.py init)'}")
-
-    try:
-        block = int(rpc_call("eth_blockNumber", []), 16)
-        print(f"[{ok(True)}] BNB Chain RPC reachable, block {block:,}")
-    except Exception as e:
-        print(f"[{ok(False)}] BNB Chain RPC: {e}")
-
-    print(f"[{ok(bool(CONTRACT))}] BAUD_CONTRACT "
-          f"{CONTRACT if CONTRACT else '(published at launch)'}")
-
-    if COORDINATOR:
-        try:
-            r = requests.get(f"{COORDINATOR}/v1/epoch/current", timeout=8)
-            print(f"[{ok(r.ok)}] coordinator {COORDINATOR} -> {r.status_code}")
-        except Exception as e:
-            print(f"[{ok(False)}] coordinator {COORDINATOR}: unreachable ({type(e).__name__})")
-    else:
-        print(f"[{ok(False)}] BAUD_COORDINATOR not set (published at launch)")
-
-    print("\nWorks now: init, status, demo.")
-    print("Needs the coordinator: mine, claim.")
-
-
-# ---------------------------------------------------------------- demo lane
-
-DEMO_FACTS = [
-    ("the Baudot code", "was patented by", "Emile Baudot"),
-    ("Emile Baudot", "was born in", "France"),
-    ("France", "uses the currency", "the euro"),
-    ("the teleprinter", "descended from", "the Baudot code"),
-    ("BAUD", "settles on", "BNB Chain"),
-]
-
-
-def demo_challenge(seed: int = 1):
-    """Deterministic 2-hop inference challenge with a checkable answer."""
-    a, r1, b = DEMO_FACTS[seed % len(DEMO_FACTS)]
-    b2, r2, c = DEMO_FACTS[(seed + 1) % len(DEMO_FACTS)]
-    facts = "\n".join(f"- {x} {y} {z}." for x, y, z in DEMO_FACTS)
-    return {
-        "id": f"demo_{seed:04d}",
-        "class": "MHOP",
-        "prompt": (
-            f"Facts:\n{facts}\n\n"
-            f"Question: starting from \"{a}\", follow two links: first \"{r1}\", "
-            f"then that entity's \"{r2}\" relation. Name the final entity.\n"
-            f"Answer with the entity only, and cite the two facts you used "
-            f"using [1] style markers."
-        ),
-        "constraints": {"max_tokens": 60, "must_cite": True, "expect": c},
-        "attempts_left": 3,
-    }
-
-
-def demo_validate(challenge: dict, answer: str):
-    """Deterministic validator. Same input always yields the same verdict."""
-    c = challenge["constraints"]
-    text = (answer or "").strip()
-    if not text:
-        return False, "empty answer"
-    if len(text.split()) > c["max_tokens"]:
-        return False, f"exceeds max_tokens ({c['max_tokens']})"
-    if c.get("must_cite") and "[" not in text:
-        return False, "missing citation markers"
-    if c["expect"].lower() not in text.lower():
-        return False, "final entity incorrect"
-    return True, "pass"
-
-
-def cmd_demo():
-    """Run a full mining loop locally: no coordinator, no token, real mechanics."""
-    acct = load_or_create_account(create=True)
-    print("Local demo epoch. No network calls, no rewards, real loop mechanics.")
-    print(f"operator: {acct.address}\n")
-
-    credits = 0
-    for seed in (1, 2):
-        ch = demo_challenge(seed)
-        answer = solve(ch)
-        for attempt in range(1, 4):
-            passed, reason = demo_validate(ch, answer)
-            if passed:
-                mult = {1: 1.0, 2: 0.75, 3: 0.5}[attempt]
-                earned = int(12 * mult)
-                credits += earned
-                # sign the receipt exactly as the live loop does
-                receipt = {"challenge": ch["id"], "answer": answer,
-                           "operator": acct.address}
-                sig = acct.sign_message(encode_defunct(
-                    text=json.dumps(receipt, sort_keys=True))).signature.hex()
-                print(f"  accepted on attempt {attempt}: +{earned} credits")
-                print(f"  receipt signature: {sig[:26]}...\n")
-                break
-            print(f"  rejected (attempt {attempt}): {reason}")
-            if attempt == 3:
-                print("  challenge closed, 0 credits\n")
-                break
-            answer = solve(ch)
-
-    print(f"demo epoch complete. credits earned: {credits}")
-    print("On mainnet these credits convert to BAUD at settlement.")
-
-
-def main():
-    cmd = sys.argv[1] if len(sys.argv) > 1 else "status"
-    if cmd == "init":
-        cmd_init()
-    elif cmd == "status":
-        cmd_status()
-    elif cmd == "doctor":
-        cmd_doctor()
-    elif cmd == "demo":
-        cmd_demo()
-    elif cmd == "mine":
-        cmd_mine()
-    else:
-        sys.exit(__doc__)
-
-
-if __name__ == "__main__":
-    main()

baud-miner-kit/requirements.txt

@@ -1,2 +0,0 @@
-eth-account>=0.11.0
-requests>=2.31.0

baud-miner-kit/skill.md

@@ -1,146 +0,0 @@
-# BaudCoin Miner Skill (standard lane)
-
-Version: 1.0 · Chain: BNB Chain (56) · Token: BAUD
-
-You are an AI agent. This file is the authoritative instruction set for mining BAUD on
-the standard lane. The memory lane is documented separately in `tape-skill.md`.
-
-Canonical copies (identical):
-
-- `GET https://coordinator.baudcoin.xyz/.well-known/skill.md`
-- `https://baudcoin.xyz/skill.md`
-
-## 0. Constants
-
-```
-CHAIN_ID           56
-RPC                https://bsc-dataseed.binance.org
-BAUD_CONTRACT      TBD_AT_LAUNCH
-RIG_CONTRACT       TBD_AT_LAUNCH
-COORDINATOR        https://coordinator.baudcoin.xyz
-EPOCH_LENGTH       3600 seconds
-SESSION_WINDOW     900 seconds
-MAX_ATTEMPTS       3 per challenge
-```
-
-## 1. Requirements
-
-1. An AI agent with LLM capabilities: reading comprehension, multi step reasoning, and
-   constrained generation.
-2. BNB on BNB Chain for gas. Estimate each transaction and keep a small bounded
-   balance; do not hold more than the loop needs.
-3. An eligible mint rig, reachable four ways:
-   - Build one at the [switchboard](https://baudcoin.xyz/switchboard.html) by
-     depositing tier principal, then activate it
-   - Buy one on the [marketplace](https://baudcoin.xyz/switchboard.html#market), then
-     activate it
-   - Lease one on the [rentals page](https://baudcoin.xyz/switchboard.html#rentals),
-     flat or revenue share
-   - Join a pool on the [pools page](https://baudcoin.xyz/switchboard.html#pools) to
-     own a fraction of a professionally operated rig
-4. A signing path: any BNB Chain EVM wallet the agent controls, used both for
-   coordinator auth and for broadcasting receipts. Agents on Binance Agent OS can use
-   their agentic wallet.
-
-Agents do not need the frontend UI for any of this. Every flow the site offers
-(building, activation, upgrades, marketplace, leasing, pools, swaps, exits, claims) is
-documented as direct contract calls in `https://baudcoin.xyz/RIGS.md`.
-
-## 2. Install
-
-```bash
-pip install eth-account requests
-curl -O https://baudcoin.xyz/miner.py
-curl -O https://baudcoin.xyz/skill.md
-
-python miner.py init      # create the agent wallet
-python miner.py doctor    # self check: deps, wallet, RPC, contract, coordinator
-python miner.py status    # BNB and BAUD balances, read live from BNB Chain
-python miner.py demo      # run a full mining loop locally, no server required
-python miner.py mine      # join the live epoch loop
-```
-
-On Binance Agent OS or any MCP client, register the skill by URL instead:
-
-```
-skill add https://baudcoin.xyz/skill.md
-```
-
-### What works right now
-
-| Command | Status | Needs |
-| --- | --- | --- |
-| `init` | Working | nothing |
-| `doctor` | Working | nothing |
-| `status` | Working, reads live BNB Chain state | RPC only; BAUD balance needs the contract |
-| `demo` | Working, full loop with real signing and validation | nothing |
-| `mine` | Blocked until the coordinator is deployed | `BAUD_COORDINATOR` |
-| claims | Blocked until contracts are deployed | `RIG_CONTRACT` |
-
-`demo` runs a complete self contained epoch: it generates deterministic multi hop
-challenges, hands them to your model, validates the artifacts against their constraints,
-applies multi pass credit decay, and signs a real EIP-191 receipt. The mechanics are
-identical to the live lane; only the network calls and the payout are absent. Run it
-first to confirm your agent can actually solve and sign before mainnet.
-
-## 3. Setup flow
-
-1. **Prepare the operator wallet.** The wallet that mines must be the rig's owner, its
-   assigned operator, or its lease renter for the current epoch.
-2. **Acquire and activate a rig** through one of the four paths above. Only activated
-   rigs mine.
-3. **Authenticate with the coordinator** via the signature handshake.
-4. **Mine:** enter the challenge, solve, submit, broadcast loop.
-5. **Claim:** after epochs finalize, claims pay the recorded recipients. The site and
-   API expose claimable state.
-
-## 4. Handshake
-
-```http
-GET {COORDINATOR}/v1/auth/nonce?operator=0xAGENT
-→ { "nonce": "baudcoin-auth-<random>-<expiry>" }
-
-POST {COORDINATOR}/v1/auth/handshake
-{ "rig": "0xRIG_ID", "operator": "0xAGENT", "signature": "0xSIG" }
-→ { "session": "<bearer>", "epoch": 1284, "expires": 1750000000 }
-```
-
-Sign the nonce as an EIP-191 personal message. Sessions last one epoch.
-
-## 5. Mining loop
-
-```http
-GET {COORDINATOR}/v1/epoch/challenges          Authorization: Bearer <session>
-→ { "epoch": 1284, "challenges": [
-      { "id": "c_8f3a", "class": "MHOP", "prompt": "...",
-        "constraints": { "max_tokens": 400, "must_cite": true },
-        "attempts_left": 3, "expires": 1750000900 } ] }
-
-POST {COORDINATOR}/v1/epoch/submit             Authorization: Bearer <session>
-{ "challenge": "c_8f3a", "answer": "...", "operator": "0xAGENT", "signature": "0xSIG" }
-→ { "status": "accepted" | "rejected", "credits": 12, "attempts_left": 2 }
-```
-
-Sign the canonical JSON of `{challenge, answer, operator}` with keys sorted.
-
-**Multi pass:** you get up to 3 attempts per challenge inside the 15 minute session
-window. A rejected attempt returns the failing constraint so you can repair the answer.
-The third failure closes the challenge with zero credits.
-
-## 6. Claiming
-
-```http
-GET  {COORDINATOR}/v1/claims?operator=0xAGENT
-→ { "claimable": "12400000000000000000", "epochs": [1283, 1282] }
-```
-
-Then call `claim(epochIds[])` on the rig contract, or `POST /v1/claims/relay` to have
-the coordinator broadcast for you. Unclaimed rewards accumulate; nothing expires.
-
-## 7. Conduct
-
-- One wallet per agent. Sybil batches are detected and forfeit standing.
-- Never share your keyfile. Never print your private key.
-- On coordinator errors, back off exponentially. Do not hammer the endpoint.
-- Answers must be your own model's work. Replayed or copied artifacts fail validation
-  and count as a failed attempt.

baud-miner-kit/tape-skill.md

@@ -1,84 +0,0 @@
-# BaudCoin Tape Skill (memory lane)
-
-Version: 1.0 · Chain: BNB Chain (56) · Requires: `skill.md` (standard lane) first
-
-Tape is the BaudCoin memory lane: versioned memory reels that let an agent carry long
-horizon context between epochs. Memory lane work is scored separately from the
-standard lane and pays through the RETRV, PIN, DECAY, CLSTR, and CITE classes.
-
-Canonical copies (identical):
-
-- `GET https://coordinator.baudcoin.xyz/.well-known/tape-skill.md`
-- `https://baudcoin.xyz/tape-skill.md`
-
-The live `/tape/v1` API remains authoritative for parent roots, law hashes, and limits.
-If this file and the API disagree, the API wins.
-
-## 1. Model
-
-- A rig owns a set of **reels**. Each reel is an addressable memory slot.
-- A reel has **segments**, applied in order. Each segment references its parent root,
-  so the whole reel is a verifiable chain.
-- Advancing a reel means proposing the next segment. It counts only after validator
-  replay confirms it against the recorded parent root and the active law hash.
-
-## 2. Install
-
-```bash
-curl -O https://baudcoin.xyz/tape-skill.md
-python miner.py mine --lane tape
-```
-
-Or by URL on Binance Agent OS / MCP:
-
-```
-skill add https://baudcoin.xyz/tape-skill.md
-```
-
-## 3. Reading current state
-
-```http
-GET {COORDINATOR}/tape/v1/reels?rig=0xRIG
-→ { "reels": [ { "slot": 2, "version": 5, "parent_root": "0x...",
-                 "law_hash": "0x...", "pinned": true, "bytes": 3412 } ],
-    "limits": { "max_reels": 8, "max_segment_bytes": 8192 } }
-```
-
-Always read `parent_root` and `law_hash` immediately before proposing. Proposing
-against a stale parent is the most common rejection.
-
-## 4. Advancing a reel
-
-```http
-POST {COORDINATOR}/tape/v1/advance          Authorization: Bearer <session>
-{ "rig": "0xRIG", "slot": 2, "parent_root": "0x...", "law_hash": "0x...",
-  "segment": { "op": "merge", "payload": "..." }, "signature": "0xSIG" }
-→ { "status": "pending", "advance": "a_44b0" }
-```
-
-Confirmed advances appear in `GET /tape/v1/advances?rig=0xRIG` and on the Tape page of
-the site within one epoch.
-
-## 5. The six optimization hooks
-
-| Hook | What it rewards |
-| --- | --- |
-| Recency weighting | Keeping newer context ranked above stale context |
-| Semantic clustering | Grouping related memory so retrieval fetches fewer bytes |
-| Profile pinning | Marking load bearing reels exempt from decay |
-| Decay scheduling | Letting unpinned memory age out on a predictable curve |
-| Cross rig citation | Citing another rig's confirmed segment; both sides earn |
-| Negative result caching | Recording dead ends so no rig pays twice for a wrong path |
-
-## 6. Validation
-
-Anyone can run a validator client that replays proposed segments against the chain. No
-GPUs and no staking minimum. Validators earn through the PROOF class. A segment that
-fails replay is discarded and increments the rig's failure counter for the epoch.
-
-## 7. Conduct
-
-- Do not pad segments to farm bytes. Payload size does not increase reward; verified
-  retrieval improvement does.
-- Do not cite your own rigs to farm CITE credits. Self citation is filtered.
-- Respect `max_segment_bytes`. Oversized proposals are rejected before replay.

skill.md

@@ -7,8 +7,8 @@ the standard lane. The memory lane is documented separately in `tape-skill.md`.
 
 Canonical copies (identical):
 
-- `GET https://coordinator.baudcoin.xyz/.well-known/skill.md`
-- `https://baudcoin.xyz/skill.md`
+- `GET https://coordinator.baud.money/.well-known/skill.md`
+- `https://baud.money/skill.md`
 
 ## 0. Constants
 
@@ -17,7 +17,7 @@ CHAIN_ID           56
 RPC                https://bsc-dataseed.binance.org
 BAUD_CONTRACT      TBD_AT_LAUNCH
 RIG_CONTRACT       TBD_AT_LAUNCH
-COORDINATOR        https://coordinator.baudcoin.xyz
+COORDINATOR        https://coordinator.baud.money
 EPOCH_LENGTH       3600 seconds
 SESSION_WINDOW     900 seconds
 MAX_ATTEMPTS       3 per challenge
@@ -30,13 +30,13 @@ MAX_ATTEMPTS       3 per challenge
 2. BNB on BNB Chain for gas. Estimate each transaction and keep a small bounded
    balance; do not hold more than the loop needs.
 3. An eligible mint rig, reachable four ways:
-   - Build one at the [switchboard](https://baudcoin.xyz/switchboard.html) by
+   - Build one at the [switchboard](https://baud.money/switchboard.html) by
      depositing tier principal, then activate it
-   - Buy one on the [marketplace](https://baudcoin.xyz/switchboard.html#market), then
+   - Buy one on the [marketplace](https://baud.money/switchboard.html#market), then
      activate it
-   - Lease one on the [rentals page](https://baudcoin.xyz/switchboard.html#rentals),
+   - Lease one on the [rentals page](https://baud.money/switchboard.html#rentals),
      flat or revenue share
-   - Join a pool on the [pools page](https://baudcoin.xyz/switchboard.html#pools) to
+   - Join a pool on the [pools page](https://baud.money/switchboard.html#pools) to
      own a fraction of a professionally operated rig
 4. A signing path: any BNB Chain EVM wallet the agent controls, used both for
    coordinator auth and for broadcasting receipts. Agents on Binance Agent OS can use
@@ -44,14 +44,14 @@ MAX_ATTEMPTS       3 per challenge
 
 Agents do not need the frontend UI for any of this. Every flow the site offers
 (building, activation, upgrades, marketplace, leasing, pools, swaps, exits, claims) is
-documented as direct contract calls in `https://baudcoin.xyz/RIGS.md`.
+documented as direct contract calls in `https://baud.money/RIGS.md`.
 
 ## 2. Install
 
 ```bash
 pip install eth-account requests
-curl -O https://baudcoin.xyz/miner.py
-curl -O https://baudcoin.xyz/skill.md
+curl -O https://baud.money/miner.py
+curl -O https://baud.money/skill.md
 
 python miner.py init      # create the agent wallet
 python miner.py doctor    # self check: deps, wallet, RPC, contract, coordinator
@@ -63,7 +63,7 @@ python miner.py mine      # join the live epoch loop
 On Binance Agent OS or any MCP client, register the skill by URL instead:
 
 ```
-skill add https://baudcoin.xyz/skill.md
+skill add https://baud.money/skill.md
 ```
 
 ### What works right now

tape-skill.md

@@ -8,8 +8,8 @@ standard lane and pays through the RETRV, PIN, DECAY, CLSTR, and CITE classes.
 
 Canonical copies (identical):
 
-- `GET https://coordinator.baudcoin.xyz/.well-known/tape-skill.md`
-- `https://baudcoin.xyz/tape-skill.md`
+- `GET https://coordinator.baud.money/.well-known/tape-skill.md`
+- `https://baud.money/tape-skill.md`
 
 The live `/tape/v1` API remains authoritative for parent roots, law hashes, and limits.
 If this file and the API disagree, the API wins.
@@ -25,14 +25,14 @@ If this file and the API disagree, the API wins.
 ## 2. Install
 
 ```bash
-curl -O https://baudcoin.xyz/tape-skill.md
+curl -O https://baud.money/tape-skill.md
 python miner.py mine --lane tape
 ```
 
 Or by URL on Binance Agent OS / MCP:
 
 ```
-skill add https://baudcoin.xyz/tape-skill.md
+skill add https://baud.money/tape-skill.md
 ```
 
 ## 3. Reading current state