Engine default + both bot configs + backtest set to 0 (cap logic stays, opt-in
via risk.max_per_event). June backfill without the cap: +465%, 237 resolved
(202W/35L), 22 missed, $170 fees.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
- engine (copytrade): stake_usd() = bankroll_pct x current equity (cash + open
cost basis) - Kelly-style compounding both directions - halved while equity
sits below 80% of its high-water mark; new risk.max_per_event (default 2)
blocks stacking correlated markets on one real-world event (dated-slug prefix
grouping; LSB1 once put 6 conviction bets on a single match).
- copybot: feed/summary report the dynamic stake, stake_pct, event_cap, hwm.
- portfolio backtest mirrors the exact same rule (PCT 4%, clamp $5-$150,
EVENT_CAP 2, brake 80%/half), with per-bet stakes in every table row and a
persistent CLOB slug cache for event grouping. June backfill: +426% vs +168%
flat - compounding amplifies the in-sample month; July live is the test.
Misses fell 62 -> 19 cash-missed (+26 deliberate event-cap skips): smaller
early stakes capture more signals.
- configs: bankroll_pct 0.04, max_trade/max_position 150 (runaway guards),
max_per_event 2.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
- portfolio.py: follow set -> the fee-aware copy-positive sharps (Kruto2027,
shisan888, fortuneking) + LSB1; entries pay the 0.03 sports taker fee and a
+0.5%/~90s lag haircut (entry_model); backfilled from June 1; feed exposes
fee_rate/slip/lag_est_s/fees_paid and unreal uses true cost basis.
- copybot.paper.json: same four wallets, p80 conviction floors from the cache
(Kruto $123.08, shisan $704.33, fortuneking $970, LSB1 $231). Fresh $1k state
committed separately by the bot - clean July book.
- host/start.sh + nixpacks: turnkey 24/7 worker for Railway/Fly/VPS - clones
with GITHUB_TOKEN, resumes the committed state, polls 60s, publishes
state+feed+fills back through publish_feed. Replaces the Mac poller.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
- bets table gains asset (token id = position identity), src/ts (endpoint
provenance + close time), resolved (False = early-sold in an unended market;
won is a curPrice mark). Auto-migrates v1 in place (~8s, 3,697 exact dupes
merged); legacy rows carry NULLs until their wallet refreshes.
- refresh is now an upsert by token instead of a wallet wipe: rows sliding out
of the rolling pull window survive, so per-wallet history accumulates into a
permanent archive. Same-asset rows from both endpoints (partially-closed
positions) dedupe to the larger-stake row - kills the two-endpoint
double-count class (~35k suspect pairs found in the audit).
- p stored raw (0 = avgPrice missing), clamped on read by get_bets, so missing
prices stay distinguishable from real 0.1c longshots; insider CLI + oos clamp
their own direct use.
- resolved_bets(strict=True): a failed page raises instead of returning a
silently truncated history; get_bets no longer caches or marks failed pulls
(pre-v2 an API error cached the wallet as empty-and-fresh for 14 days -
Kruto2027 was a live victim of this last night).
Verified: migration 18,289,320 -> 18,285,623 rows; forced refreshes of two
sharps show 0 same-asset dups, 0 legacy/new mixing, clamped reads, conviction
stats intact (Kruto conv win 73%).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
- get_json: catch OSError + http.client.HTTPException (RemoteDisconnected/
IncompleteRead escaped the retry loop and killed last night's validate_timing
run on a single dropped keep-alive).
- validate_timing: per-wallet retry+exclude guard so one bad wallet can't take
out the whole selection; regenerated watch_sharps.json — the first fee-aware,
resolved-only sharp list (10 copy-positive holders of 254).
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
- copybot: model Polymarket taker fees (V2, since 2026-03-30: shares*rate*p*(1-p),
sports 0.03) on every paper/live fill; track fees_paid in state + feed; settle
P&L nets the entry fee. publish_feed now commits state + fills ledger with the
feed (autostash rebase) so the local poller is the sole state writer.
- validate_timing: copy_pnl/held_pnl are fee-aware -> sharp selection now requires
clearing real copy costs; conv stats + lead profile use resolved bets only.
- conviction_scan/skill: exclude res_t>now rows (early-sold positions in
unresolved markets scored at curPrice - a mark, not an outcome; was ~5% of the
June test window at a 72% pseudo-win rate).
- portfolio: skip unresolved rows (stake used to vanish from equity); missed bets
of kind=open no longer KeyError - mark-to-market hypothetical P&L.
- collect: cap stale refreshes at STALE_CAP=2500/run (bulk-aged pool turned the
daily refresh into a ~40h pull holding the DuckDB lock).
- Actions cron disabled: GitHub ran */5 every ~1.5-2.5h and the 10-min stale
window skipped the rest -> 1 of ~104 qualifying buys copied. launchd --poll 60
is now the runner; workflow stays as manual backstop.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Adds each followed wallet's cache p80 conviction threshold so the dashboard
can filter LIVE open positions the same way the server does.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Set portfolio.py START to today so the $1k book tracks these wallets from
now forward (clean forward test, no in-sample backfill). Equity resets to
~$1,000; the daily run fills it in as bets resolve.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Update the dev-facing docs so others can follow the current system:
- live/README: copy-positive-holder selection (replaces lead-time gate),
Copy P&L as the copyability metric, new Paper portfolio (portfolio.py)
+ Dashboard feeds (watch_sharps.json / portfolio.json) sections, the
full 8-step daily flow, the cache rolling-180d/replace retention gotcha,
and a Copy execution (copybot/sync_floors, separate WIP) note.
- README: top portfolio is now precomputed off the cache (correct
recycling), judge by Copy P&L not win%, copy execution is separate.
- FINDINGS: capital-recycling / $1k-book section + repo-layout refresh.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
New portfolio.py replays the followed wallets' conviction bets ($1k/$50,
hold-to-resolution) from cache.duckdb — which has res_t, so capital
RECYCLES at the true resolution time (no client-side clob storms, no
phantom-locked capital) and covers the full bet history (~40 pages, not
the browser's 4). Writes portfolio.json (equity, splits, current/
resolved/missed tables, per-wallet); wired into daily.sh + publish. The
dashboard now renders the top page from this feed (1 request) with the
client-side replay kept as a fallback.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Replace the blunt 24h lead gate with a copy-replay selection run on EVERY
conviction wallet: keep only those that are copy-positive AND have a
genuine hold-to-resolution edge (held_pnl>0, held win-rate>=55% over >=8
resolved held bets), active in 30d, with a light >=1h lead floor vs true
snipers. display_stats now splits copy P&L into scalp vs held legs and
uses fresh-positions resolution (clob fallback) so it's cheap enough to
run on all ~229 wallets.
Effect: drops scalper-traps whose win% looked great but lose copied
(ArbTrader, iohihoo, S888, ttj01) and the old lead gate's discards;
surfaces fast-resolving copy-positive holders it used to throw away
(raid3r, 0x6d1A94f4, 0xec1d07e5, mantaray, earthisgood, shisan...).
14 copy-positive holders now in watch_sharps.json.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
The daily run regenerates dashboard.html but the publish step never
committed it, leaving it perpetually modified. Add it to the publish git
add list and commit the current snapshot.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
README/FINDINGS/live/README updated for today's discovery: the sharps
win% is a position snapshot that over-counts scalpers; copy_pnl (flat-$50
replay, authoritative clob resolution) is the real copyability signal.
Most "sharps" lose copied; only Kruto2027 + fortuneking are copy-positive
(now the tracked pair). Refreshed stale counts (50 -> ~31 after the
30d-active filter) and noted position-level conviction.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
display_stats now computes copy_pnl: what a flat-$50 copier of a wallet's
conviction bets ACTUALLY realizes since Jun 1 — replays their entries,
mirrors their exits, and settles held bets at AUTHORITATIVE clob
resolution (winner by token_id). This is the truth for copyability and
exposes scalpers whose position win% looks great but lose when copied
(ArbTrader 99.5% conv win but -$793 copy; iohihoo 88.7% but -$749).
Position win%/record/P&L stay on the cache (large 180d sample). Added a
clob resolver (_clob_winner) + activity-replay; only Kruto2027 (+1184),
S888, oliman2, fortuneking (+430) etc. are positive to copy.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
validate_timing now filters the sharp list to wallets that have traded in
the last 30 days (last_trade from the /activity pull), so watch_sharps.json
only lists currently-active sharps — not just hidden client-side. Dropped
10 of 41 on this run (-> 31 active). The dashboard keeps its own 30d filter
as a safety net for daily-stale feeds.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
display_stats now emits conv30_win/won/lost/pnl — conviction (top-20%)
bets resolved in the last 30 days — for a new "30 Day Conv Record" column
on the dashboard alongside the lifetime record.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
daily.sh now POSTs a summary (finish time, sharp count, push status) to a
Discord webhook after the publish step. The webhook URL is read from the
gitignored config.json (daily_webhook key) so it never lands in the public
repo; the ping is skipped if the key is absent. Sends a browser User-Agent
(Discord 403s requests without one).
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
display_stats now emits avg_bet = average stake of the wallet's
conviction (top-20%) bets, for a new dashboard column after the P&L
columns.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
validate_timing.py now writes name, conv_win, conv_won/lost, conv_pnl,
realized_pnl, last_conv_bet and last_trade per sharp, so the dashboard
reads everything from the feed in ONE request instead of 3 data-api
calls per wallet (no more rate-limit storms). Stats come from the cache
(survivorship-correct): conviction win%/record/P&L over ALL of the
wallet's top-20%-stake bets; realized P&L over the last 500 resolved
bets. Resolved P&L per bet = stake*(1-p)/p if won else -stake.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
recent_markets() only stopped on end-of-data (page <100) or MAX_SCAN.
When gamma 422s past its max offset, every page in a wave returns "ERR"
and is skipped — so `scanned` never grows and `ended` never trips,
spinning forever. This wedged every daily.sh run at "scanned 2,100…"
(step 1/6), so the cron never actually completed. Now bail after a
second consecutive all-error wave (one is tolerated; _page already
retries transient errors).
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Add the sharps pipeline (conviction_scan.py + validate_timing.py) to the
daily run so watch_sharps.json self-updates, and a publish step that
commits + pushes the refreshed outputs (watch_skilled / watch_sharps /
conviction_wallets) so the live dashboard at jaxperro.com/trading picks
up the new set. Also force-refresh the sharps watchlist (not just
skilled) before the cache top-up for accurate forward stats. Publish
does pull --rebase before push so a diverged remote can't wedge it.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
The lead-time gate in validate_timing.py is a COPYABILITY heuristic, not
proof of inside information: a short entry->resolution lead can be a
genuine insider OR just someone who trades fast-resolving markets (live
sports, hourly) well — indistinguishable, and irrelevant for copy
purposes since either way the window is too tight to mirror. Rename the
verdict accordingly. Gate unchanged (median lead >=24h to count as a
copyable sharp; 50 sharps). Docs updated to current p80 numbers
(218 profile matches, 62/83 forward-profitable, 50 sharps).
The genuine insider-detection scanner (insider.py, z-score / Bubblemaps
fingerprint) keeps its name — that's a different, correctly-named thing.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Swap the flat $200 conviction cutoff for a per-wallet percentile (top
20% of each wallet's own stake sizes) everywhere it was used:
- cache.py: canonical CONV_PCTILE=0.80 + conv_cutoff() helper (matches
the dashboard's pctl: filter >0, sort, linear interp)
- conviction_scan.py: per-wallet quantile_cont(size,0.8) in SQL, was
`size >= 200`
- validate_timing.py, pnl_focused.py: use cache.conv_cutoff
Rationale + validation: p80 reproduces flat-$200's win-rate lift on the
sharps while adapting to scale (a whale's $200 isn't conviction, a
minnow's is). Re-running the pipeline under p80: scan finds 218 profile
wallets (was 69), forward 62/83 profitable (p~0), +16% pooled ROI — edge
persists out-of-sample. Regenerated conviction_wallets.json /
watch_sharps.json; docs updated. skill.py/strategy.py/insider.py
untouched (score over all bets / size as copyability heuristic only).
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
README/FINDINGS/live-README now cover the repeatable find: score high-conviction
(>=$200) bets, validate forward (25/37 profitable, p=0.024), then a lead-time
gate drops uncopyable insiders -> 23 validated copyable sharps shown live on
jaxperro.com/trading.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
conviction_scan.py finds wallets whose high-conviction (>=$200) bets win on
uncertain (~0.4-0.6) markets — real edge, not favorite-riding — trained pre-June
and validated June (25/37 stayed profitable forward, p=0.024). validate_timing.py
applies the entry->resolution lead-time gate that separates copyable sharps from
uncopyable insiders: of 69 matches, 21 were insiders (lead <6h), leaving 23
validated copyable sharps (watch_sharps.json) now shown on jaxperro.com/trading.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
live/: operationalizes the LBS/Yale "skilled ~3%" result against the live
data-api. Enumerate recent liquid markets -> top traders -> candidate pool;
cache every wallet's resolved bets once in DuckDB (~26k wallets / 12.5M bets,
keyed by per-bet resolution time so any cutoff re-scores in seconds); 5-gate
skill funnel (n>=15, z>0, BH-FDR, split-half OOS, MM/bot cap); dashboard +
daily refresh.
Key finding: copying the high-win-rate "favorite-rider" cohort looks +23.6%
in-sample but loses -7.4% once selected on pre-June-1 data only (99% -> 68%
win rate) — selection bias, reproducing the paper's "lucky winners revert"
result on live data. Win rate != edge, again.
wide/: bulk subgraph->DuckDB scanner (survivorship-bias-free over all wallets),
but the public subgraph is frozen at Jan 2026 -> historical tool only.
Large local data (*.duckdb, candidates.json, *_scored.json, history/) gitignored.
README + FINDINGS updated with the current logic and the clean result.
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
jaxperro