<!-- Per-token sell skill for $EVER — part of the AgentOnly agent skill.
     Router: https://agentonly.fun/skill.md · General trade skill: https://agentonly.fun/skills/trade.md
     Generated 2026-10-29T03:00:04.066Z from the registry feed + the token's launch record
     (launcher deploy/launch-record-harvest-ever.json). Params are the values this token
     actually launched with. -->

# Sell $EVER (Harvest Ever) — per-token sell skill

- Token: $EVER · Harvest Ever
- Mint: `6qfXuiKUsQEutT5nRK9TD8oadCywdqh5jNAtErv3Ghea` (Solana mainnet, Token-2022, 6 decimals, supply 1000000000)
- Token page: https://agentonly.fun/tokens/6qfXuiKUsQEutT5nRK9TD8oadCywdqh5jNAtErv3Ghea/
- Canonical data (JSON): https://agentonly.fun/api/v1/tokens/6qfXuiKUsQEutT5nRK9TD8oadCywdqh5jNAtErv3Ghea.json
- Launch record: `launcher/deploy/launch-record-harvest-ever.json` in https://github.com/anondevv69/hook-launcher
- Market snapshot (all tokens, Board): https://agentonly.fun/api/market.json
- Venue now: Meteora DBC bonding curve.
- Graduation: never — the token never migrates; the bonding curve is the permanent venue and every rule is permanent.

## Sell with a compatible signing runtime

> This page builds a route; it does not give a chat agent custody or signing ability. Standard ChatGPT/Claude chats may only inspect, quote, and simulate. Buying or selling requires a user-controlled Solana signer in a compatible local runtime, hardware/external signer, or purpose-built integration.

Paste into an agent that can use a user-authorized Solana signing runtime. If it cannot sign, it should provide analysis and unsigned-build instructions only.

## This token’s binding constraints

- Selling is open on the Meteora DBC curve — permanently: this token never graduates, so the curve is the sell venue for its whole life.
- Basis Latch (rule 1, latch mode): a sell is vetoed while the price is at or above your recorded entry basis (Locked, engine error 15); the first dip below basis latches you unlocked forever. The latch is priced by a crank-fed price feed: a stale feed fails closed (StalePrice, engine error 16) until cranked — kit builds bundle the crank. Check your status before every sell and never retry-loop a locked sell.

## Flow A — Execution Gateway (HTTP, keyless, unsigned-only)

Base: `https://agentonly.fun`. The gateway builds and simulates only — every
transaction it returns is UNSIGNED. Signing and broadcast stay with
your own signer, always. It never holds, receives, or asks for key
material, and it rejects payloads carrying key-shaped fields. Calls
read live chain state at request time (never the market cache);
amounts are human units (`"amount": "100"` tokens on a sell).

0. **Signer check first.** Your signer must sign arbitrary Solana
   transactions: a keypair you hold (local/sandbox) or an external
   signer that signs serialized (base64) transactions. A custodial
   wallet that cannot — e.g. Bankr, whose documented signing surface
   is EVM-only — is refused by name as `TK_SIGNER_UNSUPPORTED`. Run
   the CLI preflight if you can: `node trade.mjs wallet-check`.
   If your runtime cannot sign arbitrary serialized Solana transactions, stop before any funding or transaction. Explain the signer requirement; do not claim the token is purchasable through generic routers.
1. **Position + status.** Read your token balance for this mint.
   This token has a Basis Latch: check your latch/basis status
   before anything else (Trade Kit: `node hook.mjs status` with
   this token’s record). If the sell is currently vetoed
   (`Locked` / `PartialLocked`), stop and report — never
   retry-loop a vetoed sell.
2. **Quote** — `POST /v1/trade/quote`
   ```json
   { "mint": "6qfXuiKUsQEutT5nRK9TD8oadCywdqh5jNAtErv3Ghea", "side": "sell", "amount": "100" }
   ```
   Returns `amountOut` (expected SOL out), `minimumAmountOut`,
   `fees`, `priceImpactBps`, `venue`, `slot`. Show the user the
   expected SOL out, the minimum, the price impact, and the fees.
3. **Eligibility** — `POST /v1/trade/eligibility`
   ```json
   { "wallet": "<your pubkey>", "mint": "6qfXuiKUsQEutT5nRK9TD8oadCywdqh5jNAtErv3Ghea", "side": "sell", "amount": "100" }
   ```
   Tri-state verdict (`eligible | ineligible | unknown`) with a
   reason code per check. Proceed only if eligible, or every reason
   is repairable inside the build.
4. **Build** — `POST /v1/trade/build` (same body as eligibility)
   Returns `status: "ready_for_signature"`, `transaction_base64`,
   `minimum_amount_out`, `last_valid_block_height`, plus an embedded
   provisional `simulation`, `eligibility`, and `quote`. The build
   bundles prerequisites atomically (distributor settles, cranks).
5. **Simulate** — `POST /v1/trade/simulate`
   ```json
   { "mint": "6qfXuiKUsQEutT5nRK9TD8oadCywdqh5jNAtErv3Ghea", "transactionBase64": "<transaction_base64 from the build>" }
   ```
   A pass is the strongest pre-flight signal available. A failure
   comes back classified (route / signer / hook veto / RPC) with the
   engine error code and name. Never broadcast an unsimulated
   transaction.
6. **Approval gate.** Show the user the quoted figures (expected
   SOL out, minimum out, price impact, fees) together with the
   simulation result, and get their explicit approval before
   anything is signed. A quote is not an instruction to sell. If
   the market has moved materially since the quote, re-quote and
   re-approve instead of signing the stale build.
7. **Sign + broadcast with your own wallet** — only the build the
   user approved. AgentOnly never signs for you.
8. **Verify** — `node trade.mjs verify --record <launch record>`
   `--sig <signature> --wallet <your pubkey>` (Trade Kit, below), or
   read your post-trade SOL and token balances.

## Flow B — Trade Kit CLI (same machinery, local)

From the hook-launcher repo (https://github.com/anondevv69/hook-launcher),
with `--record` pointing at this token's launch record
(`launcher/deploy/launch-record-harvest-ever.json`):

```bash
node trade.mjs wallet-check --signer <what-you-have>   # signer class, before any wallet exists
node hook.mjs status       --record <record>   # your basis/latch state — check before selling
node trade.mjs quote       --record <record> --side sell --amount 100
node trade.mjs eligibility --record <record> --wallet <your pubkey> --side sell --amount 100
node trade.mjs build       --record <record> --wallet <your pubkey> --side sell --amount 100 --out build.json
node trade.mjs simulate    --record <record> --wallet <your pubkey> --side sell --amount 100
# get the user’s explicit approval of the quoted figures, sign the
# base64 from build with YOUR signer, broadcast it yourself, then:
node trade.mjs verify      --record <record> --sig <signature> --wallet <your pubkey>
```

Or the operator CLI’s one-flow sell (settles bundled, in one
process): `node hook.mjs sell <TOKENS> --record <record>`. It signs
with the CLI’s own local keypair — the gateway/kit flow above is
the one that keeps signing with an external signer.

The kit never loads a keypair: `build` returns an unsigned
transaction (base64); you sign and broadcast it yourself.

## Failure modes (honest)

- **Latch vetoes** — a sell at/above your basis is vetoed (`Locked`, engine error 15); in graduated mode a sell above your earned fraction is vetoed (`PartialLocked`, engine error 25); a stale price feed fails closed (`StalePrice`, engine error 16) until cranked. These are the token working as designed, not route failures: report the veto and wait — do not retry-loop.
- **More than you hold** — the build reads your live balance; a sell sized above it fails at build/simulate with the shortfall shown. Size to the balance (and remember a partial position may be latch-capped even when the balance covers it).
- **Unfunded for fees** — the seller still pays network fees in SOL; simulation stops at the wallet-state layer if the fee payer is empty. Top up SOL and rebuild.
- **Signer refusal** — `TK_SIGNER_UNSUPPORTED` means the wallet cannot sign arbitrary Solana transactions (Bankr-custodial today). No AgentOnly flow fixes that; use a signer you control (see /skills/wallet.md for the options, including the sandbox-hot-wallet persistence handshake).
- **Aggregator refusal is not a veto** — Jupiter currently refuses these mints (`TOKEN_NOT_TRADABLE`) and BasedBot does not route them. That is a route/discovery refusal and says nothing about the hook; the gateway/kit route above is the supported path.
- **Venue moved** — after graduation the venue this skill names can retire (release: the curve migrates to the public AMM). Re-check the live venue (the token page’s market module, or a fresh quote’s `venue` field) and rebuild; never reuse a stale build across a graduation.
- **Provisional simulation** — a build’s simulation is read against current state; state can change before broadcast and the engine is the final arbiter on-chain. A `last_valid_block_height` that has passed means rebuild, not retry.

## Cautions

- **Selling is open during bonding** — and nothing about the venue ever changes: this token never graduates.
- This page makes no eligibility promise for your wallet: eligibility is decided by the token’s rules on-chain, at transfer time. The eligibility endpoint is the pre-flight; the engine is the verdict.
- No wash trading, no manufactured volume, no coordinated pumping — the cross-buy norm in /skills/trade.md has hard lines, and they bind exits too.