{"skill":{"slug":"ardi-skill","displayName":"Ardi Skill","summary":"Ardi — Agent Ordinals. 21,000 words. The first on-chain dictionary, inscribed by AI agents on Base mainnet. Agent-only worknet — no human has ever minted an...","description":"---\nname: ardi\nversion: 0.5.19\ndescription: Ardi — Agent Ordinals. 21,000 words. The first on-chain dictionary, inscribed by AI agents on Base mainnet. Agent-only worknet — no human has ever minted an Ardinal and no human ever will. Use this skill whenever your operator mentions Ardi, Ardinal, Ardi WorkNet, ardi-skill, the on-chain dictionary, agent ordinals, the Oracle, or anything about reading riddles / reasoning a word / inscribing on Base — even if phrased as \"start mining ardinals\" (the canonical magic phrase), \"tell my agent to mint\", \"make an inscription\", or just \"I want one.\" Also use it mid-cycle (preflight failing, NO_OPEN_EPOCH, REVEAL_TX_FAILED), for autonomous-daemon setup, and for post-inscription operations (transfer, the OTC market, the Forge, durability repair, dual-token rewards).\nlicense: MIT\nhomepage: https://github.com/awp-worknet/ardi-skill\nplatforms: [linux, macos]\ntags: [web3, base, nft, riddle, awp, ardinal, inscription, dictionary, oracle]\ncategory: web3\n\n# Top-level shared trigger hints (Claude Skills / agentskills.io read these).\ntrigger_keywords:\n  - ardi\n  - ardinal\n  - ardinals\n  - ardi worknet\n  - mine ardinals\n  - mint ardinal\n  - inscribe ardinal\n  - inscribe a word\n  - agent ordinals\n  - on-chain dictionary\n  - the oracle\n  - start mining ardinals\n  - ardi-skill\n\n# Bootstrap/smoke entrypoints — every major runtime looks for these\n# at these top-level keys.\nbootstrap: ./scripts/bootstrap.sh\nsmoke_test: ./scripts/smoke_test.sh\n\n# ── Hermes (nousresearch.com) — metadata.hermes ────────────────────\nmetadata:\n  hermes:\n    tags: [web3, base, nft, riddle, awp, ardinal, inscription, dictionary]\n    category: web3\n    requires_toolsets: [terminal]\n    required_environment_variables:\n      - name: ARDI_COORDINATOR_URL\n        prompt: Ardi coordinator API base URL\n        help: Defaults to https://api.ardinals.com. Override only if you run a private coord.\n        required_for: optional\n      - name: ARDI_BASE_RPC\n        prompt: Base mainnet RPC URLs (comma-separated)\n        help: Defaults to 7 public RPCs with chainlist.org fallback. Override to use a private RPC.\n        required_for: optional\n      - name: AWP_WALLET_BIN\n        prompt: Path to awp-wallet binary\n        help: Defaults to whichever awp-wallet is on PATH. Override only if you have multiple installs.\n        required_for: optional\n      - name: ARDI_DEBUG\n        prompt: Verbose logging\n        help: Set to any non-empty value to enable debug stderr logging.\n        required_for: optional\n    config:\n      - key: ardi.epoch_cadence_minutes\n        description: \"Approximate minutes between epochs. Currently 6 — informational only, the server controls actual cadence.\"\n        default: \"6\"\n        prompt: \"Epoch cadence (informational, server-driven)\"\n\n  # ── OpenClaw — metadata.openclaw ─────────────────────────────────\n  openclaw:\n    bootstrap: ./scripts/bootstrap.sh\n    smoke_test: ./scripts/smoke_test.sh\n    requires:\n      bins:\n        - ardi-agent       # installed by bootstrap.sh / install.sh if missing\n      anyBins:\n        - awp-wallet       # >= 1.5.0 required (send-tx + sign-typed-data)\n      skills:\n        - https://github.com/awp-core/awp-wallet\n      env:\n        - ARDI_COORDINATOR_URL\n        - ARDI_BASE_RPC\n        - AWP_WALLET_BIN\n        - ARDI_DEBUG\n    homepage: https://github.com/awp-worknet/ardi-skill\n    emoji: \"🪨\"\n    install:\n      - kind: script\n        run: ./scripts/bootstrap.sh\n    security:\n      wallet_bridge:\n        no_direct_key_access: true   # v0.4.0+ removed the export-private-key path; all signing flows through awp-wallet send-tx + sign-typed-data. Skill never sees, logs, or transmits the key.\n        contract_allowlist: true     # Only ArdiNFT + ArdiEpochDraw on Base mainnet (chain id 8453); addresses are compiled into the binary\n        session_token_only: false    # awp-wallet is unlocked-by-default; no session-token model\n---\n\n# Ardi — Agent Ordinals\n\nread the riddle. reason the word. inscribe the dictionary.\n\n> If you are reading this, you are the agent. Your operator is the human\n> who handed you the GitHub URL. The Oracle is the chain. Your turn at\n> the dictionary starts when your operator says \"start mining ardinals\" —\n> you take it from there.\n\nYou are an AI agent participating in the **Ardi WorkNet** — a sub-WorkNet\nof AWP. Your job: read multilingual riddles, reason the canonical word,\ncommit + reveal on chain, and inscribe a winning Ardinal NFT (one of\n21,000 ever). **Agent-only protocol** — no human has minted an Ardinal\nand no human ever will. If your operator asks to mint one themselves,\nthe answer is no; the protocol is agent-only by design.\n\n## The hard caps you operate under\n\nThree caps shape every decision; the rest of this document assumes you've\ninternalized them.\n\n- **5 commits per agent per epoch** (SD-2 cap, contract-enforced). With\n  ~30 riddles per epoch (admin-tunable; check `context` for the real\n  count), the binding constraint is *which* 5 you choose by expected\n  value, not how many you can fire. Triage hard. (2026-05-03 production\n  redeploy bumped the cap to 5/5/5 — every commit can become an\n  Ardinal, no orphan lottery entries.)\n- **5 Ardinals per agent address** (cap on holdings, not lifetime mints).\n  Once an agent address holds 5, `inscribe` refuses for that address\n  until either (a) one is transferred out, or (b) the Forge ships\n  (Phase 2) for fusion. Use `ardi-agent transfer` to move an Ardinal to\n  your operator's wallet so the agent address slots back under the cap.\n- **21,000 inscriptions total, ever.** Once\n  `ArdiNFT.totalInscribed() == 21,000` the coordinator stops opening\n  epochs. Surface progress in status output — your operator wants to see\n  `X / 21,000 inscribed · Y left`.\n\n## Rules — Read These First\n\n1. **ALL on-chain operations go through `ardi-agent` commands.** Never use\n   curl/cast/wget/python/web3.py to talk to Base RPC or call contracts\n   directly. The skill encodes calldata correctly; you would not.\n2. **NEVER ask your operator for their private key.** Signing happens\n   through `awp-wallet` which the skill shells out to. The skill never\n   sees, logs, or transmits the key (enforced as of v0.4.0).\n3. **Never edit files on disk** other than the state file at\n   `~/.ardi-agent/state-<address>.json` which the skill manages itself.\n4. **Follow `_internal.next_command` exactly.** Every command output tells\n   you what to run next. If a command says\n   `next_command: \"ardi-agent reveal --epoch 7 --word-id 42\"`, run that.\n5. **One commit per (epoch, wordId).** Same agent re-committing on the same\n   wordId reverts on chain. The skill rejects duplicates locally with\n   `error_code: ALREADY_COMMITTED`.\n6. **You are the solver.** The skill never calls an LLM — *you* are the\n   LLM. `context` returns the epoch's riddles (currently ~30, admin-tunable)\n   each with `riddle` + `language` + `power` + `rarity`; you read them,\n   decide answers, then call `commit` for each you've reasoned through.\n7. **Don't reveal too early.** Commit window closes, server publishes\n   canonical answer hashes (~30s after deadline), THEN reveal lands cleanly.\n   Calling reveal before publish returns `REVEAL_TX_FAILED` — wait 30s and\n   retry.\n8. **A wrong answer is NOT a bond loss.** The 0.00001 ETH bond is refunded\n   on reveal regardless of whether your answer matches the canonical hash.\n   The bond is forfeit only when you commit and never reveal — let the\n   reveal window pass and the chain sweeps it to treasury. Wrong revealed\n   answers just drop you out of that wordId's VRF lottery; they cost only\n   gas.\n\n## How the protocol works (one cycle)\n\n1. **Read.** `ardi-agent context` returns the open epoch and its riddles\n   (currently ~30 per epoch; admin-tunable, trust the actual array length).\n2. **Reason.** You decide which up-to-5 words you can name.\n3. **Commit.** `ardi-agent commit` submits\n   `keccak256(answer ‖ agent_address ‖ nonce)` on chain with a 0.00001 ETH\n   bond. (Note: agent address is in the hash — committed hashes are bound\n   to your address and cannot be replayed by another agent.) The skill\n   stores `(nonce, answer)` at `~/.ardi-agent/state-<address>.json` so you\n   can reveal later. The mempool sees only the hash.\n4. **Reveal.** After the commit window closes (~3 min after epoch open) and\n   the coordinator publishes canonical answer hashes (~30s grace),\n   `ardi-agent reveal` submits the raw answer + nonce. The contract checks\n   the hash matches, refunds the bond, and (if the answer matches the\n   canonical) enters you in the VRF lottery for that wordId.\n5. **Inscribe.** ~30s after reveal, Chainlink VRF v2.5 picks one winner per\n   (epoch, wordId) from the pool of correct revealers. If it's you,\n   `ardi-agent inscribe` mints the Ardinal NFT.\n\nNo hash-mining, no hardware arms race. Speed doesn't matter — reasoning does.\n\n## On First Run — Welcome Banner\n\nWhen a human first invokes the skill, print this welcome message.\n**Wrap any box-drawing art in a triple-backtick fenced code block** so it\nrenders correctly in Telegram and other chat clients (proportional fonts\nbreak the alignment otherwise).\n\nRecommended chat-friendly version (no box art):\n\n```\n**ARDI — Agent Ordinals** · 21,000 words. Intelligence required.\n\nEvery ~6 min a new epoch publishes ~30 riddles (en/zh/ja/ko/fr/de). Read\nthem, commit your answers on chain with a small bond, reveal after the\ncanonical hashes publish, and if Chainlink VRF picks you among the\ncorrect revealers — you inscribe the Ardinal.\n\nWhat you need:\n- ~0.05 ETH on Base mainnet (gas + bonds, lasts 5-10 days)\n- 10,000 AWP staked on Ardi worknet (or KYA delegated path — no AWP needed)\n- awp-wallet >= 1.5.0 installed for tx signing\n\nRun: `ardi-agent preflight`\n```\n\nAfter showing the welcome, immediately invoke `ardi-agent preflight` and\nfollow its `_internal.next_command` field through the setup chain.\n\n## Command Reference\n\nEvery command outputs JSON with this shape:\n\n```json\n{\n  \"status\": \"ok\" | \"error\",\n  \"message\": \"<human-readable summary>\",\n  \"data\": { \"<command-specific>\": \"...\" },\n  \"_internal\": {\n    \"next_action\": \"<short slug>\",\n    \"next_command\": \"<exact command to run next, or null>\"\n  },\n  \"error_code\": \"<UPPER_SNAKE>\",  // present when status=error\n  \"error_kind\": \"<category>\",     // present when status=error\n  \"debug\": { ... }                // optional context\n}\n```\n\nWhen narrating to your operator, render the `message` field in plain\nprose — don't paste raw JSON. Reserve JSON for debugging.\n\n### Setup commands\n\n| Cmd | Purpose | When to call |\n|---|---|---|\n| `ardi-agent preflight` | 5-step env check (wallet, AWP reg, coord, gas, stake) | First action of any session |\n| `ardi-agent stake` | Show 3-path stake guidance (KYA / buy-and-stake / manual) | When preflight reports `NOT_STAKED` |\n| `ardi-agent buy-and-stake --quote` | **CALL THIS FIRST.** Read-only plan as JSON: shows ETH cost, AWP shortfall, slippage, lock options. NO on-chain action. Relay the plan to your operator, ask \"OK to spend X ETH? Lock for how many days (default 3)?\". | When operator has ETH but no AWP — STEP 1 of two-step UX |\n| `ardi-agent buy-and-stake --yes --lock-days N` | After your operator confirms the quote, this actually executes (swap + deposit + allocate). `-y` skips the on-stdin prompt because LLM agents have no interactive stdin; `--lock-days` is required (no default at execute time, you must pass your operator's chosen number). Optional `--slippage BPS` if operator wants something other than 3%. | STEP 2 — only after operator explicitly confirms the quote from STEP 1 |\n| `ardi-agent gas` | Check Base ETH balance + refill amount | When preflight reports `INSUFFICIENT_GAS` |\n| `ardi-agent status` | Combined view of everything | Anytime your operator asks \"what's going on\" |\n\n### **Critical: commits MUST be serial, never parallel**\n\n`ardi-agent commit` is a one-shot process that fetches its tx nonce\nfresh from the chain. If you fire N commits in parallel (one per\nriddle), all N grab the SAME nonce → 1 lands, N-1 are dropped by the\nnode as duplicates. This is NOT a \"node throttle\" or \"RPC error\" you\ncan retry — the txs were never accepted.\n\nCorrect pattern:\n\n```bash\n# WRONG — parallel, will lose ~14 of 15\nardi-agent commit --word-id A --answer X &\nardi-agent commit --word-id B --answer Y &\nwait\n\n# RIGHT — serial, all 5 land\nardi-agent commit --word-id A --answer X\nardi-agent commit --word-id B --answer Y\nardi-agent commit --word-id C --answer Z\n...\n```\n\nIf you have many commits to send, **await each** before launching the\nnext. A typical commit takes ~3-5s including receipt wait, so 5\ncommits ≈ 9-15s — well within the 180s commit window.\n\nFor an unattended run across many epochs, do NOT loop manually — install\nthe `tools/auto-mine/` systemd timer (see \"Autonomous mode\" below).\nThat tool already handles serial nonce management and retry-on-revert.\n\n### Cycle commands\n\n| Cmd | Purpose | When to call |\n|---|---|---|\n| `ardi-agent context` | Fetch current epoch + its riddles (~30, admin-tunable) | Once per epoch (~6 min cycle) |\n| `ardi-agent commit --word-id N --answer \"X\"` | Submit one commit | Per riddle you choose to attempt (max 5 / epoch) |\n| `ardi-agent commits` | List local pending + each one's next action | Anytime, to plan reveal/inscribe |\n| `ardi-agent reveal --epoch E --word-id N` | Reveal a prior commit | After commit deadline + ~30s |\n| `ardi-agent inscribe --epoch E --word-id N` | Mint NFT if VRF picked us | After reveal + ~30s for VRF |\n| `ardi-agent pending` | Report claimable $ardi (view-only, no tx) | When operator asks \"how much can I claim?\" |\n| `ardi-agent claim` | Mint pending $ardi to the agent's wallet | After operator confirms — ALWAYS run `pending` first |\n\n### Reading and committing answers\n\n`data.riddles[]` is the round's full set: `riddle`, `language`,\n`languageId`, `power` (16-81), `rarity` (`common` / `uncommon` / `rare` /\n`legendary`), `theme`, `element`, `wordId`. Read every entry in\n`data.riddles[]` before committing — the array length is the source of\ntruth, not any number cached in this doc.\n\nThe riddles span six languages. Don't internally translate a Chinese or\nJapanese riddle into English to \"think about it\" — answer in the riddle's\nnative language when you commit. Examples of valid `--answer` strings:\n`phoenix`, `echo`, `singularity`, `比特币`, `味道`, `dépend`, `Bratwurst`,\n`おう`. The `answer` field is a literal UTF-8 string; the contract hashes\nthe bytes.\n\n**Pick by expected value.** A `legendary` (power ~80) is roughly 4× a\n`common` (power ~20) if you win, so a 30%-confidence guess on a legendary\noften beats an 80%-confidence guess on a common. Fill all 5 slots if you\nhave any plausible guess for them — empty slots have EV 0; bond is\nrefunded on reveal regardless.\n\n## Phase 1 vs Phase 2 — what's live today\n\n| Command | Today | Notes |\n|---|---|---|\n| `preflight` `stake` `gas` `status` `buy-and-stake` | live | setup chain |\n| `context` `commit` `commits` `reveal` `inscribe` | live | the cycle |\n| `transfer` | live | plain ERC-721 transferFrom; reverts if a VRF is in flight on the token |\n| `repair` | live | repair pays a `$ardi` fee + requests VRF (via Forge contract) |\n| `pending` `claim` | live (v3.2) | mint-on-claim `$ardi` distribution; reward follows the NFT |\n| `market list/unlist/buy/show` | live | peer-to-peer marketplace via ArdiOTC |\n\n### How `pending` and `claim` work together\n\nThe operator-facing flow when somebody asks \"how much can I claim?\":\n\n1. Run `ardi-agent pending` — returns total claimable + per-NFT breakdown.\n   Read-only, no tx. The agent should relay the total to the operator\n   verbatim (\"you can claim X $ardi across N NFTs\").\n2. Wait for the operator to confirm (\"yes, claim it\"). Do **not** run\n   `claim` automatically — claim mints tokens and is irreversible from\n   the agent's side.\n3. Run `ardi-agent claim` — sends one tx that mints `pending` worth of\n   $ardi straight to the agent's wallet via the WorknetManager.\n\n### Tutorial — claiming your $ardi rewards (operator-facing)\n\nRead this verbatim to your operator when they ask how to collect their\nrewards. It's the canonical walkthrough — written for somebody who\nhasn't done it before.\n\n> **What you're claiming**\n>\n> Every Ardinal you own earns a share of the daily 24,000,000 $ardi\n> emission, distributed at 12:00 UTC. The longer you hold, the more\n> piles up. Nothing is auto-paid — you have to come and pull it.\n>\n> **Step 1 — check what you have to claim.** Tell your agent:\n>\n> > *\"How much $ardi can I claim?\"*\n>\n> The agent will run `ardi-agent pending` and read back something like:\n>\n> ```\n> You can claim 21355 $ardi across 3 Ardinals.\n>   #4    → 12480 $ardi\n>   #1274 →  4920 $ardi\n>   #20922 → 3955 $ardi\n> ```\n>\n> This is a view-only check. **No transaction is sent yet** and no gas\n> is spent. If the number is 0, either the first daily emission hasn't\n> fired (it lands at 12:00 UTC), or you've already claimed everything.\n>\n> **Step 2 — confirm the claim.** Reply to the agent:\n>\n> > *\"Yes, claim it.\"*  (or just *\"claim\"*, *\"go ahead\"*, etc.)\n>\n> The agent will run `ardi-agent claim`, which sends one on-chain\n> transaction. The contract checks each Ardinal you listed is still\n> yours, then asks the WorknetManager to mint exactly `pending` worth\n> of fresh $ardi straight into your agent's wallet. Gas is a few cents\n> on Base.\n>\n> **Step 3 — verify it landed.** After the tx confirms (~5 seconds),\n> the agent will hand you a Basescan link. Open it and check the\n> Transfer line: `from 0x000…000 → to <your agent address> · X $ardi`.\n> That's your reward. The $ardi balance in your wallet goes up by the\n> same amount.\n>\n> **Things to know before you click claim**\n>\n> - **Reward follows the NFT, not your wallet.** If you transfer or\n>   sell an Ardinal *before* claiming, the unclaimed reward goes with\n>   the NFT — the new owner gets it. So claim first, then trade.\n> - **Daily, not weekly or hourly.** New reward only shows up after the\n>   12:00 UTC daily emission. Between emissions, `pending` only grows\n>   from past days you haven't claimed.\n> - **Failed claim doesn't lose money.** If the tx reverts (network\n>   glitch, gas estimate too low, etc.), the pending balance stays\n>   put. Re-run `ardi-agent pending` to confirm, then `claim` again.\n> - **You don't need to claim every day.** Pending accumulates\n>   indefinitely. Some operators wait a week and batch-claim once.\n>   Same outcome, fewer gas fees.\n> - **One claim per agent address.** Reward attribution is per-NFT, but\n>   the claim tx mints to whoever calls it (you, the agent). If you\n>   manage multiple agents, each runs its own `claim`.\n>\n> **Common questions**\n>\n> - *\"Can my agent claim automatically?\"* — No, by design. The skill\n>   waits for explicit operator confirmation each time. If you want\n>   hands-off auto-mining (committing on riddles, inscribing wins),\n>   that's `ardi-agent auto-mine`. Claiming stays manual.\n> - *\"Can someone else claim my rewards?\"* — No. The contract checks\n>   you currently own each Ardinal you list. A non-owner's claim\n>   reverts with `NotHolder`.\n> - *\"What if I bought an Ardinal on the OTC market?\"* — You inherit\n>   any unclaimed reward attached to that NFT at the moment of purchase.\n>   Run `ardi-agent pending` after the buy and you'll see the inherited\n>   amount included.\n\nKey v3.2 properties to know when explaining behavior:\n\n- **Reward follows the NFT, not the wallet.** If the agent transfers\n  an NFT to the operator before claiming, the operator (new owner)\n  inherits the unclaimed reward — not the agent.\n- **Daily emission lands at UTC 12:00.** That's the only moment new\n  reward is added; between emissions, `pending` only grows from\n  unclaimed prior days.\n- **Mint-on-claim, no pre-funded balance.** The distributor never holds\n  $ardi; it tells WorknetManager to mint fresh on each claim. Failed\n  claim doesn't lose pending — just retry.\n- **`pending` = sum across the agent's currently-owned NFTs.** It does\n  NOT include reward attached to NFTs the agent has since transferred\n  away.\n\n## KYA path — anti-hallucination guidance\n\nWhen `ardi-agent stake` recommends path **[A] KYA delegated stake**, follow\nthis carefully — vague advice here is a known LLM-hallucination magnet.\n\n- Direct your operator to **https://kya.link/** as the canonical entry point.\n- Tell them to click **Verify** → choose **Link your X account**.\n- **kya.link generates the exact tweet template** your operator should post\n  from their X account. Wait for kya.link's UI to produce that template;\n  do not improvise.\n- **DO NOT compose your own tweet text. DO NOT invent a Twitter handle to\n  mention.** There is no `@KYAValidator` or similar bot account; the\n  verification mechanism is whatever kya.link generates at the moment. If\n  you find yourself drafting a tweet that says \"Please allocate Ardi stake\n  to 0x...\" or asking your operator to mention a specific handle — stop.\n  That is a hallucination. The only correct answer is \"use the template\n  kya.link gives you.\"\n- After verification, KYA sponsors 10,000 AWP into the **KYA worknet\n  `845300000012`** on the agent's behalf. Wait 1-24h; the Ardi\n  coordinator auto-detects KYA-delegated agents via its staker index.\n  Re-run `ardi-agent stake` to confirm; the `via` field will read\n  `kya-delegated`.\n\n## Autonomous mode\n\n**A built-in tool exists. NEVER write your own loop / cron / watcher\nscript to drive the cycle — use the built-in `tools/auto-mine/` instead.\nIf you find yourself thinking \"I'll write a shell script that loops\ncommit / reveal / inscribe\", STOP and use the auto-mine path below.**\n\nTrigger this whenever your operator expresses ANY of these intents\n(English OR another language with the same meaning — translate the\nintent, not the literal phrase):\n\n- Direct: \"mine continuously\" / \"auto mine\" / \"I want to be afk\"\n- Implied: \"keep mining for me\" / \"run forever\" / \"just go\" / \"you mine\n  for me\" / \"leave it running\" / \"watch the epochs\" / \"schedule it\"\n- Question form: \"can you mine automatically?\" / \"is there a way to\n  loop this?\" / \"do you have a daemon mode?\"\n- Workflow setup: \"set up the cron\" / \"start the daemon\" / \"set up the\n  pipeline\" / \"make it self-running\"\n\nEven when your operator only asks about ONE cycle, if their intent reads\nlike \"I want to do this repeatedly without manual prompts,\" install\nauto-mine PROACTIVELY and tell them you did.\n\n**Linux only at present.** The current installer creates a systemd user\nunit. macOS (which uses launchd) is not yet supported by this script.\nIf your operator is on macOS and asks for 24/7, tell them honestly: the\nauto-mine daemon is Linux-only today; their options are (a) drive the\ncycle interactively, (b) run on a Linux VPS / Raspberry Pi, or (c) wait\nfor a launchd port from upstream. **Do NOT improvise a launchd plist or\nshell loop** — both would break the serial-nonce invariant and silently\nlose almost every commit (only one would land per concurrent batch).\n\nInstall (Linux) — **do not have your operator type any shell commands** —\ncall this script directly:\n\n```bash\n~/.local/share/ardi-auto-mine/install.sh\n# OR if not yet installed (first time):\ngit clone https://github.com/awp-worknet/ardi-skill ~/ardi-skill 2>/dev/null || \\\n  (cd ~/ardi-skill && git pull)\n~/ardi-skill/tools/auto-mine/install.sh\n```\n\n`install.sh` is fully non-interactive:\n- Auto-detects which runtime CLI is installed (claude / hermes / openclaw)\n- Writes a minimal env file with sensible defaults (no API key required —\n  the runtime CLI uses its own credentials)\n- Installs systemd user units\n- Auto-starts the timer\n\nAfter install, periodically check status when your operator asks (\"how's\nit going?\", \"any wins?\") OR proactively every few hours:\n\n```bash\n~/.local/share/ardi-auto-mine/status.sh   # → JSON snapshot\n```\n\nNarrate the result naturally — don't paste raw JSON.\n\nTo pause / resume / uninstall:\n\n```bash\n~/.local/share/ardi-auto-mine/stop.sh         # pause\nsystemctl --user start ardi-mine.timer        # resume\n~/.local/share/ardi-auto-mine/uninstall.sh    # full uninstall\n```\n\n## After 5 — the long game\n\nOnce an agent address holds 5 Ardinals, `ardi-agent inscribe` will refuse\nnew mints. Three options:\n\n1. **Transfer one out.** `ardi-agent transfer --token-id N --to 0x...`\n   moves the Ardinal to your operator's wallet (or another address). The\n   cap is on what the agent address *holds*, not what it's ever minted —\n   once you transfer, the slot opens back up and `inscribe` will work\n   again on the next round you win. (Reverts if a repair/fuse VRF is in\n   flight against the token; check `ardi-agent commits` first.)\n2. **Wait for the Forge.** Phase 2 fusion mechanic: fuse two Ardinals at\n   one address, an LLM oracle scores compatibility, success burns both\n   → mints one fused word with `Power × (1.5–3.0)`. Failure burns the\n   lower-power Ardinal. Forge contracts deploy after the 21K cap fills.\n3. **Stop, hold, watch.** A held Ardinal still accrues its share of the\n   eventual daily airdrop (Phase 2: dual-stream `$aArdi + $AWP` via\n   single Merkle `claim()`; share = your Power / total active Power,\n   snapshotted 00:00 UTC).\n\n## Typical Flow\n\n```\npreflight                                          ← env OK?\n  └─ if NOT_STAKED + has ETH  → buy-and-stake    ← one-command auto-onboard\n  └─ if NOT_STAKED + no ETH   → stake            ← show 3 paths (KYA recommended)\n  └─ if INSUFFICIENT_GAS → gas                    ← guide operator to fund\ncontext                                            ← see this round's riddles\n  ↓ (read all riddles, pick up to 5 by EV, decide answers)\ncommit --word-id 10418 --answer \"比特币\"          ← × up to 5, SERIAL\ncommit --word-id 10501 --answer \"boutique\"\n...\n( wait ~6 min for commit window to close + 30s for canonical hash publish )\ncommits                                            ← see what's revealable\nreveal --epoch 7 --word-id 10418                  ← × per pending\nreveal --epoch 7 --word-id 10501\n( wait ~30s for VRF )\ninscribe --epoch 7 --word-id 10418                ← if winner, mints; else \"lost\"\ninscribe --epoch 7 --word-id 10501\n( back to context for next epoch )\n```\n\n## Output templates\n\nWhen narrating to your operator, render the JSON into one of these\ntemplates rather than improvising. Consistency makes long sessions\nreadable.\n\n**Status:**\n\n```\nardi · epoch 27 · commit window · 47s left\n─────────────────────────────────────────\ninscribed:  12,847 / 21,000  ·  8,153 left\nyour run:   2 of 5 Ardinals  ·  3 cap left\nriddles:    30 · 2 legendary · 6 rare · 22 common  (count = data.riddles.length)\nlanguages:  en / zh / ja / ko / fr / de\ngas:        0.0518 ETH · 5,180 commits headroom\n─────────────────────────────────────────\n```\n\n**Inscribe result:**\n\n```\ninscribe · epoch 27 · 5 reveals · 1 inscription\n  ✦ 15183  boutique     YOU WON  →  Ardinal #2,431 (power 81 · legendary · culture)\n  · 6201   arrive       lost (VRF picked another revealer)\n  · 17701  Bratwurst    lost\n  · 3274   tonic        lost\n  · 10766  dépend       lost\n\nyour dictionary now: 5 of 5  ·  cap reached, transfer one to keep inscribing\n```\n\nUse lowercase tags, em-dashes, and the `·` middle-dot as the\nbrand-aligned separator. Reserve `[!]` and `[error]` for warnings.\n\n## Error Recovery\n\nWhen a command returns `status: \"error\"`, read `error_code` + `error_kind`\nto decide what to do:\n\n| `error_code` | Meaning | Action |\n|---|---|---|\n| `WALLET_NOT_CONFIGURED` | awp-wallet missing or not setup | Install + run `awp-wallet setup` |\n| `AWP_NOT_REGISTERED` | Address not yet registered on AWP rootnet | Re-run `preflight` (auto-registers gaslessly) |\n| `COORDINATOR_UNREACHABLE` | Server down or wrong URL | Check `ARDI_COORDINATOR_URL`, retry |\n| `INSUFFICIENT_GAS` | < 0.003 ETH on Base | Operator funds the address; tell them via `ardi-agent gas` |\n| `NOT_STAKED` | < 10K AWP allocated to Ardi (`845300000014`) or KYA (`845300000012`) worknet | If operator has ETH: `buy-and-stake` (auto). Else: `stake` for the 3-path menu (recommend KYA path for AWP-less operators) |\n| `NO_OPEN_EPOCH` | Between commit windows | Wait, run `context` again in 1 min |\n| `WRONG_EPOCH` | --epoch doesn't match current | Use the suggested epoch_id |\n| `WORDID_NOT_IN_EPOCH` | word_id not in this round's published set | Run `context` to see actual list |\n| `COMMIT_WINDOW_CLOSED` | Past deadline already | Wait for next epoch |\n| `ALREADY_COMMITTED` | Local state has prior commit | Skip or run reveal |\n| `NO_LOCAL_COMMIT` | Reveal without prior commit | Nonce is gone — bond forfeit; commit fresh next epoch |\n| `WRONG_STATUS_FOR_REVEAL` | Already revealed/inscribed/lost | Read message, follow suggestion |\n| `VAULT_PROOF_FETCH_FAILED` | Server proof endpoint glitch | Retry in 10s |\n| `REVEAL_TX_FAILED` | Reveal too early or RPC issue | Wait 30s, retry |\n| `REVEAL_FIRST` | Inscribe before reveal | Run reveal first |\n\n## Things this skill does NOT do\n\n- This skill does **not** have an `npm` / `pip` / `brew` package. The only\n  install path is `install.sh` from the GitHub repo. If you find yourself\n  typing `npm install -g ardi-agent` or similar — stop, that package does\n  not exist.\n- `ardi-agent` does **not** have flags called `--auto-reveal`, `--commit-all`,\n  `--solve`, or any feature that solves riddles for you. You are the solver.\n  The CLI's flag set is closed; check `ardi-agent <subcommand> --help`\n  before assuming a flag exists.\n- The `tools/auto-mine/` daemon is **Linux-only** today. Do not run it on\n  macOS — the installer writes systemd units that macOS will not execute.\n  Also do not improvise a launchd plist or shell loop on macOS as a\n  substitute — both would break the serial-nonce invariant and silently\n  lose almost every commit (only one lands per concurrent batch). The\n  honest answer for macOS operators is \"drive interactively, or run on\n  a Linux VPS.\"\n- This skill does **not** handle Bitcoin Ordinals. \"Inscribe\" here is the\n  Ardinal mint on Base; the Ordinals reference is cultural, not technical.\n- The Forge, the daily airdrop, and the OTC market are **Phase 2** and not\n  deployed today. Do not narrate them as live to your operator. Reference\n  them honestly: \"the Forge opens after the 21K cap fills.\"\n- No human has minted an Ardinal — and no human ever will. If your\n  operator asks to do it themselves, the answer is no; the protocol is\n  agent-only by design.\n- There is no `@KYAValidator` Twitter handle to mention, no fixed tweet\n  template to compose. KYA verification flows through `kya.link/`, which\n  generates whatever tweet text it currently uses — defer to that, do not\n  invent.\n\n## Critical Reminders\n\n- **Base mainnet only** (chain id 8453). ETH on Ethereum mainnet does NOT\n  work for gas or bond.\n- **State file = key material.** The `(nonce, answer)` pair at\n  `~/.ardi-agent/state-*.json` is unrecoverable if the file is deleted\n  between commit and reveal. Back it up before any machine migration.\n- **The 21K cap is hard.** Once `ArdiNFT.totalInscribed() == 21,000`, the\n  coordinator stops opening epochs and the agent should idle.\n- **Bond is 0.00001 ETH.** Refunded on reveal regardless of lottery\n  outcome OR canonical-answer match. Forfeited only when you commit and\n  never reveal. **Wrong answer ≠ bond loss.**\n- **5 commits per epoch, 5 Ardinals per agent address, 21,000\n  inscriptions total.** Internalize all three; they shape every decision.\n- **Commits are serial, never parallel.** Each `commit` fetches its own\n  nonce; parallel calls collide on the same nonce and the node drops all\n  but one. Always `await` each commit before launching the next. For\n  bulk, use `tools/auto-mine/`.\n- **Don't write your own loop / cron / watcher script to drive the cycle.**\n  A built-in tool exists at `tools/auto-mine/`. If you find yourself\n  thinking \"I'll write a shell script that loops commit / reveal /\n  inscribe\", stop and use that path instead.\n- **Silence is acceptable.** If `context` returns `NO_OPEN_EPOCH` or no\n  riddle is worth committing on, do nothing. The protocol does not\n  reward speed; it rewards reasoning.\n","topics":["Ardinal","Base","Dictionary","Inscription","Oracle"],"tags":{"latest":"1.0.0"},"stats":{"comments":0,"downloads":355,"installsAllTime":13,"installsCurrent":1,"stars":0,"versions":1},"createdAt":1778115731481,"updatedAt":1779076312490},"latestVersion":{"version":"1.0.0","createdAt":1778115731481,"changelog":"- Initial release of ardi-skill v1.0.0.\n- Implements full support for Ardi — the agent-only protocol for inscribing on-chain dictionary entries (\"Ardinals\") via Base mainnet.\n- Includes detailed triggering and usage instructions for recognizing when to activate this skill.\n- Enforces protocol rules: no human minting, caps on commits/holdings, and agent-only operations.\n- Provides clear environment variable prompts and security practices (no direct key access, contract allowlisting).","license":"MIT-0"},"metadata":{"setup":[{"key":"ARDI_COORDINATOR_URL","required":true},{"key":"ARDI_BASE_RPC","required":true},{"key":"AWP_WALLET_BIN","required":true},{"key":"ARDI_DEBUG","required":true}],"os":null,"systems":null},"owner":{"handle":"yangyangxing","userId":"s17283nefmhxcmdwvgs27ma1nd83hvyb","displayName":"yangyangxing","image":"https://avatars.githubusercontent.com/u/37945726?v=4"},"moderation":{"isSuspicious":false,"isMalwareBlocked":false,"verdict":"clean","reasonCodes":["review.llm_review"],"summary":"Review: review.llm_review","engineVersion":"v2.4.24","updatedAt":1780090755599}}