collecting ticks…

`;\n }\n\n // --- Accuracy over time -------------------------------------------------\n // Deliberately NOT a rolling line. A 200-round rolling window over a\n // CONSTANT 57.7% hit rate swings from 50% to 68% on noise alone, which\n // reads as \"hot in August, cold in September\" when nothing happened. Worse,\n // adjacent rolling points share almost all their data, so counting\n // excursions from a band means nothing.\n // Non-overlapping blocks fix both: each block is independent, so the band\n // is honest and \"how many blocks fell outside it\" is a real test. Simulated\n // against 2000 trend-free runs, 16 blocks put 0.69 outside the 95% band vs\n // 0.80 expected -- calibrated.\n const ACC_BLOCKS = 16;\n const ACC_MIN_N = 200;\n let accBlocks = null, accBand = null, accOutside = 0;\n if (n >= ACC_MIN_N) {\n const bs = Math.floor(n / ACC_BLOCKS);\n const pooled = modelHits / n;\n const se = Math.sqrt((pooled * (1 - pooled)) / bs);\n accBand = {\n mid: pooled,\n lo: Math.max(0, pooled - 1.96 * se),\n hi: Math.min(1, pooled + 1.96 * se),\n blockSize: bs,\n };\n accBlocks = [];\n for (let i = 0; i < ACC_BLOCKS; i++) {\n const chunk = statsLog.slice(i * bs, (i + 1) * bs);\n if (!chunk.length) continue;\n const mHits = chunk.filter((r) => r.modelCorrect).length;\n const mktChunk = chunk.filter((r) =>\n r.marketCorrect != null && !isImplausibleMarketQuote(r.marketUp)\n );\n const kHits = mktChunk.filter((r) => r.marketCorrect).length;\n const acc = mHits / chunk.length;\n const out = acc < accBand.lo || acc > accBand.hi;\n if (out) accOutside++;\n accBlocks.push({\n acc,\n out,\n n: chunk.length,\n mktAcc: mktChunk.length ? kHits / mktChunk.length : null,\n startMs: chunk[0].closeMs,\n endMs: chunk[chunk.length - 1].closeMs,\n });\n }\n }\n\n let accChart = \"\";\n if (accBlocks && accBlocks.length > 1) {\n const W = 600, H = 150;\n const all = accBlocks.map((b) => b.acc).concat(\n accBlocks.map((b) => b.mktAcc).filter((v) => v != null),\n );\n const lo = Math.min(0.45, Math.min.apply(null, all) - 0.03);\n const hi = Math.max(0.65, Math.max.apply(null, all) + 0.03);\n const Y = (v) => H - ((v - lo) / (hi - lo)) * H;\n const X = (i) => (i / (accBlocks.length - 1)) * W;\n const bandTop = Y(accBand.hi), bandBot = Y(accBand.lo);\n const mLine = accBlocks.map((b, i) =>\n (i ? \"L\" : \"M\") + X(i).toFixed(1) + \" \" + Y(b.acc).toFixed(1)\n ).join(\" \");\n const kPts = accBlocks.map((\n b,\n i,\n ) => (b.mktAcc == null ? null : { x: X(i), y: Y(b.mktAcc) })).filter(\n Boolean,\n );\n const kLine = kPts.map((pt, i) =>\n (i ? \"L\" : \"M\") + pt.x.toFixed(1) + \" \" + pt.y.toFixed(1)\n ).join(\" \");\n const dots = accBlocks\n .map((b, i) =>\n `Block ${\n i + 1\n }: ${fmtPct(b.acc)} over ${b.n} rounds${\n b.out ? \" — outside the noise band\" : \"\"\n }`\n )\n .join(\"\");\n accChart =\n ``;\n }\n\n const stripHtml = statsLog\n .slice(-40)\n .map(\n (r) =>\n `

`,\n )\n .join(\"\");\n\n function fmtLatency(ms) {\n if (ms == null) return \"\";\n const s = Math.round(ms / 1000);\n return s < 60 ? `+${s}s` : `+${Math.floor(s / 60)}m${s % 60}s`;\n }\n function fmtWindowRange(closeMs) {\n const openMs = closeMs - 15 * 60 * 1000;\n const openStr = new Date(openMs).toLocaleTimeString(\"en-US\", {\n hour: \"numeric\",\n minute: \"2-digit\",\n timeZone: \"UTC\",\n });\n const closeStr = new Date(closeMs).toLocaleTimeString(\"en-US\", {\n hour: \"numeric\",\n minute: \"2-digit\",\n timeZone: \"UTC\",\n });\n return { openMs, closeMs, text: `${openStr}–${closeStr} UTC` };\n }\n function fmtStreakRange(startCloseMs, endCloseMs) {\n const startOpenMs = startCloseMs - 15 * 60 * 1000;\n const fmt = (ms) =>\n new Date(ms).toLocaleString(\"en-US\", {\n month: \"short\",\n day: \"numeric\",\n hour: \"numeric\",\n minute: \"2-digit\",\n timeZone: \"UTC\",\n });\n return `${fmt(startOpenMs)} – ${fmt(endCloseMs)} UTC`;\n }\n\n const hiddenNoMarketCount =\n log.filter((r) => r.lockedAt != null && r.strikeSource === \"auto\").length;\n\n function fmtEvLine(upEV, downEV, isNet) {\n const tag = isNet\n ? \" net of fees\"\n : \" gross (logged before fees were modelled)\";\n if (upEV != null && upEV > 0) {\n return `Buy Up EV was ${\n (upEV * 100).toFixed(1)\n }¢${tag}`;\n }\n if (downEV != null && downEV > 0) {\n return `Buy Down EV was ${\n (downEV * 100).toFixed(1)\n }¢${tag}`;\n }\n if (upEV != null || downEV != null) {\n return `No positive edge on either side at lock${\n isNet ? \", once fees are counted\" : \"\"\n }`;\n }\n return `EV unavailable at lock (no live Kalshi ask)`;\n }\n\n // Walk every quarter-hour backwards and account for ALL of them. A gap in\n // this list used to mean one of two completely different things -- the\n // round was recorded and then filtered out, or the cron never locked it at\n // all -- and there was no way to tell which. Now each window renders as\n // one of three states, so a hole is never silent.\n const WINDOW_MS = 15 * 60 * 1000;\n const byClose = new Map();\n for (const r of rawLog) {\n const prev = byClose.get(r.closeMs);\n // If a window somehow has two records, prefer the one that survives.\n if (\n !prev || (exclusionReason(prev) != null && exclusionReason(r) == null)\n ) byClose.set(r.closeMs, r);\n }\n const HISTORY_WINDOWS = 16;\n const newestClose = latest && latest.closeMs != null\n ? latest.closeMs - WINDOW_MS\n : rawLog.length\n ? Math.max.apply(null, rawLog.map((r) => r.closeMs))\n : null;\n const expectedCloses = [];\n if (newestClose != null) {\n for (let i = 0; i < HISTORY_WINDOWS; i++) {\n expectedCloses.push(newestClose - i * WINDOW_MS);\n }\n }\n let missingCount = 0,\n filteredCount = 0,\n discoveryFailCount = 0,\n noTickCount = 0;\n\n const recentLocksHtml = expectedCloses\n .map((expectedClose) => {\n const rec = byClose.get(expectedClose);\n const w = fmtWindowRange(expectedClose);\n\n // State 1: nothing was recorded. \"No record\" on its own is ambiguous --\n // it looks identical whether the cron ran and failed to lock, or never\n // ran at all, and those need opposite fixes. Every tick appends a\n // timestamp to btc_kalshi_ticks, so counting the ones that fall inside\n // this window answers it outright instead of leaving it to guesswork.\n if (!rec) {\n missingCount++;\n const ticksHere = ticks.filter((t) =>\n t.t >= w.openMs && t.t < w.closeMs\n ).length;\n if (ticksHere > 0) discoveryFailCount++;\n else noTickCount++;\n return `

${w.text}

${\n ticksHere > 0\n ? `no record \\u2014 but the cron ran ${ticksHere} time${\n ticksHere === 1 ? \"\" : \"s\"\n } during this window, so it was alive and never got a market from Kalshi`\n : `no record \\u2014 and the cron did not run at all during this window`\n }

`;\n }\n\n // State 2: recorded, but a filter removed it from the statistics.\n const why = exclusionReason(rec);\n if (why) {\n filteredCount++;\n const lat = fmtLatency(rec.lockLatencyMs);\n return `

${w.text}

recorded${\n lat ? \" at \" + lat : \"\"\n } \\u2014 excluded: ${why}

\\u2013

`;\n }\n\n // State 3: a normal counted round.\n return ((r) => {\n const called = r.modelUp >= 0.5 ? \"UP\" : \"DOWN\";\n const calledPct = r.modelUp >= 0.5 ? r.modelUp : 1 - r.modelUp;\n const latency = fmtLatency(r.lockLatencyMs);\n const settleDist = r.finalSpot != null ? r.finalSpot - r.strike : null;\n const isAutoStrike = r.strikeSource === \"auto\";\n const isBadQuote = isImplausibleMarketQuote(r.marketUp);\n const isSplit = !isBadQuote && r.marketUp != null &&\n (r.modelUp >= 0.5) !== (r.marketUp >= 0.5);\n return `

${w.text}

locked $${\n r.strike.toLocaleString(\"en-US\", { maximumFractionDigits: 0 })\n }${\n r.gradeSource === \"spot\"\n ? ` SPOT`\n : \"\"\n }${\n isAutoStrike ? ` EST` : \"\"\n }${\n latency ? ` ${latency}` : \"\"\n }

${called} ${(calledPct * 100).toFixed(0)}%

${\n isSplit\n ? `⇅`\n : \"\"\n }

${\n r.modelCorrect ? \"✓\" : \"✕\"\n }

▾

\n ${\n isAutoStrike\n ? `

Kalshi was unreachable the moment this window locked, so the strike above is an estimate (live spot price at lock time), not Kalshi's real strike — this round isn't counted in the accuracy or Brier numbers above.

`\n : \"\"\n }\n ${\n isBadQuote\n ? `

Market quote at lock was within half a cent of 0% or 100% — implausible for a fresh window, almost certainly a bad Kalshi read rather than real market confidence. Excluded from market accuracy, Brier, and EV-signal numbers above.

`\n : `

Market called ${\n r.marketUp != null\n ? fmtPct(r.marketUp >= 0.5 ? r.marketUp : 1 - r.marketUp) +\n \" \" + (r.marketUp >= 0.5 ? \"UP\" : \"DOWN\")\n : \"—\"\n }${\n r.marketCorrect != null\n ? (r.marketCorrect\n ? ` ✓`\n : ` ✕`)\n : \"\"\n }${isSplit ? ` — opposite side to the model` : \"\"}

${\n (() => {\n const [eu, ed] = evPair(r);\n return fmtEvLine(\n eu,\n ed,\n r.lockUpEVNet != null || r.lockDownEVNet != null,\n );\n })()\n }

`\n }\n

${\n r.gradeSource === \"kalshi\"\n ? `Outcome taken from Kalshi's official settled result — ground truth, no timing error.`\n : r.gradeSource === \"spot\"\n ? `Kalshi never returned a settled result, so this was graded from our own price reading${\n r.gradeLatencyMs != null\n ? ` ${Math.round(r.gradeLatencyMs / 1000)}s after close`\n : \"\"\n } — timing-sensitive if it settled near the strike.`\n : `Graded from a price reading (predates official-settlement grading).`\n }

Spot at close ${\n fmtUsd(r.finalSpot)\n }${\n settleDist != null\n ? ` (${settleDist >= 0 ? \"▲\" : \"▼\"} ${\n fmtUsd(Math.abs(settleDist))\n } vs strike)`\n : \"\"\n }

`;\n })(rec);\n })\n .join(\"\");\n\n const currentLockHtml = latest && latest.lockedModelUp != null\n ? (() => {\n const called = latest.lockedModelUp >= 0.5 ? \"UP\" : \"DOWN\";\n const calledPct = latest.lockedModelUp >= 0.5\n ? latest.lockedModelUp\n : 1 - latest.lockedModelUp;\n const w = fmtWindowRange(latest.closeMs);\n const latency = latest.lockedAt != null\n ? fmtLatency(latest.lockedAt - w.openMs)\n : \"\";\n const isAutoStrike = latest.strikeSource === \"auto\";\n const isBadQuote = isImplausibleMarketQuote(latest.lockedMarketUp);\n return `

NOW${w.text}

locked $${\n latest.strike.toLocaleString(\"en-US\", { maximumFractionDigits: 0 })\n }${\n isAutoStrike ? ` EST` : \"\"\n }${\n latency ? ` ${latency}` : \"\"\n }

${called} ${(calledPct * 100).toFixed(0)}%

${\n latest.lockedMarketUp != null && !isBadQuote &&\n (latest.lockedModelUp >= 0.5) !== (latest.lockedMarketUp >= 0.5)\n ? `⇅`\n : \"\"\n }

⋯

▾

\n ${\n isAutoStrike\n ? `

Kalshi was unreachable when this window locked, so the strike is an estimate — it won't count once graded.

`\n : \"\"\n }\n ${\n isBadQuote\n ? `

Market quote at lock was within half a cent of 0% or 100% — almost certainly a bad Kalshi read. Won't count once graded.

`\n : `

Market called ${\n latest.lockedMarketUp != null\n ? fmtPct(\n latest.lockedMarketUp >= 0.5\n ? latest.lockedMarketUp\n : 1 - latest.lockedMarketUp,\n ) + \" \" + (latest.lockedMarketUp >= 0.5 ? \"UP\" : \"DOWN\")\n : \"—\"\n }

${\n fmtEvLine(\n latest.lockedUpEVNet != null\n ? latest.lockedUpEVNet\n : latest.lockedUpEV,\n latest.lockedDownEVNet != null\n ? latest.lockedDownEVNet\n : latest.lockedDownEV,\n latest.lockedUpEVNet != null || latest.lockedDownEVNet != null,\n )\n }

`\n }\n

Still running — settles when the window closes, then waits for Kalshi's official result.

`;\n })()\n : \"\";\n\n const waitingForMarket = !!(latest && latest.waitingForMarket);\n const dist = latest && latest.strike != null\n ? latest.price - latest.strike\n : null;\n const windowExpired = latest && latest.closeMs != null\n ? now >= latest.closeMs\n : false;\n const verdict = latest && latest.modelUp != null\n ? (latest.modelUp >= 0.5 ? \"UP\" : \"DOWN\")\n : null;\n const verdictP = latest && latest.modelUp != null\n ? (latest.modelUp >= 0.5 ? latest.modelUp : 1 - latest.modelUp)\n : null;\n\n const EARNED_SIGNAL_MIN_N = 30;\n const earnedSignal = latest && latest.momActive &&\n withSignal.length >= EARNED_SIGNAL_MIN_N &&\n signalHits / withSignal.length -\n (noSignal.length ? noSignalHits / noSignal.length : 0.5) > 0.08;\n\n const isPartial = reqUrl.searchParams.get(\"partial\") === \"1\";\n\n const inner = `\n

BTC · Kalshi 15-min

${\n stale\n ? \"grader stale — check the cron val is running\"\n : \"grading in background\"\n }

\n\n ${\n earnedSignal\n ? `

Earned signal — active

Both the momentum term and the EV-effectiveness split have shown a real, tested edge on history. Check the cards below for the actual numbers before acting.

`\n : \"\"\n }\n\n

${fmtUsd(latest ? latest.price : null)}

${latest ? \"price as of just now\" : \"\"}

= 0 ? \"var(--up)\" : \"var(--down)\")\n : \"transparent\"\n }\">${\n windowExpired\n ? \"waiting for next lock…\"\n : dist != null\n ? `${dist >= 0 ? \"▲\" : \"▼\"} ${fmtUsd(Math.abs(dist))} ${\n dist >= 0 ? \"above\" : \"below\"\n } strike ${fmtUsd(latest.strike)}`\n : \"\"\n }

${svgChart}

\n\n

Window closes in\n ${mm != null ? mm + \":\" + String(ss).padStart(2, \"0\") : \"—\"}

\n \n ${\n latest && latest.kalshiOk\n ? \"Kalshi: \" + latest.kalshiTicker\n : \"Kalshi quote unavailable this tick — nothing will be locked until it returns.\"\n }${\n latest && latest.awaitingSettlement > 0\n ? ` · ${latest.awaitingSettlement} round${\n latest.awaitingSettlement === 1 ? \"\" : \"s\"\n } awaiting Kalshi's settled result`\n : \"\"\n }\n

\n\n

\n Model guess · driftless lognormal barrier\n

\n ◍ Waiting for the cron to catch up to this window — it checks in about once a minute, not synced to the exact open time, so this can take up to ~60s.\n

\n ${\n verdict\n ? `

\n ${verdict === \"UP\" ? \"▲\" : \"▼\"}\n

LEAN ${verdict} LIVE

${\n fmtPct(verdictP)\n } to finish ${verdict.toLowerCase()}

Model P(Up)

${\n fmtPct(latest.modelUp)\n }

Market P(Up)

${\n latest.marketUp != null ? fmtPct(latest.marketUp) : \"—\"\n }

0 ? \" up\" : \"\"\n }\">\n

Buy Up EV, net

${\n latest.upEVNet != null\n ? cents(latest.upEVNet)\n : latest.upEV != null\n ? cents(latest.upEV)\n : \"—\"\n }

\n ${\n latest.upEVNet != null && latest.upEV != null\n ? `

${\n cents(latest.upEV)\n } before fees

`\n : \"\"\n }\n

0 ? \" up\" : \"\"\n }\">\n

Buy Down EV, net

${\n latest.downEVNet != null\n ? cents(latest.downEVNet)\n : latest.downEV != null\n ? cents(latest.downEV)\n : \"—\"\n }

\n ${\n latest.downEVNet != null && latest.downEV != null\n ? `

${\n cents(latest.downEV)\n } before fees

`\n : \"\"\n }\n

\n ${\n latest.upEV == null && latest.downEV == null\n ? \"EV needs a live tradable ask price from Kalshi — unavailable this tick.\"\n : \"EV = model probability minus what you'd actually pay, minus Kalshi's fee. Positive means the model disagrees with the market's price, not that it's right — and it still doesn't account for crossing the bid-ask spread, often another 1–3¢.\"\n }\n

LOCKED${\n latest.lockedAt != null\n ? ` `\n : \"\"\n } being graded: model ${\n fmtPct(\n latest.lockedModelUp,\n )\n }${\n latest.lockedMarketUp != null\n ? `, market ${fmtPct(latest.lockedMarketUp)}`\n : \"\"\n } — fixed at first sight of this window so scoring stays fair.

`\n : waitingForMarket\n ? `

\n ◍ Waiting for Kalshi to publish this window's market. Nothing is locked yet — that's deliberate. Kalshi typically lists a new 15-minute market ~25–30s after the window opens.\n

`\n : `

Waiting on the first cron tick.

`\n }\n

\n\n

Head to head

\n ${\n disagreeN === 0\n ? `

No graded round yet has the model and the market calling opposite sides. Until that happens there's nothing to compare — agreeing with the market can't tell you which is better.

`\n : !disagreeConsistent\n ? `

Found ${disagreeN} rounds where the two called opposite sides, but the stored win counts don't add up (${disagreeModelWins} + ${disagreeMarketWins} ≠ ${disagreeN}). That points at a bad record rather than a real result, so the split isn't shown.

`\n : `

\n ${disagreeModelWins} model\n ${disagreeN} split rounds\n ${disagreeMarketWins} market\n

These are the only rounds that can separate the two. When both call the same side they win or lose together — out of ${n} graded rounds, just ${disagreeN} actually put them against each other, and exactly one was right each time.${\n disagreeCI\n ? ` The model took ${\n fmtPct(disagreeModelWins / disagreeN)\n } of them (95% CI ${fmtPct(disagreeCI.lower)}–${\n fmtPct(disagreeCI.upper)\n })${\n disagreeCI.lower <= 0.5 && disagreeCI.upper >= 0.5\n ? \", an interval that still contains an even split — not yet evidence either way.\"\n : disagreeCI.lower > 0.5\n ? \", an interval entirely above an even split.\"\n : \", an interval entirely below an even split — the market is winning these.\"\n }`\n : \"\"\n }

Worth being blunt about the size: ${disagreeN} rounds gives a confidence interval about ${\n (1.959964 * Math.sqrt(0.25 / disagreeN) * 200).toFixed(0)\n } percentage points wide. A genuine edge would be 1–2 points. This is the right test, but it needs far more split rounds.

`\n }\n

\n\n

Track record

\n ${\n n === 0\n ? `

No graded windows yet — this fills in automatically as the cron runs.

`\n : `

Model accuracy

${\n fmtPct(\n modelHits / n,\n )\n } (${modelHits}/${n})

${\n accCI\n ? `

95% CI ${\n fmtPct(accCI.lower)\n }–${fmtPct(accCI.upper)}${\n accCI.lower <= 0.5 && accCI.upper >= 0.5 ? \" · includes 50%\" : \"\"\n }

`\n : \"\"\n }

Market accuracy

${\n withMkt.length ? fmtPct(mktHits / withMkt.length) : \"—\"\n } (${mktHits}/${withMkt.length})

Model Brier

${\n modelBrier != null ? modelBrier.toFixed(3) : \"—\"\n }

Market Brier

${\n mktBrier != null ? mktBrier.toFixed(3) : \"—\"\n }

${stripHtml}

Lower Brier wins; 0.25 is a coin flip. If the model's Brier isn't clearly under the market's, there's no edge here — the expected outcome, not a failure.${\n accCI && accCI.lower <= 0.5 && accCI.upper >= 0.5\n ? \" The accuracy confidence interval above still includes 50% — not yet statistically distinguishable from a coin flip at this sample size.\"\n : \"\"\n }

What this sample can and can't show. Resolving a 2-percentage-point edge takes roughly ${roundsFor2pp.toLocaleString()} graded rounds at 80% power. You have ${n.toLocaleString()}${\n n < roundsFor2pp\n ? `, so about ${\n Math.ceil((roundsFor2pp - n) / 96)\n } more days of continuous running`\n : \"\"\n }. The log holds ${MAX_LOG_CAP.toLocaleString()} rounds before older ones drop off, a hard floor of roughly ${\n (detectableAtCap * 100).toFixed(1)\n }pp on the smallest edge this record can ever resolve.

\n ${\n groundTruthCount < n\n ? `

${groundTruthCount.toLocaleString()} of ${n.toLocaleString()} rounds were graded from Kalshi's official settled result. The rest were decided from our own price reading, which carries timing error near the strike — those age out as new ones accumulate.

`\n : \"\"\n }`\n }\n

\n\n

Accuracy over time▾

\n ${\n !accBlocks\n ? `

Needs at least ${ACC_MIN_N} graded rounds before this says anything — ${n}/${ACC_MIN_N} so far.

`\n : `

${accChart}

\n model\n market\n noise band\n 50%\n

Blocks outside the band

= 3 ? ' style=\"color:var(--down)\"' : \"\"\n }>${accOutside} of ${accBlocks.length}

Expected by chance

${\n (accBlocks.length * 0.05).toFixed(1)\n }

${\n accOutside <= 1\n ? \"No trend. The model's accuracy is flat.\"\n : accOutside === 2\n ? \"Nothing convincing yet.\"\n : \"Worth a look.\"\n } Each dot is ${accBand.blockSize} consecutive rounds, and the blocks don't overlap, so they're independent of each other. The shaded band is the range that ${\n fmtPct(accBand.mid)\n } accuracy produces by pure chance at this block size. ${\n accOutside <= 1\n ? `With ${accOutside} block${\n accOutside === 1 ? \"\" : \"s\"\n } outside it against ${\n (accBlocks.length * 0.05).toFixed(1)\n } expected, there is no evidence accuracy is changing — whatever shape you see in that line is noise.`\n : accOutside === 2\n ? `Two outside against ${\n (accBlocks.length * 0.05).toFixed(1)\n } expected is mildly above chance but well within what a trend-free record throws up.`\n : `${accOutside} outside against ${\n (accBlocks.length * 0.05).toFixed(1)\n } expected happens in about 3% of trend-free records — not proof, but the first real reason to suspect something changed.`\n }

Why blocks and not a rolling line. A 200-round rolling average over a constant ${\n fmtPct(accBand.mid)\n } hit rate swings roughly 50%–68% on noise alone, which reads as hot and cold streaks that never happened. Rolling points also share nearly all their data, so counting excursions from a band would mean nothing. These blocks are independent, which is what makes the count above an actual test rather than a picture.

Plotted by round, not by clock time — the cron's coverage has gaps, and spacing blocks evenly by date would stretch thin patches and squash dense ones.

`\n }\n

\n\n

Coverage & what's being discarded▾

Rounds recorded

${rawLog.length.toLocaleString()}

Counted in the stats

${n.toLocaleString()}

\n ${\n excluded.length === 0\n ? `

Nothing is being filtered out. Every recorded round counts.

`\n : `${\n Object.keys(exclusionCounts).map((why) =>\n ``\n ).join(\"\")\n }

${why}

${\n exclusionCounts[why].toLocaleString()\n } dropped

\n ${\n excludedAcc\n ? `

The bias check. Discarded rounds hit ${\n fmtPct(excludedAcc.hits / excludedAcc.n)\n } (${excludedAcc.hits}/${excludedAcc.n}); counted rounds hit ${\n n ? fmtPct(modelHits / n) : \"—\"\n } (${modelHits}/${n}). If those two numbers are close, the filters are removing rounds for timing reasons and the headline accuracy is honest. If the discarded set is much worse, the filters are quietly selecting for wins and the headline number is inflated — treat it as broken until that's explained.

`\n : `

None of the discarded rounds carry a graded result, so no bias comparison is possible yet.

`\n }`\n }\n

Is the cron actually running? ${\n latest && latest.tickGapSec != null\n ? `Measured from the tick timestamps themselves: about one run every ${latest.tickGapSec}s, which is ${latest.ticksPerWindow} attempt${\n latest.ticksPerWindow === 1 ? \"\" : \"s\"\n } per 15-minute window.${\n latest.ticksPerWindow != null && latest.ticksPerWindow < 3\n ? ` That is too few — Kalshi doesn't list a market until ~27s in, so with this few tries a window that gets an early tick is simply lost. This is a cron schedule problem, not a code problem.`\n : ` That's plenty; a window missing its lock with this many attempts points at Kalshi discovery, not at the schedule.`\n }${latest.tickMs != null ? ` Last run took ${latest.tickMs}ms.` : \"\"}`\n : `Not measured yet — needs a few ticks from the current cron build.`\n }

Does locking later actually help the model? The lock cap exists on the theory that more elapsed time inflates accuracy. This tests it directly rather than assuming.

\n \n \n ${\n latRows.map((b) =>\n ``\n ).join(\"\")\n }\n

Lock landed	rounds · accuracy
${b.lo}–${\n b.hi === Infinity ? \"∞\" : b.hi\n }s after open	${b.n} · ${\n b.acc ? fmtPct(b.acc.hits / b.acc.n) : \"—\"\n }

A clean rising trend down this column means late locks really are easier and the cap is doing real work. A flat column means the cap was costing sample size for nothing, and it should be loosened further.

\n\n

Streaks & runs▾

\n ${\n !streakData\n ? `

Needs at least ${STREAK_MIN_N} graded windows to say anything meaningful — ${n}/${STREAK_MIN_N} so far.

`\n : (() => {\n const HIST_CAP = 10;\n const BREAKDOWN_CAP = 6;\n const winTier = streakTier(streakData.winPercentile);\n const lossTier = streakTier(streakData.lossPercentile);\n const runsT = runsTier(streakData.runsPercentile);\n const curTier = streakTier(streakData.endStreakPercentile);\n const curColor = streakData.actual.endType === \"win\"\n ? \"var(--up)\"\n : \"var(--down)\";\n const curNoun = streakData.actual.endType === \"win\"\n ? streakData.actual.endStreak === 1 ? \"win\" : \"wins\"\n : streakData.actual.endStreak === 1\n ? \"loss\"\n : \"losses\";\n\n const renderHistogram = (shuffledValues, actualValue, tierLevel) => {\n const counts = histogramBuckets(shuffledValues, HIST_CAP);\n const maxCount = Math.max(...counts, 1);\n const actualIdx = Math.min(actualValue, HIST_CAP);\n const bars = counts\n .map((c, i) => {\n const isActual = i === actualIdx;\n const heightPct = Math.max(4, (c / maxCount) * 100);\n const label = i === HIST_CAP ? `${HIST_CAP}+` : `${i}`;\n return `

`;\n })\n .join(\"\");\n return `

${bars}

0${HIST_CAP}+

`;\n };\n\n const winRange = streakData.actual.maxWinStart >= 0\n ? fmtStreakRange(\n statsLog[streakData.actual.maxWinStart].closeMs,\n statsLog[streakData.actual.maxWinEnd].closeMs,\n )\n : null;\n const lossRange = streakData.actual.maxLossStart >= 0\n ? fmtStreakRange(\n statsLog[streakData.actual.maxLossStart].closeMs,\n statsLog[streakData.actual.maxLossEnd].closeMs,\n )\n : null;\n\n const streakRow = (\n label,\n valueText,\n tier,\n shuffledValues,\n actualValue,\n range,\n rowKey,\n ) => `\n

\n ${label}\n ${tier.label}▾\n

\n ${valueText}\n ${\n tier.pos.toFixed(0)\n }th percentile\n

\n ${renderHistogram(shuffledValues, actualValue, tier.level)}\n

${\n range ? `Happened ${range}` : \"No such streak in this record yet.\"\n }

`;\n\n const bucketed = (countsObj) => {\n const out = new Array(BREAKDOWN_CAP + 1).fill(0);\n for (const [lenStr, cnt] of Object.entries(countsObj)) {\n out[Math.min(Number(lenStr), BREAKDOWN_CAP)] += cnt;\n }\n return out;\n };\n const winActualB = bucketed(streakData.actualCounts.win);\n const lossActualB = bucketed(streakData.actualCounts.loss);\n const winAvgB = bucketed(streakData.winBucketAvg);\n const lossAvgB = bucketed(streakData.lossBucketAvg);\n const breakdownRows = Array.from({ length: BREAKDOWN_CAP }, (_, i) =>\n i + 1)\n .map((len) => {\n const label = len === BREAKDOWN_CAP\n ? `${len}+ in a row`\n : `${len} in a row`;\n return `

\n ${label}\n ${winActualB[len]} (avg ${\n winAvgB[len].toFixed(1)\n })\n ${lossActualB[len]} (avg ${\n lossAvgB[len].toFixed(1)\n })\n

`;\n })\n .join(\"\");\n\n return `\n

\n Current streak\n ${curTier.label}\n

\n ${streakData.actual.endStreak} ${curNoun} in a row\n ${\n curTier.pos.toFixed(0)\n }th percentile\n

\n ${\n streakRow(\n `Longest win streak ever`,\n `${streakData.actual.maxWin} in a row`,\n winTier,\n streakData.shuffledMaxWins,\n streakData.actual.maxWin,\n winRange,\n \"streak-win\",\n )\n }\n ${\n streakRow(\n `Longest losing streak ever`,\n `${streakData.actual.maxLoss} in a row`,\n lossTier,\n streakData.shuffledMaxLosses,\n streakData.actual.maxLoss,\n lossRange,\n \"streak-loss\",\n )\n }\n

Streak lengthWin streaksLoss streaks

${breakdownRows}

\"Avg\" is the average count across 500 random reshuffles of this same record — the honest baseline for what chance alone produces.

\n Switching between wins/losses\n ${runsT.label}\n

\n clustered\n ${streakData.actual.runs} switches · ${\n runsT.pos.toFixed(0)\n }th percentile\n alternating\n

Everything above compares the real chronological record against 500 random reshuffles of that exact same set of wins and losses. Grey is what luck alone produces; amber and red mark territory reshuffling rarely reaches. Tap \"longest ever\" to see when it happened.

`;\n })()\n }\n

\n\n

Where it locked each round

\n ${\n !currentLockHtml && expectedCloses.length === 0\n ? `

Nothing locked yet.

`\n : `

${currentLockHtml}${recentLocksHtml}

\n ${\n missingCount + filteredCount > 0\n ? `

Why this list has holes. Of the last ${expectedCloses.length} windows, ${filteredCount} were recorded but excluded by a filter, and ${missingCount} were never recorded at all${\n missingCount > 0\n ? ` — ${discoveryFailCount} of those had the cron running but getting no market from Kalshi, and ${noTickCount} had no cron tick at all`\n : \"\"\n }. Those are different problems: the first is the filters doing their job, the second means the cron didn't lock that window — usually a tick that failed or ran long. If the second number is consistently large, check the cron's logs rather than trusting the sample size.

`\n : `

Every one of the last ${expectedCloses.length} windows was recorded and counted — no holes.

`\n }\n

Each row is identified by its own window's real open–close boundaries. The +Ns tag shows how long after the window opened the call was locked. A brass edge and ⇅ mark rounds where the model and the market called opposite sides. A SPOT tag means Kalshi never returned a settled result and we graded that round ourselves.${\n hiddenNoMarketCount > 0\n ? ` ${hiddenNoMarketCount} round${\n hiddenNoMarketCount === 1 ? \" was\" : \"s were\"\n } locked before Kalshi published a market, so the reading was forced to 50% — they never counted toward any statistic.`\n : \"\"\n }

`\n }\n

\n\n

Does the EV signal mean anything?▾

\n ${\n withSignal.length === 0\n ? `

No graded windows yet had a positive-EV side at lock time — nothing to test.

`\n : `

When EV said \"buy\" (n=${withSignal.length})

${\n fmtPct(signalHits / withSignal.length)\n } (${signalHits}/${withSignal.length})

When it didn't (n=${noSignal.length})

${\n noSignal.length ? fmtPct(noSignalHits / noSignal.length) : \"—\"\n } (${noSignalHits}/${noSignal.length})

${\n grossOnlyEvCount > 0\n ? `${grossOnlyEvCount} of these rounds were logged before fees were modelled, so their EV is gross and overstates the edge by roughly 1.75¢. `\n : \"\"\n }This is the honest answer to \"where are good spots to buy\": if the left number isn't clearly higher than the right one — and with counts this small it almost certainly isn't — the EV signal hasn't demonstrated it's worth following.

`\n }\n

\n\n

Self-tuning▾

Confidence calibration

${\n latest && latest.calibActive ? \"ON\" : \"OFF\"\n }

\n ${\n latest && latest.calibActive\n ? `Applying ${\n latest.calibK.toFixed(2)\n }× scaling, earned on ${latest.calibN} graded rounds.`\n : `${\n latest ? latest.calibN : 0\n }/300 graded rounds — ${\n latest && latest.calibN >= 300\n ? \"enough data, but the correction didn't hold up out-of-sample yet.\"\n : \"not enough data yet to safely turn on.\"\n }`\n }\n ${\n calibration && calibration.walkForward && calibration.walkForward.folds &&\n calibration.walkForward.folds.length\n ? `

Walk-forward: ${calibration.walkForward.positiveFolds}/${calibration.walkForward.folds.length} held-out folds agreed, avg out-of-sample Δbrier ${\n calibration.walkForward.avgImprovement >= 0 ? \"+\" : \"\"\n }${calibration.walkForward.avgImprovement.toFixed(4)}.

`\n : \"\"\n }\n

Momentum weight

${\n latest && latest.momActive ? \"ON\" : \"OFF\"\n }

\n ${\n latest && latest.momActive\n ? `Weighting recent trend at ${\n latest.momW.toFixed(2)\n }, earned on ${latest.momN} graded rounds.`\n : `${\n latest ? latest.momN : 0\n }/600 graded rounds — ${\n latest && latest.momN >= 600\n ? \"enough data, but the effect didn't hold up out-of-sample yet.\"\n : \"not enough data yet to safely turn on.\"\n }`\n }\n ${\n momentum && momentum.walkForward && momentum.walkForward.folds &&\n momentum.walkForward.folds.length\n ? `

Walk-forward: ${momentum.walkForward.positiveFolds}/${momentum.walkForward.folds.length} held-out folds agreed, avg out-of-sample Δbrier ${\n momentum.walkForward.avgImprovement >= 0 ? \"+\" : \"\"\n }${momentum.walkForward.avgImprovement.toFixed(4)}.

`\n : \"\"\n }\n

Both are only trusted once they improve accuracy on data they were never fit against — split chronologically into 4 held-out folds. Calibration only rescales confidence toward or away from 50%; it can't invent an edge.

\n\n

No-bet is the default. This dashboard exists to show whether the model ever beats the market's own price — it almost never should, after fees and spread. Don't size positions on a win streak.

\n\n

Outcomes are taken from Kalshi's own official settled result wherever available. Only when that never arrives does this fall back to a spot price reading, which is timing-sensitive near the strike; those rounds are tagged SPOT. Each prediction locks as soon as Kalshi publishes that window's market — typically ~25–30s after it opens.

\n`;\n\n if (isPartial) {\n return new Response(inner, {\n headers: {\n \"content-type\": \"text/html; charset=utf-8\",\n \"cache-control\": \"no-store\",\n \"access-control-allow-origin\": \"*\",\n },\n });\n }\n\n const html = `\n\nBTC · Kalshi 15-min\n${CSS}\n

${inner}

connecting…

\n${PAGE_SCRIPT}\n`;\n\n return new Response(html, {\n headers: {\n \"content-type\": \"text/html; charset=utf-8\",\n \"cache-control\": \"no-store\",\n \"access-control-allow-origin\": \"*\",\n },\n });\n}",[],[186],["D",1784565477997],{"_11":12,"_137":71},{"_11":12,"_132":133,"_70":71,"_30":69,"_134":135,"_136":24},{"_40":123,"_13":16,"_34":37,"_124":87,"_125":-5,"_126":-5,"_127":-5,"_128":-5,"_129":-5,"_130":14,"_131":12},"ctx",{"_53":-5,"_156":230,"_231":232,"_233":234,"_235":24,"_236":24,"_237":24,"_238":100,"_239":-5,"_240":-7,"_241":-7,"_242":26,"_243":24,"_244":24,"_245":-5,"_246":24,"_247":24,"_248":24,"_249":-5},"ENV",{"_201":202,"_203":204,"_205":16,"_206":207,"_208":209,"_210":211,"_212":213,"_214":215,"_216":217,"_218":219,"_220":221,"_222":223,"_224":225,"_226":227,"_228":229},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]

History · shared.ts