winning-wallet-finder/HANDOFF_ARCHIVE.md

Session handoff — 2026-07-19 (rev 15: tape+bench+gate; rev 14: +$44 bankroll, exact paper-parity config; rev 13: FAK parity; rev 12: chain-seed)

2026-07-19: VALUEBOT KILLED (user call, pre-registered criterion met)

994 resolved: 1W/993L, 0.075x — historical 1.24-1.28x edge refuted in the current era (expected ~12 wins, got 1). Post-mortem in value/PLAN.md; Fly app destroyed; feed/dashboard kept as record. Reusable takeaways: the honest fill model + silo pattern; next hypothesis should come from the RTDS tape.

2026-07-19 (rev 16): audit hardening shipped (top-10 items 1-9)

Deep-audit fixes, all deployed same day: (1) the book is now fully serialized — resolve_pendings/retry_stuck_exits/write_feed take bot.lock, _drain_fills snapshot-swaps the shared fills list (kills the last July-12 phantom-cash race class); (2) sweep_dust gates every action on CHAIN share balance and credits proportionally (data-api ghosts book ~$0 forever); (4) BOOT-ID single-writer guard — a stale process that survived machine-stop sees a newer boot in origin's state at publish time and EXITS instead of overwriting surgery (gotcha 15c is now an invariant, not a procedure); (5) user-ws verifies TLS (it carries L2 creds; RTDS stays CERT_NONE — public data); (6) valuebot state is tmp+rename atomic with a loud ⚠ STATE RESET alarm; (7) settle_resolved throttled 20s off the webhook hot path (faster copies in bursts); (8) daily.sh mkdir-lock (macOS has no flock) + ingest's two inserts are one transaction; (9) seen_tx keeps the NEWEST 5000 via a recency dict (was an arbitrary set slice); (10) AIcAIc live floor pinned to paper's 341.23 (was boot-nondeterministic, violating mirror-exactly). STILL QUEUED from the audit: redeem.py pUSD/deposit-wallet fix before any auto_redeem re-enable (audit 3.3 — it would book phantom credits today); listener-start-after-seed reorder (3.9); dead-code sweep (copytrade LiveExecutor + broken CLI, _book_snapshot dedupe); reconcile_entries positions-pull diet; sftp tape transport; rpc-down heartbeat flag.

2026-07-19 (rev 15): the rest of the day

• RTDS TAPE live end-to-end: wwf-recorder (own silo, no repo clone — code baked in image) tapes every platform trade to hour-rotated gz segments on a 10GB volume; nightly ingest (daily.sh step, 900s/segment timeout after busy hours outgrew 300s; flyctl resolved absolutely — the launchd PATH broke night one) pulls into live/rtds.duckdb (own DB file, never contends with cache.duckdb). 4.9M trades already banked. Recorder reconnect-clock bug fixed (196 flaps/34h → ~0; 45s stale guard).
• VALUEBOT v0.1: sub-bucket study showed a BARBELL (0-0.2c 3.13x in history but 404 straight live losses = modern adverse selection suspected; 0.2-1c toxic 0.62-0.70x; 1-2c 1.28x n=424k) — bot now trades 1-2c ONLY; 0-0.2c shelved pending tape confirmation. Dashboard: jaxperro.com/value.
• BENCH rev 5: five fresh sharps benched in backtest.json (lma0o0o0o, leegunner, oliman2, JuiceFarm, 0xb0E43B); ArbTraderRookie EXCLUDED (res_t poison history). Verdict next Friday; run insider.py on the 100%-win two.
• Live book reconciles clean: +$7.14 chain-over-book folded (platform auto-redemptions + favorable rounding — the venue auto-redeems winners, which also makes our own Redeemer less urgent), +$2.31 drift recognition, BetBoom ghost/zombie purged (data-api lag resurrected a 0.12sh residual the chain zeroed — reconciler trusts the laggy API; ROOT FIX QUEUED: verify residuals against chain balance before resurrecting). auto_redeem OFF again (Redeemer needs web3 in the live image + ALCHEMY_RPC_URL env fallback — QUEUED). Realized −$16.94 lifetime after honest recognitions.
• Deep architecture audit run (read-only agent, 2026-07-19) — findings in the session log; act on the top recommendations next session.

2026-07-19: spread skip retired (both books)

The depth gate's hard spread>0.08 skip was a lag-era relic: fitted at 39-90s detection when wide spread meant the book repriced under a late copy. At ~4s RTDS lag the mechanism is gone (fills ledger: median |slip| 3.7%→1.7% era over era; Kruto+gkmg in-play mean +0.4%), and the skip fired on the informed wallets' best moments — 17 resolved skips would have run 12W/5L (+$11 live / +$674 paper, Tauson tennis +$447 the headline). Overpay stays bounded by the price guard (+0.05 abs) and FAK protected band; the depth STAKE CAP and dust skip remain (thin misses were net-protective, 0W/2L). Watch: wide-spread copies' realized slip on the dashboards — if mean slip degrades past ~+3%, revisit with a guard-anchored executable-ask check instead of a spread skip.

2026-07-17: bankroll top-up + USER DIRECTIVE — live mirrors paper EXACTLY

• User deposited +$44.14 (Cash App → BTC → bridge, 70241 sats; ~$6 lost to Cash App spread + BTC conversion — Polygon USDC is the cheap route). Book rebased: cash = chain $50.53, bankroll $22.28 → $66.42 = capital contributed (the deposit lives in bankroll_usd ONLY — first attempt also logged it as an adjustment, double-counting it: realized read −$44, ledger drift −$38.91; the invariant is cash = bank + Σadj + Σpnl + flows, so a deposit enters EXACTLY ONE term). Realized preserved at lifetime −$5.14; sizing is 4% of working equity (cash+cost basis) ≈ $2.45/bet — bankroll_usd is baseline/display only.
• USER DIRECTIVE (2026-07-16): the live bot mirrors the paper test EXACTLY. Caps were already off (retired 07-10). Parity sync applied: risk.max_price 0.95 → 0.99 (paper's), wallet floors synced to paper's current pins, dead follow.per_wallet_min_usd block removed (overwritten at load by wallets[] — it had gone stale). DELIBERATE exception: min_order_usd stays $1 (venue physical minimum; paper's $5 never binds at its equity — copying it would force $2.45 signals up to $5 = 8% of equity, DIVERGING from the 4% rule). NOTE: nothing auto-writes the live config — floors drift from paper's nightly sync until manually re-synced; check at each Friday bench review.
• Ops lesson (now README gotcha 15, third corollary): flyctl machine stop reported stopped while the process ran 25 more minutes — the rebase boot came up stale with ⚠ CASH≠CHAIN −$44.12 (alarm correct, money safe). A plain restart after the push landed picked everything up cleanly. Before state surgery: watch heartbeats actually CEASE.
• Docs sweep: README follow-set (Set E rev 4), chain-seed + FAK-parity + edge.py coverage, stale "tiny test caps" pointer fixed.

Operating boundary set by the user (2026-07-13, "away for a while")

Full autonomy on BOTH bots; real-money bot stays ARMED. Never touch the private key, never raise/loosen caps, never rotate the Discord webhook (needs their login — STILL OPEN). If something looks genuinely dangerous, DISARM the live bot (flyctl secrets unset LIVE_CONFIRM) rather than push through it.

Bench review 2026-07-16 (follow set rev 4: AIcAIc re-added, no bench promotions)

Forward table = portfolio.json resolved rows (model $-weighted), two windows: since 07-11 and since the 07-13 21:30Z swap. Verdict:

• NO promotion for Vahan88 (−21.6% / −30.5%) or EdwardIN (−11.1% / −8.9%) — both negative in both windows (EdwardIN ate two ~$1k Norway–England halftime props). Both stay benched in backtest.json.
• AIcAIc RE-ADDED (6th wallet, auto p80 floor): +25.6% since 07-11 and +21.9% across 11 bets since being dropped — spread across many LoL markets, not one hit. The Esports World Cup (its exact niche) runs through August; the 07-13 drop was made mid-bad-stretch, right as its season started. WHIPSAW RISK acknowledged: the drop and the re-add are both ~2-week-noise decisions; the tiebreaker is the seasonal catalyst + the informed-niche prior (June replay). If AIcAIc is negative again next Friday, it goes for good and the slot rule tightens.
• Kruto2027 stays (floor 80 pinned): inert (3 model bets, −12.8%) but an idle wallet costs nothing and its 30d +$3.5k says it's worth the seat.
• BikesAreTheBikes stays: −3.7%/−6.1% on n≤12 — too early to cut.
• LSB1 note: +21.4% post-swap (16 bets) but −7.5% on the longer window and −$438 all-time paper — NOT re-added; re-check next Friday.
• Guard/floor counterfactuals: re-validated 07-14 by the missed-bets audit (guard skips net-negative would-be on both books) — unchanged.
• BANKROLL decision instrumented (live/edge.py, in daily.sh + digest footer): parity-era per-signal paper edge vs the MEASURED live fee hurdle (1.9% of stake — real, not the 3-4% guess; extreme-price copies keep p(1−p) small) + matched live-paper drag (6.4pp @ $1 stakes). Decision rule: size up only when edge > hurdle+2pp on n≥30 parity-era resolved signals (~end of July). history/edge.csv accrues one row/day; python3 live/edge.py any time for the current verdict. RECOMMENDED to the user (2026-07-16, no decision yet): ~$30-50 coverage top-up now at most (the free-cash gate is skipping signals at $6 free), big sizing waits for the measurement; caps bind at ~$60-125 equity anyway and stay untouched. Deposits are the user's to make — never move funds.

Shipped since rev 12 (2026-07-15)

• PAPER FAK PARITY: PaperExecutor BUYs now model live FAK reality — if the depth gate's book snapshot (threaded through meta["book"], no second fetch) has no ask ≤ quote×1.05 (live.max_slippage_pct default), the paper "fill" is a rejection and the engine records the same "order rejected: no orders found to match" miss live logs. Rationale: post-chain-seed this is live's #1 miss class (10/33) and paper pretended to fill them (it "filled" the Claude Opus bet live's FAK couldn't) — biasing the live-vs-paper per-signal ratio (the top-up number) OPTIMISTIC. Chain-seed verdict after 41h: detection misses 23→3 live / 35→2 paper; the residual tail is no-trigger-at-all. Resting-limit fix for live FAK no-match evaluated and REJECTED for now: recent 10-row sample is −$0.97 would-be net + a resting bid is adversely selected (fills when price falls through it, not when we're right). Revisit only with paper-parity data showing real cost. Fail-open on dead book fetch; SELLs stay optimistic (exits need the retry/pending machinery to model honestly — out of scope). Live book unaffected (meta ignored). Tests: tests/test_paper_fak.py (8 paths); LedgerPaperExecutor no longer appends a fill row for a rejection. Deploy: paper app restart only. Expect paper misses like "order rejected: no orders found … (paper model: best ask 0.900 > cap 0.840)".

Shipped since rev 11 (2026-07-14)

• CHAIN SEED (T0b): the missed-bets review found the one remaining detection leak — RTDS doesn't emit every market (the "Credible public sale" sweep was missed on BOTH books at 20:18Z despite the rev-11 fix: RTDS silent + data-api indexer past the 600s window; badaf's detection misses are the only +EV ones, +$34.60/10 on paper). Now the Alchemy push carries its tx hashes into on_wallet_activity(hint_txs=…); any hash the data-api fetch didn't return is decoded straight from the receipt (fills_from_tx: OrderFilled logs, maker==wallet row; gamma lookup for title/outcome/cond; block ts). Validated 200/200 against shadow-ledger fills and end-to-end on the actual missed Credible txs. Fail-open on any RPC/gamma error (backstops unchanged); forged-event-safe (only the two new-stack exchange contracts 0xe111…996b / 0xe2222…0f59 are trusted emitters — a dust transfer can trigger the webhook, so this matters). Tests: tests/test_chainseed.py (6 stub paths). Both boxes have ALCHEMY_RPC_URL, so the path is live on deploy. Watch for the first chainseed: line — expected on badaf niche markets during RTDS flaps.
• Missed-bets audit verdict (what prompted this): price guard skips are net-NEGATIVE would-be P&L on both books (validated again — leave at 0.05); old detection misses were -EV and all from since-dropped wallets; conform/ sub-$1/sub-penny categories all fixed pre-rev-11. Remaining candidates NOT built: thin-book FAK no-match → resting limit via the pending registry (small now, scales with stakes), paper thin-book modeling parity (biases the live-vs-paper ratio optimistic).

Shipped since rev 10 (all deployed + verified)

• RTDS-seed lag fix (the big one): RTDS detected trades at ~0.3s but the copy landed 130-305s later — on_wallet_activity threw the RTDS payload away and re-fetched the data-api, whose indexer lagged that long on badaf/1kto1m crypto+index markets, so the 300s backstop poll did the copy. Now the RTDS message SEEDS the funnel directly (deduped by tx; re-fetch + fill-split merge still run). Verified live: first RTDS-era copy landed at 4s lag (heartbeat 24h lag 4s). This was "option B done as augmentation".
• Tick-conform protected prices: the sub-penny 4dp bound violated tick size on 1c books ('max_price must conform to tick size 0.01' — cost a winning SPX copy). Bound now rounds to the QUOTE's own precision (a quote is always a tick multiple → its decimals are the finest safe precision).
• Cursor cold-start: _fetch_since_cursor with no cursor now seeds at now-600s (fresh only). The bug walked 500 rows/wallet of history at the 02:10 boot → ~230 phantom "too slow (20,000m late)" missed rows/book; purged both books.
• Dashboard: exec-lag tile falls back to lifetime avg when the 24h window is empty; per-copy lag_s now renders in the Slip cell. /live verified.
• floor_pin + audit (3-agent clobber audit of every automated writer): sync_floors.py was silently reverting manual floors to p80 nightly (Kruto 80→125.61) — the paper book diverged from the live book. Fixed with a floor_pin field it honors; Kruto pinned 80 across paper+live+backtest. Audit also fixed: pin now really mirrors to backtest.json (comment lied), a loud warning when reverting an unpinned hand-edited floor, watch_sharps add/drop diff logging + generated-only doc, class_pct paper/backtest parity guard in daily.sh. Audit verdict: otherwise CLEAN — sync_floors is the ONLY pipeline step that mutates a manual-knob file, and it round-trips the whole JSON touching only floor; config.live.example.json is untouched by every automated writer (safe by neglect).

Known live quirk (not a bug): RTDS stream FLAPS

The undocumented RTDS socket drops a few times a day and hits the 60s reconnect-backoff cap; heartbeat shows ⚠ rtds down briefly then rtds up. Detection is covered by the Alchemy webhook (~3s) + 300s poll + the 120s silent-stale guard throughout. This is the layered-fallback design working. If it ever flaps CONSTANTLY, that's when to investigate (RTDS deprecation?).

Current state (2026-07-13 ~20:40Z)

• Live (wwf-copybot-live, ARMED): ~$16 equity, 32 copies, realized −$5.33 (day-1 incident still dominates), rtds up · userws up, books chain-exact. Follow set: Kruto2027(floor 80), 0xbadaf319, gkmgkldfmg, AIcAIc, 1kto1m.
• Paper (wwf-copybot): +$1,347 realized, 107 copies. Same 5 wallets.
• Backtest proves 11 (bench: Vahan88, 42021, BikesAreTheBikes, EdwardIN).
• Two persistent monitors were watching failure signatures this session (they end with the session — re-arm in the next one if desired).

Next-session priorities

1. Friday bench review: pull the per-wallet forward table for the 4 backtest candidates + re-read guard/floor counterfactuals; decide promotions and the bankroll top-up size (the live-vs-paper per-signal ratio is the number — now clean & comparable on both books).
2. Watch the exec-lag tile fall toward ~1-2s as RTDS-era copies replace the pre-RTDS average.
3. The protected-price/amount rounding (5 lines in copybot.py _order) has been the buggiest corner — 4 fixes now, each for a different quote class. Believed done (tests pin every class) but it's the first place to look if an ORDER FAILED: … conform/amount line appears.
4. User to-do still open: rotate the Discord webhook (their login).

Items 2-4 shipped (2026-07-13, evidence from a 3-agent analysis workflow)

• DEPTH GATE (copytrade.book_depth + gate in _handle_their_buy; config.depth_gate, both books). Fitted on 131 book-annotated fills: before ordering, SKIP if spread>0.08 (market mid-move, median |slip| ~14%) or ask5c<$50 (dust books mispriced every fill), else cap stake at 10% of 5c ask depth (impact <~2%; >20% of depth → >+2% slip 33-50% of the time). Fail-open on a book-fetch error. This is what lets stakes SCALE — binds mainly on slow-market wallets (badaf median 23% of depth at $40-100). 5 stub paths pass.
• PRICE GUARD validated, unchanged: counterfactuals put 0.05 exactly at the EV knee (0.05-0.10 moves ≈ breakeven, >0.10 = -20% ROI). Comment records it. The +9-14% slip tail is lag-drift in deep esports books — a detection problem RTDS ~1s already addresses, not a guard problem.
• clob_user OWN-FILL PUSH (UserFillsListener, live only): streams our order/trade lifecycle from ws-subscriptions-clob/ws/user (auth = client.credentials; all-markets). A matching order id fires an IMMEDIATE resolve_pendings() — in-play holds adopt on match, not on the 60s tick. Events only TRIGGER; get_order stays the arbiter (2026-07-12 invariant). resolve_pendings is now re-entrancy-locked (ws + heartbeat race). 60s poll stays as fallback; ws failure degrades to today. Heartbeat shows userws up. VERIFIED connected on the live box.
• Sub-$1 BUY fix: gated $1.00 stakes shaved to $0.99 by share-flooring → 7 of 13 live rejections. Now bumped to the $1 venue minimum.
• Follow-set (rev 9→10): 5 wallets live (dropped imwalkinghere, demoted LSB1; Kruto floor 80 pinned in backtest too for comparability). Backtest proves 11 (bench: Vahan88, 42021, BikesAreTheBikes, EdwardIN).

Since rev 8 (2026-07-11 → 07-13)

• RTDS shadow verdict: GO — 916 detections, p50 0.8s / p99 6.4s / max 9.9s (in-play emits within 10s). RTDS_DETECT=1 is live on the real-money bot; detections stream on both books; Alchemy + 300s poll remain backstops. Silent-stale guard force-reconnects a 120s-quiet socket (the stream once sat "up" delivering nothing for 35 min).
• Phantom-cash incident (+$7.86, book-only, alarms caught it): overlapping pendings on one token each read the same balance move — one real 1.48-share sell booked 3×. FIXED: order-size caps every adoption, balance-diff only when the exchange no longer answers, SELLs cap at book holdings, ONE pending per token (engine + retries refuse while the resolver owns a token). Book rebuilt from chain ($11.21, drift 0, poisoned bets corrected from real fills, residual −$0.08).
• No price floor (user call after a 0.001 longshot was blocked): risk.min_price 0 on both books, cap stays 0.95; executor protected prices now 4dp and price-proportional (2dp zeroed sub-penny bounds).
• H3 fixed: per-wallet trade cursor + paginated activity fetch (5×100, walks to the last processed ts) — bursts can't scroll past a page.
• clone-guard works now: verifies over git ls-remote (the REST API is unreachable from Fly boxes — Bearer 401 + anon rate-limit; it failed open on every boot until 07-13). Both boots log clone verified @ sha.
• preflight_live.py rewritten for the unified SDK (deposit wallet, pUSD, book access, RTDS stream, geo). Drift ALARM floor 1c→5c (penny rounding isn't a bug; the self-heal path keeps its threshold).
• Live book truth: 31 copies, realized −$5.32 lifetime (day-one incident dominates), ~$11.2 cash + LAB + 1 small open. User to-dos: polymarket.us key REVOKED, $32 RESOLVED; Discord webhook rotation still open.

RTDS shadow run (started 2026-07-10 22:26Z)

T0 detection is deployed: RtdsListener in copybot.py streams Polymarket's real-time trade socket (wss://ws-live-data.polymarket.com, topic activity/type trades — undocumented but official; probe measured median 0.8s delivery, ~45 msg/s peak firehose, zero drops in 45 min). Client-side Set E filter → the same on_wallet_activity funnel as the Alchemy push. Heartbeat shows rtds up Ns / ⚠ rtds down.

• Paper: ON by default — this IS the 24h shadow run. Compare rtds: detection lines vs Alchemy-path lag; watch the in-play tail (does RTDS emit held esports matches at match time or settlement?).
• Live: OFF until the shadow validates. Enable with flyctl secrets set RTDS_DETECT=1 -a wwf-copybot-live (restarts armed).
• Expected outcome: 24h lag stat drops toward ~1-2s and the "not copied in the detection window" misses go near-zero on paper.
• Phase 2 (researched, not built): RTDS clob_user topic streams OUR order lifecycle (auth: CLOB api creds) — would make the pending-order registry event-driven instead of 60s polling.

Retune (2026-07-10 ~21:20Z, USER-directed — supersedes the rule-0.6 caps)

• Hard caps RETIRED (user decision): risk block mirrors the paper sentinels. Sizing = paper-parity 4% of equity (class_pct 0.04/0.12), floored at the venue's $1 min order. Bankroll REBASED to the real $22.28 equity (heartbeat reads free $17/$22); spend tracker reset.
• Price guard is ABSOLUTE +0.05 (both books, identical rules): 0.14→0.15 follows, 0.14→0.20 skips. Key renamed price_guard_abs.
• Pending-order registry: in-play delayed holds are handed to state.pending_orders (full copy context) instead of a 20s cancel; the heartbeat resolver adopts fills whenever they land or cancels at TTL 600s → honest miss. Stub-tested (adopt + expire). Watch the first PENDING FILLED line in production.
• Both bots restarted on the new rules (paper +$1,378, 60 copies at reboot).
• GOTCHA REMINDER proven again today: a boot can clone a stale GitHub replica — the 17:18 boot ran pre-push config for 4h (harmless here); ALWAYS verify the first heartbeat shows the numbers you shipped.

INCIDENT 2026-07-10 (resolved in code; bot left DISARMED)

Push mode worked (~6s detection) — and exposed an executor bug: in-play markets accept orders with status delayed and ZERO matched at response time. The port read matched==0 as a rejection, logged an honest miss, and forgot the order — six such orders then filled at the exchange untracked (09:10–13:14Z, $30 real spend vs $5 booked; caps stopped binding; exits never mirrored; CASH≠CHAIN alarmed exactly as designed). Damage net ≈ −$2.7 (G2 g2/g3 and PlayTime g1 lost; Rune Eaters +$7.50 and Aurora g1 +$3.77 won, platform auto-redeemed; Aurora g2 won, redeem pending). First diagnosis wrongly blamed a second bot instance — the missed ledger's "order rejected: {'order_id': …}" rows matching on-chain fills to the second settled it: it was THIS bot.

Fix (copybot.py, unit-tested with a stub client, 5 paths): the executor invariant is now no order outlives _order() untracked — zero-matched acceptances poll get_order, cancel the remainder, and measure truth via the exchange's CONDITIONAL balance diff; exception paths sweep all open orders on the token the same way. State surgery done disarmed: cash = chain ($10.03), six fills adopted as bets, spend tracker = the real $35 today (over cap → a re-arm today places nothing new), false miss rows purged, −$0.59 adjustment documented.

DISARMED via flyctl secrets unset LIVE_CONFIRM (survives restarts — note machine stop does NOT: http_service auto-restarts the machine). Re-arm = user types flyctl secrets set LIVE_CONFIRM="TRADE LIVE" after reviewing the fix. Recommended: re-run a probe on an IN-PLAY market first.

Self-contained pickup for a fresh session (human or AI). Read README.md gotchas 1–16 (16 is the new-stack one), FINDINGS.md, ETHERSCAN_MIGRATION.md, LIVE_ROLLOUT.md. The repo is authoritative.

THE CRITICAL PATH IS DONE (2026-07-10 05:08Z)

Every link from rev 4 closed, in order, all proven on the live box:

1. Root cause of the wrap revert found on-chain (not caller-gating): the pUSD CollateralToken accepts BOTH native USDC and USDC.e by contract, but the public CollateralOnramp 0x93070a… has native USDC paused (paused(0x3c499c…)=1). Docs claiming "must be USDC.e" are downstream of that pause, and the ts-sdk has NO wrap helper — the UI converts via the Bridge.
2. Bankroll converted via the sanctioned path (host/wrap_via_bridge.py, stage-gated $3 test slice first): gasless ERC-20 transfer → per-wallet bridge address (POST bridge.polymarket.com/deposit) → delivered back already wrapped as pUSD, fee-free ($24.73 in → $24.73 pUSD out). get_balance_allowance(COLLATERAL) = 24730000 with max-uint allowances.
3. Executor ported (copybot.py LedgerLiveExecutor): unified SDK SecureClient.create(private_key) — deposit wallet auto-resolves, no api_key at runtime; place_market_order FAK with protected prices (quoted ± live.max_slippage_pct, default 5%, clamped [0.01,0.99] so the SDK's band check can't raise); never raises into the trade loop. chain_cash_gap repointed at the deposit wallet's pUSD (the +24.73 alarm is gone). Old tick-rounding machinery deleted — the SDK owns tick/negrisk.
4. $5 FAK round trip FILLED on the new image (polymarket-client==0.1.0b16 in fly.Dockerfile): BUY matched 7.35294 sh @ 0.68 ($5.00), SELL matched 7.35 sh @ 0.67 ($4.92 gross). Fill-field semantics confirmed: BUY making=USD given / taking=shares got; SELL reversed. Round trip cost 23.7¢ = 1c spread + ~3.2% taker fee on the sell + 0.003 sh dust — the modeled TAKER_FEE_RATE 0.03 tracks reality.
5. Armed bot restarted on the ported code: geo TRADABLE, LIVE banner, baseline clean, heartbeat [1] open 0 · free $25/$25 with NO drift/chain alarm. The bot can now actually place.

THE ONE REMAINING STEP — first organic fill ⇒ Phase 4

When the first real copy fills, walk LIVE_ROLLOUT Phase 4 and report every link: order id → fills ledger row → position visible in the Polymarket UI (the DEPOSIT WALLET 0x455e252e45Ee46d6C4cc1c8fAdD3899d68f245a1, not the legacy proxy) → /live feed row → cash math → Polygonscan.

PUSH MODE (added 2026-07-10 05:41Z — user wanted push-speed detection)

The live app now runs its OWN Alchemy address-activity webhook (wh_98s36kdtcaf9t9xx → https://wwf-copybot-live.fly.dev/alchemy, 7 Set E addresses, id also in gitignored config.json as alchemy_webhook_id_live) — fully separate from the paper app's webhook; the two books still share nothing. Detection ~3s vs the poll era's ~39s avg. Verified: boot banner push mode · signature-verify ON · heartbeat 60s · backstop poll 300s, public /health "alive", Fly health check passing, unsigned POST → 401. Remaining soft link: the first REAL Alchemy push accepted (a key mismatch would print ⚠ bad signature — rejected on every Set E trade — watch for that; the 5-min backstop poll covers detection meanwhile).

• live/sync_webhook.py now syncs BOTH webhooks on every deploy_bot.sh run.
• The live app has its watchdog now: Fly /health check (self-heal) + watchdog.yml probes both apps → Discord (notify). A DISARMED live app idles WITHOUT HTTP — its watchdog page is expected, not a fault.
• start.sh live role: ALCHEMY_SIGNING_KEY present → push, absent → 60s poll fallback (so flyctl secrets unset ALCHEMY_SIGNING_KEY is the way back).
• Cosmetic: on restarts the push server exits with a KeyboardInterrupt traceback in the logs (SIGINT path) — harmless, not a crash.

Known small offsets (do NOT fix while the bot runs — gotcha 15)

• Book cash $25.00 vs chain pUSD $24.49: fixed $0.51 offset (config bankroll $25 vs $24.73 deposited, + the probe's 23.7¢ round trip which correctly bypassed the book). Below the $1 CASH≠CHAIN alarm. Fold into the state at the next natural machine-stop surgery if desired.
• The probe's trade is deliberately absent from the fills ledger/feed.

System state (2026-07-10 05:10Z)

• Live bot (wwf-copybot-live, poll 60s, arn): ARMED, $24.49 pUSD, caps $5/trade · $25/day · $30 exposure — NEVER raise without the user. Disarm: flyctl secrets unset LIVE_CONFIRM or flyctl apps stop.
• Paper bot (wwf-copybot, push mode): Set E, $1,000 book of 2026-07-08 — Day 1½ realized +$1,107.57 (36 copies) at rev-4 time; check the dashboard for current.
• Set E both books: LSB1, imwalkinghere, Kruto2027, 0xbadaf319, gkmgkldfmg, AIcAIc, 1kto1m (watch list & demotion candidates in rev 4 / FINDINGS).
• Dashboards: jaxperro.com/trading (paper), jaxperro.com/live (real).
• Ops utilities (all need the box's env): host/wrap_via_bridge.py (bankroll conversion — done, idempotent), host/order_probe_v2.py ($5 round-trip probe; now polls the indexer and self-revokes its builder key), host/flatten_positions.py (market-sell everything — the emergency exit).

New-stack facts a future session must not relearn (also gotcha 16)

• py-clob-client: ARCHIVED. Reads OK, placement dead everywhere.
• polymarket-client (SecureClient): placement, gasless execute_transaction, get_balance_allowance (.balance int base units). create() is ready-to-use; with only closes transports.
• Protected prices (max_price/min_price) raise outside [tick, 1−tick]; we clamp to [0.01, 0.99] before calling.
• Builder API keys: revocable ONLY via their own secret (HMAC DELETE) — always atexit-revoke in-process keys. 9 inert ones from bring-up sit on the account; only the UI (settings→builder) can clear them. Runtime bot needs NO key (approvals persist on-chain).
• Bridge: POST /deposit {address} → per-wallet EVM address (ours: 0x66C1A4b43824CB0DDa54c94F118fc868A6270b91, pinned in wrap_via_bridge.py); Polygon native USDC accepted ($2 min); delivery is pUSD directly; /status/{bridge_addr} tracks; /quote previews.

Queued work (unchanged priorities)

1. ETHERSCAN_MIGRATION.md phases 0→5.
2. Empirical fill model from book snapshots; depth gate before sizing up.
3. Funding-cluster tracer port to Etherscan logs.
4. Live-app watchdog (poll mode has no /health).
5. Decide the leftover $32 on polymarket.us (withdraw or abandon).
6. preflight_live.py still validates the ARCHIVED stack — port or retire.

User to-dos (security/hygiene)

• Revoke the polymarket.us API key DONE (user, 2026-07-10).
• Decide the leftover $32 on polymarket.us RESOLVED (user moved it, 2026-07-10).
• Rotate the Discord webhook committed pre-2026-07-09 (spam risk only) — STILL OPEN.
• Optional: clear the 9 inert builder keys at polymarket.com/settings?tab=builder.

Hardening trio (2026-07-10 late — all stub-tested)

• Exit-retry (LIVE_ROLLOUT 1.6 built): failed mirror-exits queue in state.exit_retries; the heartbeat re-attempts up to 10 ticks (recovered exits ping Discord), then pages ⚠ EXIT STUCK and lets the position ride knowingly. In-play holds hand off to the pending registry.
• RTDS shadow ledger: every Set E detection appends to rtds_shadow.jsonl (live: rtds_shadow.live.jsonl) — ts, lat_s, and whether another trigger saw the tx first. Rides the publish commit; capped ~2000 lines. This file is the 24h go/no-go data for RTDS_DETECT=1.
• Boot stale-clone guard (start.sh): clone HEAD verified against the GitHub API (re-clone up to 4×) — kills the stale-replica boots that hit twice on 2026-07-10.

Operational quick-reference

• Follow-set change: edit live/copybot.paper.json → ./live/deploy_bot.sh; keep backtest.json mirrored.
• State surgery: flyctl machine stop FIRST → edit → push → restart → VERIFY first heartbeat (gotcha 15).
• Never 2 Fly machines per app (flyctl scale count 1).
• Bot commits its own state — git pull --rebase --autostash before pushing.
• Image changes (fly.Dockerfile, host/) → flyctl deploy --remote-only -c fly.live.toml -a wwf-copybot-live; code/config → push + flyctl apps restart (a deploy also wipes /tmp clones on the box).
• Box one-offs: flyctl ssh console -a wwf-copybot-live -C "bash -c '…'"; clone to /tmp with the box's GITHUB_TOKEN; run python with -u.