# HANDOVER: Robinhood Chain lane radar (category tree + novelty "golden nugget" finder)

Written 5 Oct 2026 about 08:15 BKK by the Cowork session that built it. Paste this link into the new session and continue from here. Everything needed is in this one file. No secrets are in it, only the paths where they live.

---

## 0. First 5 minutes for the new session
1. Read this whole file. Then read the project docs listed in section 11, plus memory files /projects/01a0fb26-9317-76c2-81d6-e63f6c1959d5/areas/trading-edge-hub-4.md and /preferences.md.
2. Reach the droplet. The cloud container cannot SSH out. Use Ben's Mac through Desktop Commander (`mcp__remote-devices__Desktop_Commander__start_process`):
   `ssh -T -i ~/kookwatch/id_kookwatch -o ConnectTimeout=25 root@159.223.88.168 'python3 -' < /tmp/lanemac/live/SCRIPT.py`
   Pattern: write the script on the Mac with Desktop Commander write_file (`/tmp/lanemac/live/`), then pipe it over ssh. Port 22 sometimes times out once; retry.
3. Run the health check in section 7. Expect: all units active, beat under 5 s, missing 0, rows_without_label 0.
4. The AI judge is WORKING again: Ben topped up credits at about 08:10 BKK, and Opus 5.5 labels have flowed since 08:11 BKK. Confirm `state/judge_health.json` shows last_ok newer than last_err, and that rows get `label_src='judge'` with `judged_by='claude-opus-5-5'`.
5. Measured cost (08:11 to 08:18 BKK):
   - Opus 5.5: about $0.023 to $0.033 per coin when the cache is warm (49k cached tokens, about 2.5k fresh input, about 200 output tokens).
   - One cold cache write: about $0.26.
   - Speed: 3 to 10 s.
   - Expect about $15 to $20 a day for about 630 judged coins (950 with text, minus copies). Track it daily from cost_usd.

## 1. How Ben wants to be talked to (standing rules, apply always)
- Talk like he is 5: plain words, very short bullets, no jargon, no walls of numbers. Detail goes in docs, not chat.
- Never use dashes or em dashes in replies. Use commas, periods, colons, parentheses.
- Always Bangkok time (UTC+7).
- Never put a secret on screen. Inspect configs with `/opt/common/showcfg.py`, never cat. Secret files chmod 600.
- Never truncate blockchain addresses.
- Build and deploy end to end without asking. Come back only when a step needs his hands.
- Things must fix themselves, with redundant checkers. He is messaged only when ALL layers fail.
- Anything handed to another AI must be ONE public URL (like this one).
- Push back when there is a better way. Work from first principles. No self-deprecating framing; state corrections plainly.
- Every trading insight goes into the hub ledger (memory trading-edge-hub-4) in the same turn.
- Use APIs carefully (GMGN shared limiter, X daily cap). Never push into rate limits.

## 2. What Ben asked for (the goal)
- A live map of every new Robinhood Chain (RH) coin: a CATEGORY TREE (domain > category > type > subtype, for example Financial services > Lending > Shared lending pool > Against tokenized stocks). Shows where launches land and how that shifts over time.
- Each coin labeled within seconds of launch (hard promise: the first category within 20 s). The time the category was given is saved.
- Socials from GMGN (API, used gently). No socials and no text means Uncategorized > No info. Links but no words means Uncategorized > Lazy launch. "Uncategorized" stays its own group because it is information by itself.
- Novelty: most launches are trash and copycats. Find the GOLDEN NUGGETS: projects with a real new idea and real thought behind them. Classes NONE / COSMETIC / NOVEL_MINOR / NOVEL_SIGNIFICANT, score 0 to 3, a gap id G1..G40, plus (new) market appeal 0 to 3 and red flags.
- 72 h price tracking in a database. This feeds Ben's separate winner-pattern process.
- Stats page: how many coins, how fast, why slow, categories over time. Must work on phone and desktop.
- Use the smartest AI brain available, made efficient WITHOUT losing quality. Ben is not trying to save money.
- Latest focus from Ben (5 Oct): stay FULLY on categorization, meaning understanding what the project does. Market signals (smart wallets buying, holders, price) are OUT of scope for the idea work.
- Not going live with trading. This is a map and a research database.

## 3. Current state (5 Oct 2026, 08:15 BKK)
- Radar v3.6 live on droplet `kookwatch` 159.223.88.168, `/opt/laneradar/`.
- Labeled about 1,700 coins per 24 h. About 950 per day have text. About 34% of text coins are relaunch copies of earlier text.
- First label: median about 3.7 s from the launch block (detection 3.4 s, work after detection 0.3 s). The AI label lands a few seconds later (budget 40 s).
- AI judge: model chain claude-opus-5-5, then claude-sonnet-5-5, then claude-haiku-4-5. It was down 04:52 to about 08:15 BKK (credit ran out). There is a backlog of about 290 coins with only the fast label in the last 24 h. lanecheck re-labels them automatically once the judge works (10 per 15 s run, only coins older than 10 min).
- MEASURED cost with Opus 5.5 (v3.6): about $0.025 per judged coin, plus about $0.26 per cold cache write. That is about $15 to $20 a day. Prices per million tokens: $4 input, $20 output, $0.20 cache read, $5 cache write (5 min).
- Fixed 08:13 to 08:17 BKK:
  - v3.4: Opus replies can hold non-text blocks, so only text blocks are read. When the cache is cold, one call writes it and the others wait (no parallel double writes).
  - v3.5: broken replies are kept in state/judge_bad.log.
  - v3.6: max_tokens raised 500 to 1500. Replies were being cut off, so 30% fell back to Sonnet; now 100% Opus.
- Why $5 of credit lasted only about 5 h: each call sent the ~30k-token instruction book plus 120 memory lines, and failed calls were retried. Fixed in v3.2 and v3.3.
- Stats page: http://159.223.88.168/hx-c9ois/lanes/stats.html (and stats.json). Map, rubric, research: http://159.223.88.168/hx-c9ois/lanes/map/

## 4. Architecture (droplet /opt/laneradar)
**laneradar3.service** (simple, Restart=always, RestartSec=5, env XCAP_DAY=600) runs `radar3.py` with venv `/opt/laneradar/venv/bin/python`.
- Poll loop every ~2 s: `eth_getLogs` for Uniswap v4 PoolManager `0x8366a39cc670b4001a1121b8f6a443a643e40951`, Initialize topic `0xdd466e674ea557f56295e2d0218a125ea4b4f0f6f3307b95f85e6110838d6438`, public RPC `https://rpc.mainnet.chain.robinhood.com` (browser User-Agent needed).
  - Backup source: Alchemy (key in /opt/common/rpc_keys.json). The FREE tier allows only 10 blocks per getLogs, so 3 slices per poll.
- Public RPC logs come WITHOUT blockTimestamp. `bts(block)` reads the block time (cached), otherwise launch times would be "seen" times.
- Base quotes: ETH `0x0000000000000000000000000000000000000000`, `0x5fc5360d0400a0fd4f2af552add042d716f1d168`, `0x0bd7d308f8e1639fab988df18a8011f41eacad73`.
- Each coin runs in an 8-thread pool (catch-up coins in a separate 2-thread pool):
  1. Chain metadata batch (name, symbol, description, socials, tokenURI, decimals, supply, code fingerprint, hook fingerprint) through `R.meta_batch` (Alchemy). R.rpc is replaced by a fast version: 6 s timeout, 2 tries, then the other source.
  2. GMGN `/v1/token/info` (openapi.gmgn.ai, key /opt/common/gmgn_key) through the shared limiter `/opt/common/gmgnlimit.py` (`acquire(1, 3, reserve=4.0)`, `ok()`, `banned(reset)`). Weight 1, low priority, never below the shared reserve.
  3. tokenURI json, X bio (twitterapi.io, cached in state/xcache.json, cap 600 a day), website text (only real html/text pages), linked post text.
  4. Text = on-chain description + URI description + GMGN description + bio + linked post + site. Then `sanitize()` cuts images, CSS and pool words ("Pump AMM", "Raydium CPMM"...). Launchpad coin pages (stonkfun, fomo, long.xyz, pons, bankr, letscash...) are ignored.
  5. Rules first, then labels:
     - Name contains "Robinhood Token": Real-world assets > Stock tokens (bond and treasury names go to Funds and debt).
     - Same text as an earlier AI-judged coin (text_key, 7 days): copy that label, `label_src='same_text'`, `relaunch_of`.
     - No text and no socials: Uncategorized > No info. Socials but text under 40 chars: Uncategorized > Lazy launch.
     - Otherwise the fast label (bge-small embedding + logistic model fastclf.npz). This is the FIRST LABEL, saved immediately with t_first_label.
  6. AI judge (`judge()`):
     - System prompt = judge_v3_system.md (category tree with definitions + novelty rubric, ~120 KB, ~30k tokens, cached) + ADDENDUM v3.2 (strict novelty, category rules, market appeal, short fields).
     - User message = 25 memory lines (15 most similar earlier novel ideas + 10 newest) + coin card.
     - Returns l3, l4, cls, score, gap, claim, why, conf, appeal, appeal_why, red_flags. Usage tokens and cost are logged.
     - Credit or auth error: pause 5 min and write state/judge_health.json. 404/429/529: try the next model.
- Every row is written twice: at the first label (label_stage first) and at the final label (label_stage final). Placeholder at 22 s if a coin has no row yet ("Uncategorized (labeler slow)"). Crash fallback row "Uncategorized (label error)". Both are replaced later.
- Heartbeat `state/radar3.beat` every poll. `state/radar3.ok` every 30 s. Corpus (`state/corpus.npz`, 5,954 earlier projects) saved atomically with corpus.prev.npz.
- Catch-up: lanecheck writes `state/requeue.json` (block numbers). A background thread fetches those blocks (20 per round) into a queue, and the main loop drains up to 30 logs per poll.

**Other units**
- `lanetrack.timer` (5 min): `tracker.py` reads 72 h prices from v4 slot0 via extsload (selector 0x1e2eaeaf, keccak(poolId, 6), sqrtPriceX96 low 160 bits). Every 5 min in hour 1, 15 min to 6 h, hourly to 72 h. USD from CoinGecko/DexScreener ETH, USDG=1.
- `lanestats.timer` (10 min): `stats.py` writes /opt/launchwatch/pub/hx-c9ois/lanes/stats.html + stats.json. Speed = launch block to first category; catch-up rows (seen more than 300 s late) are excluded from speed.
- Old `laneradar.timer` (v2) is disabled.

**Files** in /opt/laneradar: radar3.py, radar.py (helpers), lanedb.py (schema), lanecheck.py, stats.py, tracker.py, stale.py, judge_v3_system.md, tree_v1_nodes.json, tree_prompt.txt, fastclf.npz, map_v2.json, history_rows.json.
- Backups: *.bak31* .bak32 .bak33 .bak34 .bak35 .bak36. Last good code: /opt/laneradar/good/ (radar3.py, radar.py, lanedb.py).
- Patch folders: /opt/laneradar/p31, /opt/laneradar/p32.

## 5. Database `/opt/laneradar/lanes.db` (SQLite, WAL)
- **coins**: tok (PK), t_launch, launched_bkk, block, pool_id, c0, c1, quote, hook, name, sym, decimals, supply, txt, x_handle, x_followers, x_created, site, flags, near, maxsim, knn_*.
  - Labels: l1, l2, l3, l4, category (plain words), label_src (rule / rule_rh_stock / fast / judge / same_text / fallback_*), label_stage, fast_conf.
  - Judge: cls, score, gap, claim, why, conf, judged_by, judged_at, appeal, appeal_why, red_flags, judge_ms, tok_in, tok_cache_read, tok_cache_write, tok_out, cost_usd.
  - Timings: t_block, t_seen, t_first_label, first_label_bkk, first_label_latency_s, t_labeled, labeled_bkk, latency_s, fast_latency_s, ms (json per step), slow_reason.
  - Other: socials_src, has_socials, launchpad, relaunch_of, text_key, tracked, control, created.
- **prices**: tok, t, minutes, price_quote, price_usd, mcap_usd, src.
- **history**: 22,972 coins, 60-day labels.
- **view coin_outcomes**: first, peak and last market cap in 72 h.

## 6. Reliability layers (all silent, they fix)
1. **lanecheck.py**: systemd lanecheck.timer every 15 s, plus cron every minute; shared flock /tmp/lanecheck.lock.
   - Heartbeat older than 30 s: restart radar (60 s cooldown).
   - Chain check, last ~1,500 blocks: every pool older than 45 s must have a row; if not, requeue, and restart if still missing.
   - Rows without a category or label time, and fallback rows: requeue.
   - Failed AI labels: retried only while the judge works (10 per run, 10-min spacing).
   - Saves last good code after 10 healthy minutes; a crash loop rolls back automatically.
   - AI judge down 30 min for credit or key: ONE message to Ben via /opt/common/alertgate.py, and one BACK.
   - Backup chain source when the public RPC fails.
2. **livewatch2** (/opt/livewatch/livewatch2.py, timer every 20 s): radar heartbeat older than 75 s means restart; turns lanecheck.timer back on if it stops.
3. **/opt/laneradar/stale.py** (cron 5 min): heartbeat 150 s, lanecheck.ok 300 s, stats and tracker. It alerts only if all layers keep failing for 10 min.
4. **/opt/supervisor/super.py** (5 min) entries for laneradar3 (beat 150 s), lanecheck, lanestats, lanetrack.
5. **/opt/supervisor/guardkit.py** (15 min) re-enables laneradar3.service, lanestats.timer, lanetrack.timer, lanecheck.timer.
- Tested 5 Oct: frozen radar back in 37 s; killed back in 11 s; broken code rolled back in 61 s; deleted row restored in 42 s; lanecheck off, livewatch2 restored it in 21 s.

## 7. Health check script (save as /tmp/lanemac/live/verify.py on the Mac, run over ssh)
```python
import json, sqlite3, subprocess, time
H='/opt/laneradar'; ST=H+'/state'; now=time.time()
def age(p):
    try: return round(now-int(open(p).read().split()[0]),1)
    except Exception: return None
print(subprocess.run('systemctl is-active laneradar3 lanecheck.timer livewatch2.timer super.timer lanestats.timer lanetrack.timer',shell=True,capture_output=True,text=True).stdout.split())
print('beat',age(ST+'/radar3.beat'),'lanecheck',age(ST+'/lanecheck.ok'),'stats',age(ST+'/stats.ok'))
print(json.load(open(ST+'/lanecheck.json'))['last'])
try: print('judge',json.load(open(ST+'/judge_health.json')))
except Exception as e: print(e)
d=sqlite3.connect(H+'/lanes.db',timeout=30)
print(d.execute("SELECT label_src,count(*),round(avg(first_label_latency_s),1),max(first_label_latency_s) FROM coins WHERE t_launch>? AND t_seen-t_block<300 GROUP BY 1",(now-3600,)).fetchall())
print(d.execute("SELECT judged_by,count(*),round(avg(cost_usd),4),round(sum(cost_usd),2),round(avg(judge_ms)) FROM coins WHERE label_src='judge' AND judged_at>? GROUP BY 1",(now-86400,)).fetchall())
print('unlabeled all time',d.execute("SELECT count(*) FROM coins WHERE t_labeled IS NULL OR category IS NULL").fetchone())
```

## 8. Transfer routes (container to droplet, code only, NEVER secrets)
- dpaste.com is BLOCKED for us (10 MB per-IP limit hit). Use **dpaste.org**:
  - Upload from the container: `curl -s -F "content=<file.b64" -F syntax=text -F expiry_days=1 https://dpaste.org/api/` returns a URL.
  - On the droplet: `curl -s URL/raw | tr -d "\r\n " | base64 -d > file`, then check md5.
- Small scripts: write them on the Mac with Desktop Commander write_file and pipe over ssh (simplest).
- Droplet to container: copy into /opt/launchwatch/pub/hx-c9ois/<tmp>/, curl from the container, then DELETE the temp folder.
- Public folder: /opt/launchwatch/pub/hx-c9ois/ is served at http://159.223.88.168/hx-c9ois/

## 9. Lessons and traps (do not repeat)
- Edit on the server. Never push a stale Mac or container copy over the server file. Patch with exact-string replacement scripts that assert, keep a .bakNN copy, and run ast.parse before writing.
- A patch that replaced the text "between function A and main()" deleted the catchup thread and caused a 3 min outage. Always check that neighbours survive. Rollback to /opt/laneradar/good now catches this.
- A numpy .npz read by several threads breaks. Load it fully at start (done for fastclf).
- Write files atomically (tmp + os.replace). The corpus was lost once to a half-written file.
- Public RPC getLogs gives no block times; Alchemy free tier allows 10 blocks per getLogs; Anthropic credit errors arrive as HTTP 400 with "credit balance" in the body.
- The cheap AI (Haiku) over-called NOVEL_SIGNIFICANT (4.3% vs 0.2% in the careful blind study) and filed site-only claims as significant. A template farm ("ZK + tokenized stocks + 80% of fees burn") fooled it. Opus plus the v3.2 addendum should fix this. VERIFY on the first 100 Opus labels.
- Never skip coins with word filters: on 5,754 judged coins it would lose 4 of 12 significant. Never trim the tree branches: the cache makes the full tree cheap, and trimming mislabels about 6%.

## 10. Findings so far
- 5,754 RH coins with first-minute text (4 Aug to 2 Oct), careful blind judge: NONE 44.8%, COSMETIC 52.2%, NOVEL_MINOR 2.8%, NOVEL_SIGNIFICANT 0.2% (12: PolyFrog, size it, violeti, PEER, vetra, Pomp, Parity, Arena Markets, Note Systems, hoodoracle, Trion, MERGER).
- 60-day history (22,972 coins): Uncategorized 68%, Memes 15%, Token mechanics 3%, Token launch 3%, AI 2%, Games 2%, Social 2%, Finance 1%.
- What separates significant projects in their own text (AUC, 0.5 = nothing, 1 = perfect):
  - Concrete mechanism words minus buzzwords: 0.80. Significant ones average 0 buzzwords.
  - Demanded-gap words (weekend, dividend, shorting, oracle, options, payments): 0.72.
  - Similarity to earlier projects: 0.51 (useless).
  - Length: 0.66. Has an X account: 0.66.
- Early outcomes (coins 6 to 24 h old, share reaching $100k, small sample, re-check at 72 h):
  - By category: Uncategorized 8%, Memes 25%, AI 36%, Token launch 32%.
  - By novelty: NONE 27%, COSMETIC 36%, NOVEL_SIGNIFICANT 7 of 14.
- Hand check of 40 Haiku labels: about 22% wrong at type level (causes since fixed: images as text, launchpad pages, a catch-all node, news memes filed as AI).
- Fast model (no AI): domain top-1 72%, top-3 94%, top-8 99% (optimistic, in-sample).

## 11. Where everything else lives
- Project "Pro Trading" docs:
  - claude/lane-map-v2-2026-10-04.md (tree, labeler, reliability)
  - claude/lane-review-2026-10-05.md (5 checks, 50 map ideas, first 50 novelty ideas)
  - claude/golden-nuggets-2026-10-05.md (cost answer, 5 passes, 50 content-only nugget ideas)
  - claude/lane-radar-v2-2026-10-04.md
  - claude/lane-map-v1.md
- Memory: /projects/01a0fb26-9317-76c2-81d6-e63f6c1959d5/areas/trading-edge-hub-4.md (ledger lines for all of this); /preferences.md.
- Research in the old container (may be gone): /tmp/lanes/research (iter01..iter10, map_v2.json, novelty_rubric.md), /tmp/lanes/v5_all.json, stream3.json, lab_X.npy, lab_Y.json. The droplet keeps the map and rubric at /opt/launchwatch/pub/hx-c9ois/lanes/map/.

## 12. NOT YET DONE: the full backlog, in recommended order
### A. Do first (next session)
1. Confirm Opus labels keep flowing (no Sonnet fallbacks, judge_bad.log not growing); report cost per day to Ben in one line.
1b. Cost idea that keeps quality: the about 2.5k fresh input tokens per call (card + 25 memory lines) are about 40% of the cost. Test whether 15 memory lines judge the same on a gold set before changing it.
2. Check the first 100 Opus labels by hand (category right? novelty base rate near 0.5% significant? template farm caught?). Tune the ADDENDUM if needed.
3. Watch the backlog re-label (about 290 fast-only coins) finish.
4. Re-check the outcome table at 72 h (coins from 4 to 5 Oct).
5. Stats page: add AI judge status, cost per day, appeal and novelty counts, a "golden nuggets today" list. Must work at 390 px and desktop.

### B. Golden-nugget ideas, content only (Ben's current focus). From claude/golden-nuggets-2026-10-05.md, none built yet unless marked
1. Read the whole website (how it works, FAQ, docs, whitepaper, up to about 3,000 words). Best as a second pass 5 to 10 min after launch.
2. Follow docs links (GitBook, Notion, Mirror).
3. GitHub README, commit count and span, languages. GitHub is blocked from the cloud container; use the droplet or the Mac.
4. Verified contract source (Blockscout): does the code do what the text says?
5. First 20 posts of the project X account (the launch thread explains the idea).
6. Pinned post and long explainer threads.
7. Open the app link: a working screen or only a landing page?
8. Telegram description and pinned message.
9. Founder's own earlier builds (content, not follower counts).
10. Re-judge at 1 h and 24 h when new text appears (text diff trigger).
11. Idea card: user, problem, mechanism, asset, who pays, what is new, proof; empty fields marked missing.
12. Seven-word test.
13. Mechanism chain (input, rule, output) to compare ideas instead of words.
14. Separate theme from mechanism.
15. Product vs token: is the token needed?
16. Extract every factual claim.
17. Tag claims: checkable now, later, never.
18. Translate non-English text first.
19. Specificity score (mechanism words minus buzzwords, AUC 0.80) passed to the AI as a hint, never as a gate.
20. Buzzword-stack penalty.
21. Does it name its own failure cases?
22. Do the numbers add up?
23. Do the parts fit together?
24. Why here, why now (uses something only RH has: stock tokens, USDG, Robinhood Earn)?
25. Team-written or AI boilerplate shared across many sites (template farm)?
26. Effort: own domain, app, contract.
27. New code template that matches the text claim (the flags new_token_template and new_hook_template exist).
28. Contract has the claimed functions.
29. Docs depth (risks, parameters, math).
30. Founder answers hard questions in replies (the content of the answers).
31. Prior-art search by mechanism chain across all RH coins plus Solana and Base launches.
32. Web and X search of the 7-word summary.
33. Weekly commodity-list update.
34. Copy family tree: "first of its kind" vs "copy number 23".
35. Relaunch detection by mechanism (by text is DONE).
36. Template farm by site template, wording or deployer.
37. Growing rebrand dictionary.
38. Toggle test (could pump.fun or Pons ship it in a week?).
39. First anywhere vs only first on RH.
40. Pairwise: what does it do that the nearest earlier project does not?
41. Match to the 40 demanded gaps, kept fresh from what people ask for on X (the request text).
42. Name the user and the new action.
43. Who pays (outside payer vs circular).
44. Hard to copy (data, integrations, licence, risk engine).
45. Depends on someone else's switch.
46. Legal reality of stock-token claims.
47. Two passes: an adversarial Opus critic only for coins rated MINOR or better (about 5%).
48. Daily top 10 for quality of thought.
49. Ben marks about 20 coins a week as nugget or trash; tune to his calls.
50. Weekly review of misses.

### C. Map ideas (from claude/lane-review-2026-10-05.md). Done: 25 same text, 45 auto re-label after outage, 48 hard timeouts on chain calls. Dropped: 26 trim tree branches.
1. Project layer (group relaunches by text, X, site, deployer).
2. Deployer and funder graph, serial launchers.
3. Template-farm detector.
4. Launchpad from hook address (1,089 of about 1,700 coins a day have no launchpad tag; hook 0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544 alone covers 533).
5. Paired-asset lane (stock token quote gives the lane).
6. Name and ticker hint for no-info coins (side field; they stay Uncategorized).
7. Logo reading with a vision model.
8. to 10. Pinned post and last posts, Telegram, deeper site (overlap with B).
11. Product stage field (landing, waitlist, live app, audited).
12. Claims verified in contract code.
13. Test tokens get Uncategorized > Test.
14. Impostor flag.
15. Existing bridged or wrapped assets (cbBTC, TRON) are not launches.
16. Official stock tokens recognized by issuer contract.
17. Re-label at 1 h and 24 h, with category drift.
18. Daily clusters, emerging metas.
19. Level 5 free-text meta tag.
20. Monthly proposal of new tree nodes.
21. Audit catch-all nodes.
22. Confidence per level.
23. Second opinion by a second model.
24. Gold set of 200 hand-checked coins, weekly accuracy.
27. to 44. Map views: hit rate per node, volume per node, buyers per node, hour heatmap, launchpad x category, Solana and Base on the same tree, X mentions per category, demand layer, gap heat, saturation, copy speed, first mover per node, leader per node, fees per node, tree versions, JSON feed for Ben's winner process, stats drill-down, daily digest. (Several of these use market data. Ben's latest focus is content; keep them for the map views only.)
46. WebSocket push detection (3.4 s down to about 1 s).
47. Start X and site reads as soon as GMGN answers.
49. Auto-detect new launchpads.
50. Monthly quality report.

### D. Earlier "will the market like it" ideas: PARKED by Ben (5 Oct). Do not work on smart wallets, holder flow, buy pressure, bundles or callers for this project. Only the appeal score from content (hook, timing, simplicity) stays in the AI judge.

## 13. Suggested next build (highest value per Ben's goal)
- "Deep read" second pass at about 5 to 10 min after launch, for coins with a site, X or docs:
  - Fetch the full site, docs, GitHub, contract source and first X posts.
  - Opus fills the idea card and runs an adversarial critique (B1 to B7, B11, B16 to B29, B47).
  - Store the idea card fields and a quality-of-thought score.
- Daily "golden nuggets" list on the stats page (B48).
- Gold set with Ben (B49), to calibrate.