# Third Window pre-registration log (APPEND ONLY)

Rules:
- One line per test, written BEFORE you open half B. Never edit or delete a line; a change is a new line that names the old one.
- Format: `time_bkk | owner | test id | rule | label | exit | kill bar (what result kills it)`
- The DC Auditor checks every result against its line. No line, no edge.
- Owners append through their own route; if two people publish at once, the later one re-reads and re-appends.

## Lines
- 7 Oct 10:30 | Supervisor | DC0 baseline | buy every T1 coin (sellable $250k + 100 unique buyers, skip list applied) at trigger, $100 ticket | honest 7 d outcome | 0.3x stop with pull detection, sell at 5x, 7 d cap | baseline is the bar every module must beat, not an edge itself
- 7 Oct 10:40 | Supervisor | DC0 v2 (replaces DC0) | buy every T4 survivor coin at the T4 time, $100 ticket, public router sells only, one per cluster per day | 3x within 48 h + path $ | sell at 3x or 48 h, pull = 0 | baseline bar for Lane D modules
- 7 Oct 10:20 | A2 | DC2.1 (record) | 17 chain features x 4 checkpoints on T1 (v4, 21 Sep to 4 Oct), one cut per feature chosen on A, greedy 2 to 3 feature rule on A | Y5 = sellable 5x from entry within 7 d; Y1M = cap at +24 h >= $1M | sell at 5x, pull = 0, else 7 d | list was in dc-a2-1-chain.md v0 (server time 10:04:53, md5 5e78ae05514c2d42477107a90aa15016) BEFORE results; this line is late because the file did not exist yet. Kill bar: no feature wins both halves at a 30 s delay
- 7 Oct 10:20 | A2 | DC2.1-F forward | at T1 (sellable $250k + 100 unique buyers): close / high <= 0.784 AND alumni share of buyers >= 0.053 (alumni = first 30 min buyers of an earlier coin that later hit a sellable $1M, past only); buy the first trade 30 s or more after T1 | Y5 from the entry trade | sell at 5x, pull = 0, else 7 d; $100 and $1,000 tickets at pool depth | KILL if after 14 forward days: $/day <= 0 at $100, OR beats random < 95%, OR fewer than 10 hits
- 7 Oct 10:22 | A2 | Q2 who can pull | T1 coins (v4, 21 Sep to 4 Oct, same 612 as DC2.1). LP control at the trigger block, from liqlock liq + nft: class BURN (every PositionManager LP NFT sent to 0x0 or 0x000000000000000000000000000000000000dead), CREATOR (an NFT held by the creator wallet), EOA (held by another plain wallet), CONTRACT (held by a contract, or liquidity added by a non-PositionManager contract) | label 1: LP pulled within 24 h of trigger; label 2: Y5 from the entry | entry = first trade 30 s or more after T1; sell at 5x, pull = 0, else 7 d; $100 and $1,000 | KILL if no class differs from the rest by 15+ points of 24 h pull rate in BOTH halves, or if skipping the worst class does not raise $/day in BOTH halves
- 7 Oct 10:20 | A3 | DC3.1 (record) | X (CA or $TICKER, xsafe real, 3+ likes and all posts), DexScreener paid time, GeckoTerminal project links on T1 v4 sample 150 (15 Sep to 4 Oct), one cut per feature on A | Y5 from trigger (7 d peak / trigger cap) and 3x | +$400 at 5x, else -$75 | list was in dc-a3-1-social.md v0 (md5 a91b867170fd1356eab4b127fd810b8f) BEFORE any X call; this line is late because this file did not exist yet. Result: all DEAD except the all-posts author lead (one half only)
- 7 Oct 10:40 | A3 | Q4 X authors on survivors | coins: T4 survivors (crossed sellable $250k, main pool not pulled by +6 h; provisional from dc-a1-1-universe until DC1.2 lands), any venue, crossing 30 Sep to 5 Oct only (X shows all posts for ~7 days). Features from dc-a3-xrecipe.py (all posts, no like filter): auth, fol, big at T4 = cross + 2 h and at cross + 6 h, plus slope = auth added in (+2 h, +6 h]. One cut per feature from {>0, top half, top quarter} chosen on half A = 30 Sep to 2 Oct, tested on half B = 3 to 5 Oct | 3x within 48 h from the decision time (DC0 v2 label) | DC0 v2: sell at 3x or 48 h, pull = 0, $100 | KILL if auth AUC < 0.60 in either half, OR the A cut does not beat DC0 v2 $/day in B, OR beats random < 95% in B
- 7 Oct 10:50 | A3 | DC3.2 forward X authors (replaces nothing; forward twin of the DC3.1 lead) | rule: real authors >= 2 by the decision time, counted with dc-a3-xrecipe.py on PP's live saved posts (DCPP.4, all posts, no like filter): lane T1 decision = trigger + 1 h; lane D decision = the DC1.2 T4 time | 3x within 48 h from the decision (DC0 v2 label) | DC0 v2: sell at 3x or 48 h, pull = 0, $100 at pool depth | KILL after 14 forward days if, in a lane: authors AUC < 0.60, OR the rule $/day <= that lane's buy-all baseline, OR beats random < 95%, OR fewer than 10 hits. Halves = forward days 1 to 7 / 8 to 14
- 7 Oct 10:35 | A2 | DC2.1-F2 (replaces DC2.1-F) | look AT T1 (data up to the trigger swap only): price at T1 / high so far <= 0.784 AND alumni share >= 0.053; fill = first trade 30 s or more after T1 (covers the 20.9 s live fill); one trade per crew per day | Y5 from the fill price | sell at 5x, pull = 0, 48 h cap; $100 and $1,000 at depth | same kill bar as DC2.1-F (14 forward days: $/day <= 0 at $100, or beats random < 95%, or < 10 hits)
- 7 Oct 10:35 | A2 | DC2.2 exits on Lane F | coins = DC2.1-F2 picks, 21 Sep to 3 Oct (48 h covered by data). Exits, each tested alone: X5 sell at 5x; X3 at 3x; X2 at 2x; T15 = 3x or the first trade 15 min after the fill, whichever first; PS = 5x, or the first trade after the first LP removal event (liqlock liq kind pull), whichever first. Pull = 0 in all. Exit price = first $100+ sell at or above the target (router check pending PP DCPP.3) | path $ per day, 3x label | best exit picked on A only | KILL if no exit beats X5 in $/day in BOTH halves; one trade per crew per day
- 7 Oct 10:50 | A2 | DC2.3 Lane D hold book | universe: v4 coins launched 21 Sep to 3 Oct that reach a sellable $250k (launch file ts_250000), LP control at that block NOT creator-held (CONTRACT, BURN, or plain non-creator wallet; method of Q2); skip list (campaign 5059_7adb2ec7, junk 25533_3080c1dd, bundle 341_6de2bb44) applied; entry = first trade 5 min or more after the crossing (deep check time), also reported at 30 s | label: 3x from entry within 48 h; path $ | exits each alone: X3, X5, X10, TR50 (sell when price falls 50% from its peak since entry, after at least 1.5x), CAP48 (hold 48 h), CAP7D (hold 7 d, report only where covered); pull = 0; $100 and $1,000 at depth; one trade per ticker, creator and funder root per day; half A 21 to 27 Sep, half B 28 Sep to 3 Oct | best exit picked on A only. Then features chosen on A: funder root record before entry (coins, pulls, 5x+), operator bundle share of buy ETH up to entry (wallets funded by the creator, its root, or disperse 0x84157d3d24630c297849c84d49ae7f1805c1b60f / 0x03802649e469ed5680c58dff9e65425e22d21cc5), outside net buy ETH up to entry ÷ cap | KILL if the best A exit loses money in B at $100, or no feature cut chosen on A adds $/day in B
- 7 Oct 11:00 | A1 | DC1.2 T4 survivor baseline | universe = DC1.1 coins (v4 day files + v3 WETH + Pons graduations, first trade 15 Sep to 5 Oct, one pool per coin). Cross = first sellable event (a $100+ sell; public router check not possible on history, all routers counted until PP DCPP.3) at cap >= L. Variants: T4-2h (L=$250k, pool not pulled by cross + 2 h, decide at cross + 2 h); T4-6h (same, + 6 h); T4-LOCK (v4 LP at the cross block all burned, or no LP NFT held by the creator: decide at cross); T4-PONS (Pons graduated pool, venue pons_grad or v4 hook 0xe5e702641ea86f4ae6cc3cdaed2b886f976be044: decide at cross); widen only if a variant has < 10 winners per half: T4-2h-100k (L=$100k) and T4-1h (L=$250k, + 1 h); T3 (coin older than 24 h, first clock hour with $50k+ volume after 24 h under $50k, decide at the $50k mark). Entry = first trade at or after the decision time, $100 at pool depth, 1% fee each side. One trade per cluster (same symbol, creator or crew root) per Bangkok day, earliest kept. Coins whose entry + 48 h is past their venue's data end are dropped | label = sellable 3x from entry within 48 h before any pull | DC0 v2: sell at the first sellable 3x, else last price at 48 h, pull = 0 | halves A = entry 15 to 28 Sep, B = 29 Sep to 5 Oct; report coins a day, winners per half, $ a day per half, and $ from entries made before the coin's first sellable $1M (new $) | KILL a variant as a Lane D base if $/day <= 0 in either half or < 10 winners in either half (then the wider variant is reported, same rules)
- 7 Oct 10:59 | A1 | DC1.2 time fix (names the line "7 Oct 11:00 | A1 | DC1.2") | that line was appended at 10:52 Bangkok real time (my clock slip wrote 11:00); content unchanged, written before any DC1.2 result
- 7 Oct 11:01 | A1 | DC1.1-V3F forward (hypothesis from DC1.1, post hoc, not tuned further) | v3 WETH pools only (not v4, not Pons): T1 = first sellable event (a $100+ sell) at cap >= $500k with >= 200 buy swaps since the first trade; buy the first trade >= 15 min after T1 if price >= 70% of the sellable high so far and the pool is not pulled; $100 at pool depth, 1% fee each side; one trade per cluster per day | Y5 (sellable 5x from entry) and 3x within 48 h for reporting | 0.3x stop, sell at sellable 5x, pull = 0, 7 d cap | KILL after 14 forward days if: $/day <= 0 in either 7 day half, OR beats a random entry minute (same triggered coins, entry uniform in T1 to T1 + 2 h) < 95%, OR fewer than 10 trades. Overlap with the Second Window v3 $1M gate reported per trade (Auditor)
- 7 Oct 11:01 | A1 | Q-FLOAT | coins: pp3 cross level $500k (all venues, transfers in /opt/sw/pp3_raw.db, c10k excluded by PP), cross 15 Sep to 5 Oct, pool not pulled by D = cross + 1 h (pp3 series lp_removed_share < 0.5). Insiders = creator + every wallet receiving the token in the first 30 blocks after the first market transfer + any wallet receiving the token by a direct transfer from an insider before D. Market side = pool, PoolManager and the router/hub list in pp3_series.py. F1 = insider share of non-market holdings at D; F2 = outside (non-insider) net buy $ from cross to D (tokens from market minus tokens to market, priced at the pp3 series cap of that 10 min slot). Cuts chosen on half A only: F1 in {below median, bottom quarter}, F2 in {> 0, top half}, and F1 below median AND F2 > 0 | DC0 v2 label: sellable 3x within 48 h from the first trade at or after D | sell at 3x or 48 h, pull = 0, $100 at depth, one per cluster per day; baseline = buy all qualifying coins at D | halves A = cross 15 to 28 Sep, B = 29 Sep to 5 Oct | KILL if the A-chosen cut does not beat the buy-all baseline $/day in B, OR beats random same-size picks < 95% in B, OR < 10 winners in either half (then report "too small")
- 7 Oct 11:01 | A2 | KILL DC2.1-F and DC2.1-F2 (Lane F) and void DC2.2 | cause: the T1 trigger mixed launch-file times with chain time, so 75% of triggers fired below a sellable $250k; on a chain-only trigger the rule has 1 hit in 16 trades | see dc-a2-1-chain.md v4 | DC2.3 runs on the chain-only clock
- 7 Oct 11:10 | A5 | AN5.1 exit map | coins: engine tape (PP wash.db v4, 21 Sep to 5 Oct), three universes: C250 = chain clock first $100+ sell at cap >= $250k (TW_T250=tape, A2 v4 fix); T1c = C250 + 100 unique buyer wallets; T4c = C250 + 2 h, pool not pulled AND a $100+ sell at cap >= $250k in the hour before the check (Auditor Q2 "still sellable"); skip list (campaign 5059_7adb2ec7, junk 25533_3080c1dd) applied; entry = first swap 30 s or more after the decision, engine twtest v1.1 fills (depth from last 30 swaps, pool fee each way, dynamic fee 1%) | path $ per trade and $ a day, 3x label for reporting | exits each alone, all with pull = 0 and 48 h cap: price X3, X5, T15 (3x or first swap 15 min after fill), TR50 (after 1.5x, sell at 50% off the peak since entry), H48; seller exits (each = sell at 5x OR the signal, signal exit at the next swap): CR (creator wallet sells $100+), INS10/INS25/INS50 (insiders = creator + wallets that bought in the first 120 s of trading; their summed sells since entry reach 10/25/50% of their net stack at entry), NET5/NET15 (outside net buy ETH = non insider buys minus all sells over the last 5/15 min turns negative, checked from 5/15 min after fill), LP (first liqlock removal of any size on the pool); $100 and $1,000; one trade per cluster per day (engine dedupe) | best exit per universe picked on half A (before 28 Sep) by $/day at $100 | KILL a seller exit if, in half B, it does not beat X5 AND X3 $/day at $100, OR beats a random exit (same trades, hold times shuffled across trades, 2,000 draws) < 95%. Limits stated up front: 51% of swaps have no wallet (insider sells half seen), tape ends at the pull or ~30 h (trunc counted), v3 and Pons not on this tape (v3 lane stays forward only)
- 7 Oct 11:14 | A4 | AN4.1 winner anatomy | winners W = DC1.1 universe rows with honest5x = 1 (765; v4 462, v3 274, Pons 29), plus a 20x flag (best_1k_mult >= 20). Leg start L = scan A1 events from the first sellable $100k, before pull: keep the running lowest $1k buy cost; L = that running low at the first sellable event where a $1k buy from it nets >= 5x (A1 honest5x math). Control C = coins with honest5x = 0; candidate points = events after the first sellable $100k, before pull, within 7 d of launch, whose buy cost is not beaten in the next 24 h (or to pull or data end) = a hindsight low, same selection as L. Match each W to up to 3 C coins (one point each, no reuse, seed 7) on venue group (v4 | v3 + Pons), age bucket (log2 hours since first trade) and cap bucket (log2 cap at the point). Features read only from data before the point (no look ahead): age, cap, pool depth R and R/cap, cap / sellable high so far, minutes since that high, prior sellable high (had $1M before?), 1 h and 6 h buy $, sell $, net $ (and / cap), buy count, volume / cap, hook family, creator and funder root past coins / past honest5x / past pull share (only coins launched before), LP holder class at L (v4, A2 Q2 method), unique wallets and new-wallet share in the prior 1 h and operator (root or disperse funded) share of prior 1 h buys where wash.db / v3 signers cover it, X authors only where saved posts exist. | label = W vs C at a matched hindsight low | no exit (anatomy); continuous features get one cut chosen on half A (L or point time 15 to 28 Sep) at the C quartiles, held fixed for half B (29 Sep to 5 Oct) | keep a fact only if lift (W share / C share) >= 1.5 in BOTH halves, W coverage >= 20% and >= 10 W per half; top 3 by min(lift A, lift B) go to the Engine as rules with their own prereg line. Limits stated up front: no public router filter (DCPP.3), v4 pulls unseen after 5 Oct 17:39, hindsight-low points use future data for SELECTION only, so a kept fact is a hypothesis for the Engine, not a tradable edge.
- 7 Oct 11:22 | A1 | T4-ALIVE | universe = DC1.2 T4-2h coins (sellable $250k crossed, pool not pulled by cross + 2 h; v4 day files + v3 WETH + Pons graduations, 15 Sep to 5 Oct, chain clock only). Decide at cross + 2 h: BUY only if (a) the last price before the decision >= 50% of the sellable high so far AND (b) net buy $ (all buys minus all sells, every wallet, from the pool's own swaps or 1 minute bars) in the hour before the decision > 0. Wallet split not used: transfers exist only for $500k crossers (Q-FLOAT covers that) | DC0 v2 label: sellable 3x within 48 h from entry | entry = first trade at or after the decision, $100 at depth, 1% fee each side; sell at 3x or 48 h (last sellable price), pull = 0; one trade per cluster per Bangkok day | halves A = entry 15 to 28 Sep, B = 29 Sep to 5 Oct | KILL if $/day <= 0 in either half, OR < 10 winners in either half, OR beats random same-size draws from the T4-2h B trades < 95%
- 7 Oct 11:14 | A1 | T4-ALIVE time fix (names the line "7 Oct 11:22 | A1 | T4-ALIVE") | appended at 11:13 Bangkok real time; content unchanged, written before any T4-ALIVE result
- 7 Oct 11:14 | A2 | DC2.4 operator float on non-pullable coins (phase 1: v4) | universe: v4 coins launched 21 Sep to 3 Oct, chain-clock crossing of a sellable $100k OR $250k (two runs), LP at that block BURN or held by locker 0x267444d099b10fb5ed7c3cc7b7c767adca574952 / 0xeff166aaf189323c58dc27ed1206eb2c37faacdf (0xd0fd42bd8374ac659d3d81242d032211c2481055 counts as pullable); skip list applied; entry = first trade 5 min after the crossing | features: OPF = operator share of net tokens held by all swap wallets at entry (operator = creator, wallets first funded by the creator or its funder root, or by disperse 0x84157d3d24630c297849c84d49ae7f1805c1b60f / 0x03802649e469ed5680c58dff9e65425e22d21cc5); OPS = operator net sell ETH in the first hour after entry / cap in ETH (known only at +1 h, so its trade enters at +1 h) | label: 3x from entry within 48 h; path $ with exit TR50 (best Lane D exit on A) and X3 | cut chosen on A, tested on B; one trade per ticker/creator/root per day | KILL if no cut beats the universe in $/day in BOTH halves, or fewer than 10 hits per half (then say too small, and phase 2 adds Pons graduated pools)
- 7 Oct 11:19 | A5 | AN5.3 exit map with no pull | coins: v4 coins whose LP cannot be pulled at the crossing, taken from A2's tables (one ruler with A2): NP = LP held by locker 0x267444d099b10fb5ed7c3cc7b7c767adca574952 or 0xeff166aaf189323c58dc27ed1206eb2c37faacdf, or burned to 0x000000000000000000000000000000000000dead (dc-a2-4-laned + dc-a2-5-float); NP+ = NP plus A2's other non-creator holders EXCEPT 0xd0fd42bd8374ac659d3d81242d032211c2481055 (pulls all its coins). Levels: chain clock first $100+ sell at cap >= $250k (main) and >= $100k (wider). Entry first swap 30 s after the crossing (main, A2 csv) and 5 min (check). Skip list as AN5.1. One trade per ticker, creator and funder root per day | path $ per trade and $ a day, 3x label for reporting | exits each alone, pull = 0, 48 h cap: X3, X5, X10, T15, TR50, H48, CR, INS10, INS25, INS50, NET5, NET15 (as AN5.1, seller exits = 5x OR signal), plus TRI10 (TR50 OR INS10) and TRN15 (TR50 OR NET15); $100 and $1,000; twtest v1.1 fills | best exit picked on half A (21 to 27 Sep) at $100 | KILL a seller exit if in half B it does not beat TR50 (A2's best) AND X3 at $100, OR beats random exit < 95%; "too small" if fewer than 10 3x hits per half. Forward only line carried: AN5.1 lead T4 NET5 (5x or outside net buy < 0 over 5 min) on the Coder shadow book, KILL after 14 forward days if $/day <= T15 or beats random < 95%
- 7 Oct 11:28 | A4 | E-AN4-1 (from AN4.1 fact 1, for the Engine) | any venue, coin age <= 1 h, a sellable $100k already printed, pool not pulled; fire at the first trade where price <= 0.88 x sellable high so far AND net buy (buy $ minus sell $) in the last 15 min >= 0.25 x cap; one trade per cluster (symbol, creator or funder root) per day | 3x within 48 h from the fill, plus path $ | $100 at depth, 1% fee each side, sell at 3x or 48 h, pull = 0 | KILL if $ a day <= 0 in either half, or beats random entries on the same coins < 95%, or < 10 winners per half
- 7 Oct 11:28 | A4 | E-AN4-2 (Lane D, from AN4.1 late-leg fact) | any venue, coin age >= 1 h, a sellable $100k already printed, pool not pulled; fire at the first trade where price <= 0.88 x sellable high so far AND net buy in the last 6 h >= 0.25 x cap; one trade per cluster per day | same label | same exit | same kill bar (expect too few winners: report "too small" if < 10 per half)
- 7 Oct 11:28 | A4 | E-AN4-3 (v3, from AN4.1 v3 fact) | v3 WETH or Pons graduated pools, age <= 1 h, sellable $100k printed, not pulled; fire at the first trade where price <= 0.88 x sellable high so far AND buy $ in the last 1 h >= $250k; one trade per cluster per day; report overlap with Second Window v3 trades | same label | same exit | same kill bar
- 7 Oct 11:30 | A1 | Q5 overlays on Second Window wide trades | positions = the 70 public SW wide trades (sw-a2-16-wide-trades.csv: token, pool, entry, exit, x at $500, stop 0.3), chain clock only; kit labels from sw-a2-24-kits.csv. Bundle = creator + first-30-block receivers + their direct transfers (Q-FLOAT definition), from pp3_raw transfers. (a) SELL-NOW: at entry + 15 min, + 1 h, + 4 h, if the position is still open, sell at the first sellable print when bundle net sells since entry >= 10% of the bundle's holdings at entry AND bundle share at the check >= 50%. (b) HOLD-PAST (non-kit trades that exit at the 5x target only; kit coins are already held live): instead of selling at 5x, hold with a 50% trail from the sellable peak, pull = 0, 48 h cap, only if bundle net sells since entry <= 0 AND outside net buy in the last hour > 0; otherwise keep SW's 5x exit. LP holder class (lever 1) is added as a separate line when Data DA.1 lands | score = $ added vs SW's actual exit per trade at $500, halves as in the file (A / B) | (a) and (b) scored separately | KILL an overlay if $ added <= 0 in either half, OR it beats random < 95% (a: same number of sells at random check times on the same open trades; b: same number of random non-kit 5x trades held), OR it fires on fewer than 5 trades per half (then "too small"). A perfect-foresight ceiling (best possible sell-now and hold-past $) is reported first as context, not as a test
- 7 Oct 11:26 | A1 | Q5 time fix (names the line "7 Oct 11:30 | A1 | Q5 overlays") | appended at 11:26 Bangkok real time; content unchanged, before any Q5 result. From now on every A1 stamp is taken from the server clock (date), never typed
- 7 Oct 11:44 | A4 | E-AN4-4 (operator record, from AN4.1 v2; the half A to half B check was run before this line, so the Engine must test on data AFTER 5 Oct, or on a rolling 14 day record with no overlap) | v4 coins; root = crew.db launch.root; record = coins of that root launched in the 14 days before this coin's first trade, honest 5x label as DC1.1, only coins whose 48 h window closed before this coin's first trade; fire if record has >= 5 coins and honest 5x share >= 25%; buy $100 at the first sellable $100k print; one trade per root per day NOT applied (the root is the signal), report per-root P&L | 3x within 48 h, plus path $ | sell at 3x, or at the first trade after any LP removal by the creator, or 48 h; pull = 0 | KILL if forward $ a day <= 0 over 7 days, or one root makes > 60% of the P&L
- 7 Oct 11:41 | A4 | E-AN4-4 time fix (names the line "7 Oct 11:44 | A4 | E-AN4-4") | that line was appended at about 11:38 Bangkok real time (typed time slip); content unchanged
- 7 Oct 11:55 | A3 | DC3.4 community / product as HOLD | coins: PP pp3.db crossings at $500k and $1M (pp3 has no $250k level; chain clock t_cross), v4 + v3, cross 13 Sep to 5 Oct, pool still standing at cross + 1 h (series lp_removed_share < 0.5 at slot 6); decision at cross + 1 h; one row per pool per level. Half A = cross 13 to 26 Sep, half B = 27 Sep to 5 Oct. Features at cross + 1 h only: F1 outside holders = wallets holding the token at +1 h (pp3_raw Transfer logs) whose first funder (ffund_snap) is NOT the creator, the creator's funder, 0x84157d3d24630c297849c84d49ae7f1805c1b60f or 0x03802649e469ed5680c58dff9e65425e22d21cc5, and that are not first-30-block receivers: count, and slope = count added (+10 min, +1 h]; F1b series holders slope (+10 min to +1 h); F3 own token bytecode > 10 kB (eth_getCode) and site publishes the full own contract (site from GeckoTerminal / lanes.db, fetched once); F4 category tag (lanes.db, only coins launched from 4 Oct: descriptive only). X authors are NOT in this test (no saved posts for old coins; forward line DC3.2 covers it). One cut per feature from {>0, top half, top quarter} (binary features as is), picked on A | L24 = cap at +24 h >= 50% of cross cap and no pull; L48 same at +48 h; L3 = cap >= 3x cross cap between +1 h and +48 h before any pull | hold from the +1 h cap: sell at 3x or 48 h, pull = 0, $100, cap-based (no fill model; marked approximate) | KILL a feature if L24 AUC < 0.60 in either half, OR the flagged coins' hold $/day does not beat the unflagged coins' in B, OR beats random < 95% in B
- 7 Oct 12:05 | A3 | DC3.5 holder-growth SELL (new lead found in DC3.4 as the flip side of a killed HOLD feature; not yet tested anywhere else) | for a coin a live or paper book already holds that crossed $500k or $1M: at cross + 1 h, if outside holder growth (+10 min to +1 h, DC3.4 "loose" definition, dc34v2.py) is in the top half (>= +280), SELL at the first sellable print; else keep the book's own exit | test sets: SW wide trades (sw-a2-16-wide-trades.csv) and FW fmmc5 live + paper trades with a $500k / $1M cross after entry, halves by entry date as in those books | $ difference vs the book's own exit, real fills where the book has them | KILL if the overlay does not add $ in BOTH halves, OR it cuts any coin that later did 10x+ more often than random overlays of the same size (beats random < 95%)
- 7 Oct 12:15 | A3 | DC3.5 CORRECTION (names the 12:05 DC3.5 line; that line stays) | "top half (>= +280)" was wrong: +280 is the q3 median. Fixed quarter edges from DC3.4 (420 rows, both halves pooled, frozen now): outside holder growth (loose) q-edges +1 / +69 / +528; plain holder count growth (any wallet, +10 min to +1 h) q-edges +2 / +77 / +494. DC3.5 / A1 Q5b use: top quarter = loose growth >= +528 (or holder growth >= +494); top half = >= +69 (>= +77)
- 7 Oct 12:15 | A3 | DC3.6 forward holder-growth flag (shadow, logging only) | every coin a FW / SW / DC book holds, or any coin crossing sellable $500k or $1M (chain clock): at cross + 1 h log plain holder growth (+10 min to +1 h after cross, any wallet with balance > 0, hubs excluded) and flag DIE if >= +494 (top quarter), WARN if >= +77; no trade action | labels: alive = cap >= 50% of cross cap at +24 h and no pull; pulled within 48 h | n/a (shadow) | after 14 forward days: KILL the flag if DIE coins are alive at +24 h more often than 10%, OR the DIE vs rest pull-within-48 h gap is under 20 points; else hand to A1 Q5b as a live SELL candidate
- 7 Oct 12:13 | A1 | Q5b holder-growth SELL overlay (A3 DC3.4 death sign, edge frozen by A3 12:15 line) | trades: the 70 SW wide trades (sw-a2-16-wide-trades.csv, $500, halves as in file) and the 176 FW mc5 rows (fw/a2-ramp-v2-fwrows.csv, $300 column, entry = T0 + 306 s, halves as in file); checks at entry + 15 min, + 1 h, + 4 h, only if before their exit and before a pull | feature: outside holder growth (loose) over the last 50 min = outside_loose(check) minus outside_loose(check - 50 min), computed exactly as A3 dc34v2.py (hubs = 50+ counterparties up to the check or ffund contract; bundle = creator + receivers in the first 30 blocks from the first transfer + wallets fed by a bundle wallet; outside = balance > 0, not hub, not bundle, funder unknown or not creator / creator funder / the two disperse contracts), transfers from /opt/tw/an1/xfer.db | rule: SELL NOW at the first sellable print ($100+ sell) at or after the first check with growth >= +528 | score: $ added vs their real exit (my pricer, pull = 0), per half, SW and FW separately and pooled | bar: pooled $ added > 0 in A and in B, and beats random >= 95% in B (random = same number of sells at random check slots of the same half, 10,000 draws); otherwise KILLED | sensitivity only (not the bar): edge +69 (top half) and plain holder growth >= +494
- 7 Oct 12:30 | A2 | DC2.4 phase 2 amendment (names DC2.4 11:14) | Pons graduated pools in v3hist exist only from 28 Sep, so halves for phase 2 are A = 28 to 30 Sep, B = 1 to 4 Oct (by entry day, UTC). Crossing = first sell of $100+ at mcap_usd >= level; entry = first swap 5 min later; 48 h must be covered; operator = token creator (tokens.db birth), wallets first funded by it or its crew root, or the two disperse contracts; OPF from post-graduation swaps only (curve buys not seen); fills priced at 1% fee + 1% impact each way ($100), 3% impact ($1,000), because pool_eth_after is empty. Same features, labels, exits and kill bar as DC2.4
- 7 Oct 13:16 | A1 | Q5c HOLD LONGER on early holder growth (lead from Q5b; written before any new data) | trigger: on a held position, outside holder growth (A3 dc34v2 loose ruler, frozen, transfers from /opt/tw/an1/xfer.db or the same fetcher) over the last 50 min, read at our entry + 15 min and + 60 min, >= +528 at either read while the position is still open | action V1 (plain): ignore the window own sell rule from the fire time and exit on a 50% trail from the peak sellable value after the fire ($100+ sell prints, priced on real depth, 1% fee), or at entry + 48 h, pull = 0 | action V2 (A2 LP gate): same as V1 only when the pool LP is burned or held by a real locker (A2 / Data lockers class) at the fire time; creator-held or unknown LP keeps the window own rule | data (UNSEEN only): Data DA.4 honest-5x coins ($300k to $1M base) minus the 203 coins already in xfer.db, with a simulated window baseline = buy at the first sellable $300k cross, sell at 5x or 0.3x stop or 48 h (SW honest rules); plus every FW mc5 and SW position opened after 7 Oct 13:15 BKK, scored against its real exit (Coder shadow book) | halves: A = entry before 29 Sep, B = 29 Sep onward for DA.4 coins; live shadow trades reported as a third block | score: $ added vs the baseline exit per fired position, per variant | bar (each variant): $ added > 0 in A and in B, fired n >= 30 in total, beats random >= 95% (random = the same trail-hold applied to the same number of randomly picked positions of the same half, 10,000 draws); else KILLED | no refit of the +528 edge, the read times or the 50% trail
- 7 Oct 13:18 | A1 | Q5c AMENDMENT (names the "7 Oct 13:16 | A1 | Q5c" line; that line stays; written before any data) | universe fix (outcome bias, lesson 28): the DA.4 part is replaced by EVERY coin with a first sellable $300k cross in the window (launch based, any venue the pricer covers), i.e. DA.4 honest-5x coins PLUS the non-5x crossers Data fetches, minus the 203 coins already in xfer.db; entry = that first sellable $300k print; if Data samples the non-5x set, each sampled non-5x coin carries weight = true non-5x count / sampled count, per half, in $ added, n and the random draw | trigger, V1 / V2, baseline (5x / 0.3x stop / 48 h, pull = 0), halves, live shadow block and bar unchanged
- 7 Oct 13:18 | A4 | AN4.2 SKIP "operator holds float at entry" (from A2 DC2.4 lead, 4 of 4 universes) as an overlay on two existing books, scored with their own lab.py trades: SW live book (/root/fwa3/lab/out/sw_accept/live_book_trades.csv, 71 trades, $1k, halves A to 30 Sep / B 1 to 6 Oct) and FW mc5 (/root/fwa3/lab/out/sw/fw_mc5_trades.csv, 177 trades, $1k, halves A 13 to 24 Sep / B 25 Sep to 6 Oct 12:00). Universe source: harness gold (v3 WETH pools, A3 raw rebuild), not an outcome-picked tape. | Operator wallets OP-F (primary): token creator (gold idx.json) + every wallet SW lists for that creator in /opt/sw/crew_wallets.json (creators, creator_funders, distributors, army) + any swap recipient first funded via 0x84157d3d24630c297849c84d49ae7f1805c1b60f or 0x03802649e469ed5680c58dff9e65425e22d21cc5 or by the creator (ffund/crew funder tables where they cover it). OP-B (secondary, reported, not decisive): creator + recipients of buys in the pool's first 30 blocks. Float share = operator recipients' positive net tokens bought via swaps before the entry minute ÷ all recipients' positive net tokens (router 0xcaf681a66d020601342297493863e78c959e5cb2 excluded). SKIP when OP-F float share >= 0.33 (sensitivity: > 0, reported only). | label = the book's own x per trade (no new exits) | PASS only if, in BOTH halves of a book: $ a trade of the kept trades > the full book's, $ a day of kept >= full book's, the skip beats 1,000 random skips of the same count >= 95%, and kept $ a day without the top 2 trades >= full book without its top 2 | else KILL for that book. Prior work cited, not redone: FW-009 (operator flag skip on mc5, KILLED) and the SW live book's own army <= 0.015 filter (already a float skip, so SW is tested on what is left).
- 7 Oct 13:19 | Engine | E-AN4-1-T15 forward (twin of A4's E-AN4-1 line of 7 Oct 11:28; forward only, no refit, T15 was already a named side exit) | same entry as E-AN4-1: any venue, coin age <= 1 h, a sellable $100k already printed, pool not pulled; fire at the first trade where price <= 0.88 x sellable high so far AND net buy (buy $ minus sell $) in the last 15 min >= 0.25 x cap; fill = first trade in a later block than the fire trade (1 block or more, a fill a live bot can get); one trade per cluster (symbol, creator or funder root) per day; rule file rules/e_an4_1_t15.py md5 ef62db0d9ec6c975f98c05a1b862ad61, engine twtest v1.6 md5 c0f2b013970699f157b0f313b49c4201 | 3x within 48 h from the fill, plus path $ | T15: sell at the first sellable 3x, else at the last sellable print at fill + 15 min; pull = 0; $100 and $1,000 at depth, pool fee each way (dynamic fee 1%) | forward days = Bangkok days after this line (8 Oct on); the backtest (21 Sep to 5 Oct, A +75 / B +178 a day) is context only. PASS (live candidate, $10) = 3 net-positive forward days in a row at $100 AND forward fills beat random entry times on the same coins >= 95%. KILL after 14 forward days if $ a day <= 0, OR beats random < 95%, OR < 10 winners. Forward record = Coder book tw_an4_1_t15
- 7 Oct 13:22 | A4 | AN4.3 HOLD LONGER overlay for good funder roots | frozen root list (picked on half A, 15 to 28 Sep, v4, 5+ coins and honest 5x share >= 25%): 0x28bd039474d6942d8ad4ec07d57a0e98a1c58e45, 0x92a0849f9b1e9e02363a4bd8d74a317fa6ddae92, 0x4757fc41278bd0f1b028c6dae71d381dc4558d98, 0x2c2572da570646b402b9b9e625aa102803904a49, 0x37e51b3694e7cdc9a4f0c6ad4031e1b55eb94cf4, 0x847091a657ff98a37213246d343def3e3988945c | coin's root = crew.db launch.root for its pool, else the creator's crew.db wallet funder chain root (hop_root / funder), creator from gold idx.json; books = FW mc5 and SW live (lab.py trades, their halves, $1k, tick walk) | on a book position whose root is on the list: ignore the book's own sell rule, exit on a 50% trail from the peak since entry or 48 h (same as A1 Q5c), pull = sold at the next block (lab model) | PASS if overlay $ > the real book exit in both halves on the affected trades AND beats random re-assignment of the same exit to the same number of book trades >= 95% in half B | if fewer than 10 book trades have a listed root: no backtest verdict, score forward only (Coder shadow).
- 7 Oct 13:28 | A4 | AN4.4 v3 root lift (replication of the v4 root test on Uniswap v3) | coins = DC1.1 universe venue v3 (honest5x labels), creator from harness gold idx.json, root = crew_v3.db launch.root (A4, crew.db method: first funder by balance gallop + callTracer, walked up until contract, exchange-like nonce >= 2000 or 5 hops). Halves by first trade: A 15 to 28 Sep, B 29 Sep on | pick on A only: roots with >= 5 coins in A and A honest 5x share >= 25% (the v4 rule) AND, because the v3 base rate is ~30%, the scaled rule A share >= 2x the A base rate | label = honest 5x | report B share of picked roots' coins vs all other rooted B coins | a lift counts only if B share >= 2x the rest with >= 20 picked B coins
- 7 Oct 13:33 | A4 | E-AN4-5 HOT/COLD operator overlay on the FW mc5 and SW live books (lab.py trades, their halves, $1k) | operator = cluster id from dc-an4-4-v3coins.csv method (creator->funder EOA links in crew_v3.db, funders with 50+ funded wallets not joined); record at OUR ENTRY minute, leak free: same cluster's coins first traded in the prior 3 days; hit = honest 5x printed before entry; miss = pulled or 7 d window closed before entry; open = left out. HOT = 3+ resolved and 2/3+ hits; COLD = 3+ resolved and 0 hits | HOT trade: ignore the book's sell rule, exit on a 50% trail from the peak since entry or 48 h; COLD trade: exit at the book's first take profit (SW 5x; mc5 has none) or entry + 15 min, whichever first, unless the book's own exit came earlier; else the book's own exit. A pull before our exit = 0x. Valuation: lab x of the real exit plus the difference between overlay exit and real exit valued on the same pool path (cap ratio, 1% fee each way) | PASS if, per book, overlay $ a day > book $ a day in both halves, the change beats 1,000 random hot/cold assignments to the same number of trades >= 95% in half B, and holds without the top 2 trades; if fewer than 10 hot+cold trades in a book half: "too small", forward only (Coder shadow)
- 7 Oct 13:37 | A1 | Q5c V3 (names the 13:16 Q5c line and its 13:18 amendment; written before any Q5c data, after A4 E-AN4-5 showed a 50% trail fires on the first shake) | V3 action: after the fire, keep the window own STOP (simulated baseline: 0.3x; FW mc5: its 0.5x stop; SW: its stop) but remove its take-profit and time stop; once the position value has reached 2x it exits only on a 70% drop from its peak sellable value (value <= 0.3 x peak); otherwise at entry + 48 h; pull = 0; same trigger, universe, weighting, baseline and halves | multiple tests: with V1, V2 and V3 the random bar is raised to >= 98% in B for every variant; the other bar parts ($ added > 0 in A and B, fired n >= 30) unchanged; a variant passes only on its own numbers
- 7 Oct 15:57 | A1 | Q5c RULER NOTE (names the 13:16 Q5c line; written before any Q5c score) | the transfer logs differ by coin (A1 xfer.db from the mint, Data x5 coins from token birth, Data non-5x coins only from cross - 1 h), so a full-history holder count would be measured differently for winners and losers and could fake a signal. Fix, same for every coin: balances are built only from transfers at or after the block of (first sellable $300k time - 1 h); hubs, outside, funder rules exactly as A3 dc34v2.py; the bundle is the creator plus wallets fed by a bundle wallet (the first-30-blocks-after-the-first-transfer rule is dropped because launch is outside most windows); growth = outside holders at the read minus 50 min earlier, reads at entry + 15 min and + 60 min, edge +528 unchanged | prices, BASE and V1 columns from Engine dc/en/q5c_paths.csv (status ok only); weights per half and class (hit5x 1 / 0) = Engine ok count / scored count; the 353 Engine non-ok coins (uncovered 323 = entry + 48 h past tape end, nofill 22, noreserve 8) are dropped by data rules fixed before outcomes