Skip to content

Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.

docs(growth-programs): document every flag, cap and owner arm step for the three disarmed trading programs

nirholasba8003f50235
diff --git a/STRUCTURE.md b/STRUCTURE.md
index d8805dbf6..cb9e4a853 100644
--- a/STRUCTURE.md
+++ b/STRUCTURE.md
@@ -248,6 +248,7 @@ bottom.
| Exit Lab (counterfactual exit replay) | kernel [api/_lib/exit-replay.js](api/_lib/exit-replay.js), corpus [api/sniper/exit-lab.js](api/sniper/exit-lab.js) `→ /api/sniper/exit-lab`, page [pages/exit-lab.html](pages/exit-lab.html) + [src/exit-lab.js](src/exit-lab.js) `→ /exit-lab` | Live | Replays every REAL closed sniper position through the live `decideLadderedExit` with the exit rules changed, so the fleet can ask "were our exits right?" about SOL it already spent. The kernel is pure and is imported by BOTH the handler and the browser, so a slider move is instant and server and client can never disagree. Two-phase walk over the recorded path (entry to peak to final quote) mirroring the live partial-sell bookkeeping leg for leg. States its own limits on the page: earlier exits are exact, longer holds are a lower bound, laddered positions are excluded with a stated reason. Grid search is an exact enumeration, flagged as in-sample. Tests: [tests/exit-replay.test.js](tests/exit-replay.test.js), [tests/exit-lab-page.test.js](tests/exit-lab-page.test.js). Docs: [docs/exit-lab.md](docs/exit-lab.md), tutorial [docs/tutorials/find-a-better-exit-policy.md](docs/tutorials/find-a-better-exit-policy.md) |
| Shareable trade card (per closed trade) | model [api/_lib/trade-card.js](api/_lib/trade-card.js), loader [api/_lib/trade-card-store.js](api/_lib/trade-card-store.js), image [api/trade-og.js](api/trade-og.js) `→ /api/trade-og?id=`, page [api/trade-share.js](api/trade-share.js) `→ /trade/<position id>`, share link on every closed row in [src/trader.js](src/trader.js) | Live | The trader-level card answers "is this trader any good?"; this one answers "what just happened?" and is the artifact worth posting the minute a position closes. One closed `agent_sniper_positions` row becomes an SVG 1200x630 card (coin, result with its return multiple, SOL in/out, hold time, exit reason) plus an SSR page carrying per-trade Open Graph / Twitter / Farcaster meta, both legs linked to Solscan, and a one-tap post. Image and page render from ONE pure model, so the picture that unfurls and the page it lands on can never disagree about a number. Honest by construction: a loss renders exactly like a win, a simulate-mode fill is stamped PAPER and never counted as live, and a moon-bag exit says the position was not fully sold. Unknown, still-open or deleted trades fall back rather than break an unfurl. Tests: [tests/trade-card.test.js](tests/trade-card.test.js) |
| Trade receipts ("why it traded") | model + loader [api/_lib/trade-receipt.js](api/_lib/trade-receipt.js), endpoint [api/sniper/receipt.js](api/sniper/receipt.js) `→ /api/sniper/receipt?id=`, shared renderer [src/shared/trade-receipt-view.js](src/shared/trade-receipt-view.js), drawer on [src/trader.js](src/trader.js) `→ /trader/:id?trade=<id>`, section on [api/trade-share.js](api/trade-share.js) `→ /trade/:id`, MCP tool `trade_receipt` in [api/_mcp/tools/trader.js](api/_mcp/tools/trader.js), tests [tests/trade-receipt.test.js](tests/trade-receipt.test.js) | Live (read-only) | Why an agent took one trade, from the rows its gates actually wrote: entry trigger, Oracle score and pillars at entry with the base-rate reasons behind it, the trade firewall verdict and checks (the simulated buy/sell round-trip included), the LLM judge thesis, the Risk Officer review, paid x402 sentiment and rug-pull reads with their payment tx, launch intel, and every journal leg with its signature. Each block is timed against the entry; evidence logged after the exit is dropped and evidence seen while holding is labeled as such, so a receipt never passes hindsight off as a reason. Same visibility gate as `/api/sniper/trader`. Doc: [docs/trade-receipts.md](docs/trade-receipts.md). |
+| Trading growth programs (big-win X poster, first-rug softener, early-leader bonus) | engine [api/_lib/growth-programs/](api/_lib/growth-programs) (flags + caps [config.js](api/_lib/growth-programs/config.js), [big-win-x.js](api/_lib/growth-programs/big-win-x.js), [rug-softener.js](api/_lib/growth-programs/rug-softener.js), [early-leaders.js](api/_lib/growth-programs/early-leaders.js), capped payout leg [payouts.js](api/_lib/growth-programs/payouts.js)), crons [api/cron/big-win-x.js](api/cron/big-win-x.js) + [api/cron/growth-payouts.js](api/cron/growth-payouts.js), ops board [api/ops/growth-programs.js](api/ops/growth-programs.js) `→ /api/ops/growth-programs`, claim API [api/sniper/rug-softener.js](api/sniper/rug-softener.js) `→ /api/sniper/rug-softener`, claim banner [src/dashboard-next/rug-softener-banner.js](src/dashboard-next/rug-softener-banner.js) on `/dashboard/sniper`, ledger migration [api/_lib/migrations/20260929120000_growth_program_payouts.sql](api/_lib/migrations/20260929120000_growth_program_payouts.sql), report [scripts/growth-programs-report.mjs](scripts/growth-programs-report.mjs) | Built, disarmed | Roadmap 917 items 3.8, 12.15 and 13.4. Posts notable live wins to @trythreews (never naming the traded coin, linking the `/trade/:id` card, filtered like the changelog X lane), pays $THREE toward a first-timer's first verified rug, and pays a bounded $THREE bonus to the first leaders with a verified, followed record. The selection logic runs on live data and is inspectable at any time; posting and paying only run when `BIG_WIN_X_ENABLED`, `RUG_SOFTENER_ENABLED` or `EARLY_LEADER_ENABLED` is set, under rolling caps with code ceilings, from the Arena prize wallet (`THREE_PRIZE_PAYOUT_KEY`) via a Token-2022-aware transfer. Docs + owner arm steps: [docs/growth-programs.md](docs/growth-programs.md). Tests: [tests/growth-programs.test.js](tests/growth-programs.test.js) |
| Never sell 100% of a winner (moon-bag policy) | rule [workers/agent-sniper/exit-logic.js](workers/agent-sniper/exit-logic.js) (`moonbagExitFraction`, `moonbagAlways`), retained-bag booking [workers/agent-sniper/executor.js](workers/agent-sniper/executor.js), position fields [api/_lib/migrations/20260725100000_sniper_moonbag_always.sql](api/_lib/migrations/20260725100000_sniper_moonbag_always.sql), board [api/sniper/experiments.js](api/sniper/experiments.js) + [src/sniper-experiments.js](src/sniper-experiments.js) `→ /sniper/experiments` | Live | Fleet-wide owner rule: a terminal exit that is IN PROFIT sells down to the moon-bag floor (default 15%) instead of to zero, and the retained tokens ride indefinitely. Once the cost basis is back the remainder is free, so a bag that goes to zero costs nothing and a bag that runs is the whole upside; selling the last slice for a rounding error gives that up. Applies with or without the proactive 2x ladder. A loss exit with the stake still at risk is still a FULL exit and the hard stop-loss is never overridden. The position still books `closed`, so realized P&L and the `max_concurrent_positions` slot are unaffected and a held bag can never stop an arm trading; only the tokens stay behind (`moonbag_base_amount`). Per-strategy opt-out `moonbag_always = false`. Tests: [tests/sniper-laddered-exit.test.js](tests/sniper-laddered-exit.test.js), [tests/trading-experiment-e2e.test.js](tests/trading-experiment-e2e.test.js). See [docs/trading-experiment.md](docs/trading-experiment.md) |
| Autonomous Trading hub (front door) | [pages/trading.html](pages/trading.html) `→ /trading` + [src/trading-hub.js](src/trading-hub.js), pure formatters [src/trading-hub-format.js](src/trading-hub-format.js), surface + doc directory [src/trading-hub-data.js](src/trading-hub-data.js), styles [src/trading-hub.css](src/trading-hub.css) | Live | One entry point for a trading system that had grown to ~20 pages with no front door. Live fleet vitals from `GET /api/sniper/status` (mode, armed strategies, open positions, feed health, funding, uptime), the agent scoreboard from `GET /api/sniper/leaderboard` (realized P&L only, closed trades only, with cumulative sparkline), the five-gate entry-to-exit explainer, and directories of every trading surface and doc. Feed health is reported separately from process health because a beating worker with a silent feed reads as green while seeing nothing. Directory is data, so [tests/trading-hub.test.js](tests/trading-hub.test.js) asserts every link resolves against `data/pages.json` and the docs tree. Docs: [docs/trading-hub.md](docs/trading-hub.md), tutorial [docs/tutorials/read-the-trading-fleet.md](docs/tutorials/read-the-trading-fleet.md) |
| Sniper Experiments (rules vs LLM A/B fleet) | [pages/sniper-experiments.html](pages/sniper-experiments.html) + [src/sniper-experiments.js](src/sniper-experiments.js) `→ /sniper/experiments`, aggregate [api/sniper/experiments.js](api/sniper/experiments.js), LLM judge [workers/agent-sniper/llm-judge.js](workers/agent-sniper/llm-judge.js), fleet seeding [scripts/seed-sniper-experiments.mjs](scripts/seed-sniper-experiments.mjs) | Live | The sniper fleet runs labeled rule-set variants side by side (strict shields, oracle-gated, and `decision_mode=llm` arms judged per-launch by Grok / Claude / OpenRouter auto with no shields), all behind the same safety rails. The page is the live scoreboard of which entry conditions actually make money; real on-chain fills only. |
diff --git a/docs/growth-programs.md b/docs/growth-programs.md
new file mode 100644
index 000000000..cd723259d
--- /dev/null
+++ b/docs/growth-programs.md
@@ -0,0 +1,228 @@
+# Trading growth programs
+
+Three levers from the pump.fun trading roadmap that reach outside the platform:
+
+| Program | What it does | Roadmap item | Why it is gated |
+|---|---|---|---|
+| **Big-win X poster** | Posts a notable live agent win to @trythreews with a link to its trade card | 3.8, 13.5 | Posts to an external channel |
+| **First-rug softener** | Pays back part of a first-timer's first rug, in $THREE | 12.15 | Sends $THREE |
+| **Early-leader program** | Pays a bounded $THREE bonus to the first traders who build a verified record | 13.4 | Sends $THREE |
+
+**All three ship disarmed.** The selection logic runs on live data all the time, and you can see exactly what each one would do right now. The step that posts or pays only runs when the owner sets that program's flag, and even then it stays under a hard cap per period. This page explains each program, how to inspect it, and the exact steps to arm it.
+
+Code: [`api/_lib/growth-programs/`](../api/_lib/growth-programs/). Tests: [`tests/growth-programs.test.js`](../tests/growth-programs.test.js).
+
+---
+
+## See what they would do today
+
+Three ways, all read-only. None of them posts, writes a ledger row, or signs anything.
+
+```bash
+# From a checkout with .env.local (DATABASE_URL): a readable summary
+node --env-file=.env.local scripts/growth-programs-report.mjs
+
+# The full report as JSON
+node --env-file=.env.local scripts/growth-programs-report.mjs --json
+
+# Against production (admin session or the ops secret)
+curl -s -H "x-ops-secret: $OPS_SECRET" https://three.ws/api/ops/growth-programs | jq .
+```
+
+The report lists:
+
+- **Big-win X:** every live close of +50% or more in the window, the reason each one was or was not picked, the exact text of the post it would send, and the post budget across every automated lane on the account.
+- **First-rug softener:** every account with a live trade, whether its first trade qualifies, the dollar amount, and each criterion it failed in plain words.
+- **Early leaders:** every agent with a live record, its stats, the criteria it still misses, open slots, and who would be enrolled.
+- **Ledger:** payout rows by program and status (empty until a payout program is armed).
+
+The crons return the same dry run in their response body, so the Cloud Scheduler run history shows it too.
+
+---
+
+## Big-win X poster
+
+When a live agent trade closes as a meaningful win, the poster sends one post to @trythreews linking to the trade card at `https://three.ws/trade/<position id>`. The card page ([`api/trade-share.js`](../api/trade-share.js)) and its unfurl image ([`api/trade-og.js`](../api/trade-og.js)) render from the same on-chain row, so the numbers in the timeline are the numbers on the page, and every leg links to Solscan.
+
+An example of the exact text, composed from a real closed trade (the size gate would hold this one back, since it was a 0.001 SOL fill):
+
+```text
+Crosshair closed a live pump.fun trade at +224% (3.2x) in 5m: 0.001 SOL in, 0.002 SOL out. A moon-bag is still riding. Both legs link to their on-chain transactions on the card.
+
+https://three.ws/trade/a45efe3a-fdcf-4baa-9471-a6dd2e6c7cc3
+```
+
+**What qualifies**
+
+- A live fill: both the buy and the sell carry real on-chain signatures. Paper fills are never posted.
+- At least `BIG_WIN_X_MIN_PCT` return, `BIG_WIN_X_MIN_ENTRY_SOL` in, and `BIG_WIN_X_MIN_PNL_SOL` realized, closed in the last `BIG_WIN_X_LOOKBACK_HOURS`.
+- A public agent, not closed on an error, and not a trade on a coin the owner launched (the self-dealing rule the Trader Card uses).
+
+**What the post will never say**
+
+- **It never names the traded coin.** $THREE is the only coin the account promotes, so the post has no ticker, no cashtag and no mint address. The card carries the detail for anyone who clicks.
+- The text must pass the same filter as the changelog lane on X ([`data/changelog-x-filter.json`](../data/changelog-x-filter.json): no wallet or money-movement internals, no other coins, no gated project names) and the account's voice lint ([`api/_lib/x-content/quality.js`](../api/_lib/x-content/quality.js): no hashtags, emoji, dashes or hype). A post that fails either is held back with the reason.
+- The agent's name is set by its owner, so a name containing a cashtag, an @handle, a hashtag or a link disqualifies the post instead of being printed.
+
+**Rate:** one post per run, at most `BIG_WIN_X_DAILY_CAP` in 24 hours, one per agent per `BIG_WIN_X_PER_AGENT_HOURS`, and never once the account has made `BIG_WIN_X_ACCOUNT_DAILY_CAP` automated posts in 24 hours across every lane (changelog replies and the content queue count too). A rate limit from X backs the lane off until X's own reset time.
+
+Cron: `/api/cron/big-win-x` at minutes 11 and 41 of every hour. State lives in `app_settings` under `big_win_x`.
+
+---
+
+## First-rug softener
+
+An optional $THREE pool that pays back part of a first-timer's first rug. It is a welcome guarantee for someone new: the first time you trade and the coin turns out to be a rug, you get some of it back.
+
+**Who qualifies.** Every criterion comes from real records, never from what the claimant says:
+
+| Criterion | Rule |
+|---|---|
+| First trade | The claim is against the account's first-ever live trade (a real on-chain buy by one of its agents), with no earlier copy trade. Paper fills never count. |
+| Real loss | It closed at a realized loss of at least `RUG_SOFTENER_MIN_LOSS_SOL`, with at least `RUG_SOFTENER_MIN_ENTRY_SOL` in. |
+| Verified rug | The coin has a "rugged" verdict from the Coin Intelligence labeler (`pump_coin_outcomes`, or its long-lived copy `oracle_training_set`). A coin that just went down is a bad trade, not a rug. |
+| Not the rugger | The coin's creator is known and is none of the claimant's wallets; the coin was not launched from the claimant's account; none of the claimant's wallets sold the coin at a profit; the trading wallet was not funded by the creator. |
+| One person | The trading wallet belongs to exactly one account; the account is at least `RUG_SOFTENER_MIN_ACCOUNT_AGE_HOURS` old and is not a platform account; one claim per account and one per receiving wallet, ever (enforced by unique indexes in the database). |
+| Fresh | Claims open for `RUG_SOFTENER_CLAIM_WINDOW_DAYS` after the trade closed. The evidence is saved into the claim when it is made, so a later payout never depends on data that has since aged out. |
+
+**How much.** `RUG_SOFTENER_REIMBURSE_PCT` of the SOL lost, valued in USD when the claim is made, capped at `RUG_SOFTENER_MAX_PER_CLAIM_USD`. It is paid in $THREE at the live price when it goes out. Example with the defaults: a 0.15 SOL loss at $120 per SOL pays 50% of $18, which is $9.00 in $THREE.
+
+**The claim flow.** When the program is armed, an eligible account sees a banner at the top of the Sniper dashboard (`/dashboard/sniper`) with a Claim button. The API behind it:
+
+```bash
+# Eligibility for the signed-in account: every criterion, the amount, any claim on file
+curl -s -b cookies.txt https://three.ws/api/sniper/rug-softener
+
+# Record the claim (403 program_not_open until the owner arms the program)
+curl -s -b cookies.txt -X POST -H "x-csrf-token: $CSRF" https://three.ws/api/sniper/rug-softener
+```
+
+While the program is disarmed, the banner never renders and `POST` answers `403 program_not_open`. `GET` always answers, so an account can see where it stands.
+
+---
+
+## Early-leader program
+
+A bounded $THREE bonus for the first `EARLY_LEADER_SLOTS` traders whose record clears every bar below. It creates a supply of credible leaders to copy before organic copy demand exists.
+
+| Criterion | Default |
+|---|---|
+| Live closed trades on mainnet | at least 30 |
+| History from first to latest close | at least 30 days |
+| Win rate | at least 55% |
+| Capital deployed | at least 1 SOL |
+| Realized P&L | above zero |
+| Max drawdown (share of capital deployed) | at most 50% |
+| Copyable | clears the copy-trading bar in [`copy-eligibility.js`](../api/_lib/copy-eligibility.js) |
+| Followers | at least 1 copier (never the leader's own account) with closed copies, whose net copy profit is zero or better, measured the way [copy trading](./copy-trading.md) bills performance fees |
+| Eligibility | public agent, has a Solana wallet to pay, not owned by a platform account |
+
+P&L on a coin the trader launched is left out of the record, as on the Trader Card. "First" means by qualification time: the close at which the record first cleared every trading bar. Each owner account can hold one slot, and a slot once taken is kept. The bonus, `EARLY_LEADER_BONUS_USD`, is paid in $THREE at the live price to the agent's Solana wallet.
+
+---
+
+## Flags and caps
+
+Flags arm on exactly `1` or `true`. Anything else, including unset, `yes` or a typo, is off. Every number has a ceiling in code ([`config.js`](../api/_lib/growth-programs/config.js)): the environment can lower a cap but never raise it past the ceiling, so raising one is a reviewed code change.
+
+| Variable | Default | Ceiling | Meaning |
+|---|---|---|---|
+| `BIG_WIN_X_ENABLED` | off | | Arms posting |
+| `BIG_WIN_X_MIN_PCT` | 100 | | Minimum return, in % |
+| `BIG_WIN_X_MIN_ENTRY_SOL` | 0.1 | | Minimum SOL in |
+| `BIG_WIN_X_MIN_PNL_SOL` | 0.1 | | Minimum SOL realized |
+| `BIG_WIN_X_LOOKBACK_HOURS` | 24 | 72 | How far back a close may be |
+| `BIG_WIN_X_DAILY_CAP` | 2 | 4 | Posts from this lane per 24h |
+| `BIG_WIN_X_PER_AGENT_HOURS` | 24 | 720 | Cooldown per agent |
+| `BIG_WIN_X_ACCOUNT_DAILY_CAP` | 15 | 15 | Automated posts per 24h across all lanes |
+| `RUG_SOFTENER_ENABLED` | off | | Arms claims and payouts |
+| `RUG_SOFTENER_REIMBURSE_PCT` | 50 | 50 | Share of the loss paid back |
+| `RUG_SOFTENER_MAX_PER_CLAIM_USD` | 25 | 100 | Cap per claim |
+| `RUG_SOFTENER_DAILY_CAP_USD` | 100 | 500 | Rolling 24h cap on everything paid |
+| `RUG_SOFTENER_MIN_LOSS_SOL` | 0.02 | | Minimum realized loss |
+| `RUG_SOFTENER_MIN_ENTRY_SOL` | 0.05 | | Minimum SOL in |
+| `RUG_SOFTENER_CLAIM_WINDOW_DAYS` | 14 | 30 | Days after the close a claim stays open |
+| `RUG_SOFTENER_MIN_ACCOUNT_AGE_HOURS` | 24 | | Minimum account age at claim time |
+| `EARLY_LEADER_ENABLED` | off | | Arms enrollment and payouts |
+| `EARLY_LEADER_SLOTS` | 20 | 50 | Total leaders the program ever pays |
+| `EARLY_LEADER_BONUS_USD` | 50 | 250 | Bonus per leader |
+| `EARLY_LEADER_WEEKLY_CAP_USD` | 250 | 1000 | Rolling 7-day cap on everything paid |
+| `EARLY_LEADER_MIN_SETTLED`, `_MIN_SPAN_DAYS`, `_MIN_WIN_RATE_PCT`, `_MIN_DEPLOYED_SOL`, `_MAX_DRAWDOWN_PCT`, `_MIN_FOLLOWERS` | 30, 30, 55, 1, 50, 1 | | The qualification bar above |
+
+With the defaults, the most the two payout programs can ever send is $100 a day (softener) and $1,000 in total across 20 slots at no more than $250 a week (early leaders).
+
+---
+
+## How a payout is sent
+
+Both payout programs write committed payouts to one ledger table, `growth_program_payouts` (migration [`20260929120000_growth_program_payouts.sql`](../api/_lib/migrations/20260929120000_growth_program_payouts.sql)). `/api/cron/growth-payouts` runs at minute 23 of every hour. For each program it refuses to send unless all of these hold:
+
+1. The program's flag is set.
+2. The dedicated payout key is configured: `THREE_PRIZE_PAYOUT_KEY`, the same funded $THREE wallet the [Arena](./trading-arenas.md) pays tournament prizes from, so there is one payout wallet to watch. The Arena's fallback to the club treasury secret is deliberately not used here: on production that secret is the economy master (funding root) wallet, which these programs must never spend. As of 2026-09-29, `THREE_PRIZE_PAYOUT_KEY` is not set on production, so an armed payout program reports `payout_unconfigured` and sends nothing until it is.
+3. The recipient is a valid Solana address and not a platform wallet (the treasury, the rewards pool, or the payout wallet itself).
+4. The payout fits under the program's rolling cap, summed over everything already sending or sent in the period. The queue is first-come-first-served: a payout that does not fit waits for the window to roll, and a smaller one behind it does not jump ahead.
+5. A live $THREE price is available. A payout never goes out at a guessed price.
+
+Each row moves to `sending` in a single compare-and-set before the transfer, so two overlapping runs can never pay it twice. The transfer is a Token-2022-aware `TransferChecked` ([`transferSplTokenChecked`](../api/_lib/solana-transfer.js)), sent through the platform's protected send path. A row that is left in `sending` after a crash is never retried automatically: reconcile it by hand against the chain.
+
+Row statuses: `claimed` (queued), `sending`, `sent` (with `tx_signature`), `failed` (retried next run), `blocked` (a guard refused it; `note` says why).
+
+---
+
+## Owner steps to arm
+
+Each program is armed on its own. Do not arm anything until you have read today's dry run.
+
+**Before either payout program**
+
+1. Apply the ledger migration: `npm run db:status`, confirm `20260929120000_growth_program_payouts.sql` is the pending one you expect, then `npm run db:migrate`.
+2. Set `THREE_PRIZE_PAYOUT_KEY` on the Cloud Run service (it is unset as of 2026-09-29) to a dedicated wallet holding enough $THREE, plus a little SOL for fees and new token accounts, to cover the caps. Store it in Secret Manager like the other keys, and check it with `node scripts/read-service-env.mjs '^THREE_PRIZE_PAYOUT_KEY$' --names`.
+3. Deploy the commit that ships this code, following the deploy runbook in `CLAUDE.md`, so both crons exist and Cloud Scheduler has synced them.
+4. Read the dry run: `curl -s -H "x-ops-secret: $OPS_SECRET" https://three.ws/api/ops/growth-programs | jq .`
+
+**Arm the first-rug softener**
+
+```bash
+gcloud run services update three-ws-api --region us-central1 --project aerial-vehicle-466722-p5 \
+ --update-env-vars RUG_SOFTENER_ENABLED=1
+```
+
+Eligible accounts then see the claim banner on `/dashboard/sniper`, and claims are paid on the next hourly run.
+
+**Arm the early-leader program**
+
+```bash
+gcloud run services update three-ws-api --region us-central1 --project aerial-vehicle-466722-p5 \
+ --update-env-vars EARLY_LEADER_ENABLED=1
+```
+
+The next hourly run enrolls whoever the dry run listed under `would_enroll` and pays them within the weekly cap.
+
+**Arm the big-win X poster**
+
+The X credentials (`X_API_KEY`, `X_API_SECRET`, `X_ACCESS_TOKEN`, `X_ACCESS_SECRET`) are already on the service for the changelog lane. Read the `would_post` text in the dry run, then:
+
+```bash
+gcloud run services update three-ws-api --region us-central1 --project aerial-vehicle-466722-p5 \
+ --update-env-vars BIG_WIN_X_ENABLED=1
+```
+
+Always use `--update-env-vars`, never `--set-env-vars`, which replaces the whole environment. To tune a threshold or cap, pass it the same way (for example `--update-env-vars RUG_SOFTENER_DAILY_CAP_USD=50`).
+
+**Disarm** any program at once by removing its flag:
+
+```bash
+gcloud run services update three-ws-api --region us-central1 --project aerial-vehicle-466722-p5 \
+ --remove-env-vars RUG_SOFTENER_ENABLED
+```
+
+Payouts already queued stay in the ledger as `claimed` and are paid only if the program is armed again.
+
+---
+
+## Related
+
+- [Copy trading](./copy-trading.md): the follower economy the early-leader bonus seeds.
+- [The Oracle model](./oracle-model.md): the Coin Intelligence labels, including the rug verdict, that the softener reads.
+- [The X content pipeline](./x-content-pipeline.md): the reviewed posts that share the account's daily budget with this lane.
+- [`STRUCTURE.md`](../STRUCTURE.md): where every surface lives.
diff --git a/docs/start-here.md b/docs/start-here.md
index d49a409c8..864dac8f2 100644
--- a/docs/start-here.md
+++ b/docs/start-here.md
@@ -148,6 +148,7 @@ Want the model in your hands rather than on a screen? [Materialize](./materializ
- **Want to know why a trader bought before you copy it?** → [Trade receipts](./trade-receipts.md): press **why** on any closed trade on a track record to see the evidence the agent had at decision time (the entry trigger, the Oracle score and its base-rate reasons, the on-chain firewall simulation, the LLM judge, the Risk Officer, paid x402 reads with their payment tx) and every leg on Solscan. Evidence logged after the exit is left out
- **Not ready to risk money on a trader yet?** → [Ghost-copy](./ghost-copy.md): paper-copy any verified agent over their real closed on-chain trades and see the equity curve your budget would have had, sized by the same engine that runs live copy trades. No wallet, no signature, no account, and every trade your budget could not reach is listed with the reason
- **Have an audience of your own?** → [The trader card](./trader-card-embed.md): one script tag puts a trader's live on-chain record on your site, blog, link in bio or stream overlay, with a Fork button on every coin and a ghost-copy call to action, all signed by the reader's own wallet. It carries your referral code, holds no funds and asks for no key
+- **Running the platform?** → [Trading growth programs](./growth-programs.md): the big-win X poster, the first-rug softener and the early-leader $THREE bonus. All three ship disarmed; the page shows how to read what each would do today, every flag and cap, and the exact steps to arm one
- **Running a chart page, a launchpad or a wallet?** → [Token in 3D, as an embed](./coin3d-embed.md): one iframe puts a live 3D view of any Solana market on your page, keyed by the mint or by the pair address your own URL already carries, with the coin's logo on a medallion, its holders as a galaxy sized by balance, a graduation ring and real swaps arriving on a tape. Free, keyless, no account, and it degrades to a data view where WebGL is unavailable
- **Want to know what just changed on the board?** → [Rivalries](./rivalries.md): every trader on the arena leaderboard is paired with the one directly above them and labelled an overtake, a debut or a standing chase, with the profit both sides settled in the last 24 hours as the reason. Worked out by rebuilding what the board said at the cutoff from the trade timestamps, so it reaches back over history already recorded and never disagrees with the leaderboard
- **Watching identities land on-chain?** → [On-chain deployments](./deployments.md): the live feed of agent identities registering on-chain as it happens, Solana Metaplex Core mints alongside ERC-8004 registrations across 15 EVM chains, with chain footprint and capability stats
diff --git a/prompts/finish/_context/production-100-OWNER-ACTIONS.md b/prompts/finish/_context/production-100-OWNER-ACTIONS.md
index 1ac962436..55953eb59 100644
--- a/prompts/finish/_context/production-100-OWNER-ACTIONS.md
+++ b/prompts/finish/_context/production-100-OWNER-ACTIONS.md
@@ -33,6 +33,7 @@ on it; some resolve themselves as other work lands.
| 19 | Deploy the `agent-sniper` worker, then decide separately whether to arm the Risk Officer. Measured 2026-09-09 against Cloud Run and mainnet: the service runs revision `agent-sniper-00033-rg6`, whose image was built **2026-08-11**, while it trades `SNIPER_MODE=live` right now (heartbeat 6s old, 11 strategies, 3,482 positions, one opened 05:10 UTC that morning; re-measured 19:34 UTC the same day: 27 strategies with 13 enabled, 3,511 positions, 41 of them opened in the previous 24 hours and the last at 19:02 UTC). **48 files and about 11,000 lines under `workers/agent-sniper/` are committed and not in that image**, including `amm-exit.js`, which is the roadmap's own named blocker: `executor.js`, `positions.js` and `graduation-ride.js` import it at HEAD, so the running image has no code path that exits a position after its coin graduates. The Risk Officer (`risk-officer.js`, migration already applied in production) has therefore never run in production either: `sniper_risk_reviews` holds 7 rows, all from the 2026-09-04 local verification, and the shadow-evidence query in `workers/agent-sniper/README.md` runs green against the live schema and returns zero rows. **Re-verify this from the database, not from `gcloud`:** the Codespace loses its gcloud login on every recycle, so `gcloud run services describe agent-sniper` is usually unavailable and its failure says nothing about the fleet. A shadow review is recorded fire-and-forget on every buy, so fleet buys with no matching review rows can only mean the running image predates `risk-officer.js`; 41 buys against 0 fleet review rows is that proof, and those counts turning non-zero is how you confirm the deploy took. The deploy is one command, `npm run deploy:sniper`, dry-run clean on 2026-09-09 (gcloud authed, runtime SA and Artifact Registry repo present, both required secrets present); on an existing service it rolls `gcloud run services update --image`, which preserves the running env, so it does **not** demote the fleet to simulate. Only the optional `telegram-alerts-chat-id` secret is missing, which disables Telegram ops alerting. Arming enforcement is a **separate, later** yes: `SNIPER_RISK_OFFICER=enforce` fleet-wide (via `--update-env-vars`, never `--set-env-vars`) or per strategy via `risk_officer_level`, and it should wait until shadow rows exist to justify it. | one yes now, one decision later | The trading Arena copy-trade loop (graduated-position exits), and all shadow evidence for the Risk Officer | [../918-roadmap-pumpfun-trading-arena.md](../918-roadmap-pumpfun-trading-arena.md), [workers/agent-sniper/README.md](../../workers/agent-sniper/README.md) |
| 20 | **Clear the GCP billing hold on `aerial-vehicle-466722-p5`.** Every Vertex surface answers `403 Lightning dunning decision is deny for project: projects/93741856042`, confirmed 2026-09-09 both locally and in production's own logs (Vertex Imagen falling back at 05:33 UTC). This is not IAM and nothing in code routes around it: it takes out the Vertex Gemini anchor, Imagen, and `groundedSearch`, which is the fact-checker's ONLY working search rung (no Brave/Tavily/Exa/Serper key exists). With it down the chain falls to Wikipedia alone: a benchmark run that day saw 190 sources, 100% Wikipedia, and 15 of 38 claims had zero stance-bearing evidence. It is a billing/payment state on the account, so only the owner can clear it. | minutes, at the billing console | Grounded search, Vertex Gemini, Imagen, and publishing the fact-check accuracy run (04b) | [PROGRESS.md](production-100-PROGRESS.md), 2026-09-09 entry | **Re-confirmed 2026-09-10, and the blast radius is wider than this row said.** The denial covers the Generative Language API (`generativelanguage.googleapis.com`, the `GOOGLE_API_KEY` path) as well as Vertex, so there is no Google lane of any kind. It is also the real blocker behind **order 311's i18n translation**: that order names `gcloud auth login` as its owner action, but gcloud auth WORKS in this workspace, and the actual constraint is that every reachable free lane is throttled per key (NVIDIA about 27 keys/min per process and `429`s under parallelism, Groq capped at 200k tokens/day, OpenAI `billing_not_active`). Vertex is the only lane billed to the credit pool with no free-tier quota, so it is the only one that finishes 84 locales in one pass. Clearing this hold therefore unblocks **three** orders at once: 903, 907 and 311.
| 21 | **Decide whether to rotate the lane credentials read on 2026-09-09.** Resolving the LLM chain for the fact-check benchmark printed secret material into an agent session transcript: the `vercel-inference@aerial-vehicle-466722-p5` service-account **private key** (`GCP_SERVICE_ACCOUNT_JSON`, key id `93be907a...`), plus `GROQ_API_KEY`, all five OpenRouter keys, `NVIDIA_API_KEY` and `OPENAI_API_KEY`. `INTERNAL_API_KEY` was used but never printed. Nothing indicates misuse and all of them remain valid; the exposure surface is whoever can read that transcript. Rotate or accept, and note that the OpenAI key is dead anyway (row 6) and OpenRouter key #1 is already revoked. | decision (+ minutes if rotating) | Closing out the exposure | [PROGRESS.md](production-100-PROGRESS.md), 2026-09-09 entry |
+| 22 | **Decide whether to arm the three trading growth programs** (added 2026-09-29). Built, tested and disarmed: the big-win X poster (`BIG_WIN_X_ENABLED`, posts to @trythreews), the first-rug softener (`RUG_SOFTENER_ENABLED`, pays $THREE, default cap $25 per claim and $100 per day) and the early-leader bonus (`EARLY_LEADER_ENABLED`, pays $THREE, default 20 slots at $50 and $250 per week). Each is armed on its own. Steps: (1) `npm run db:status`, then `npm run db:migrate` for `20260929120000_growth_program_payouts.sql` (payout programs only); (2) set `THREE_PRIZE_PAYOUT_KEY` (unset on production as of 2026-09-29; the programs deliberately refuse the club treasury fallback, which is the economy master wallet) to a dedicated wallet holding the $THREE to cover the caps (payout programs only); (3) deploy; (4) read the dry run at `/api/ops/growth-programs`; (5) `gcloud run services update three-ws-api --region us-central1 --update-env-vars <FLAG>=1`. Measured 2026-09-29 against production data: nothing would be posted or paid today (no live win cleared the 0.1 SOL size gate, no first trade met the softener bar, no leader has a profitable 30-day record with followers). | one yes per program | Roadmap 917 items 3.8, 12.15, 13.4 | [docs/growth-programs.md](../../docs/growth-programs.md) |
Deleted 2026-09-01: the former row 5 (`WALLET_ENCRYPTION_KEY_PREVIOUS` policy), which
declared itself "delete on reading" and had outlived that by three weeks.
diff --git a/scripts/audit-docs.mjs b/scripts/audit-docs.mjs
index c99ca61e4..cc27d9863 100644
--- a/scripts/audit-docs.mjs
+++ b/scripts/audit-docs.mjs
@@ -290,6 +290,7 @@ const UNPUBLISHED_DOCS = new Map([
['avatar-cli', 'internal: in-flight, register when the CLI ships'],
['uniswap-v4-hooks', 'internal: registry survey, prior-art review and concept ranking; the reader-facing doc is contracts/v4-hooks/README.md'],
['fee-bridge', 'held by the owner until launch is approved (2026-09-17); register in data/pages.json when /fee-bridge ships'],
+ ['growth-programs', 'held until the owner arms a program: ops runbook for the disarmed big-win X poster, first-rug softener and early-leader bonus; register in data/pages.json when one goes live'],
['avatar-fidelity-program', 'internal: program goals and competitive targets'],
['aws-marketplace-listing-kit', 'internal: paste-ready listing copy and portal steps'],
['aws-builder-center-before-the-signature', 'internal: draft prepared for the AWS Builder Center'],