outcometick 1.6.4 → 1.6.5

package/README.md

@@ -5,7 +5,7 @@
   scripts/publish-sdk-repos.mjs and overwritten wholesale on each publish.
   An edit made here survives until the next publish and then disappears.
 
-  Generated from monorepo revision c44df8d3662f109757247e01752e966858db6a05.
+  Generated from monorepo revision 13e95ca5b2d1f465cb53799e610a08476f1db274.
 -->
 
 # outcometick

package/api/lib/backtest-contract.mjs

@@ -15,7 +15,7 @@ import { FIRST_COMPLETE_DAY } from './coverage-window.mjs';
 export const SCHEMA_VERSION = 1;
 
 /** SDK version reported by the docs page and stamped into every report. */
-export const SDK_VERSION = '1.6.4';
+export const SDK_VERSION = '1.6.5';
 
 /**
  * The tag of the sandbox images, and the ONLY place it is written down.
@@ -60,7 +60,7 @@ export const SDK_VERSION = '1.6.4';
  * forwarded a fourth descriptor, so fd 3 was closed inside the container and no
  * containerised run had ever returned anything.
  */
-export const SANDBOX_IMAGE_TAG = '1.15.0';
+export const SANDBOX_IMAGE_TAG = '1.16.0';
 
 // ---------------------------------------------------------------------------
 // Languages
@@ -294,6 +294,24 @@ const BOOK_CAPTURE = Object.freeze({
   ]),
 });
 
+/**
+ * The days the book cadence changed, oldest first.
+ *
+ * Exported for the prewarm, which has to warm one shape PER CADENCE TIER: the
+ * cadence is chosen from a run's date RANGE, so a range that stops short of a
+ * change and one that crosses it are two different cache entries for the same
+ * day. Warming a single range therefore covers exactly one tier and silently
+ * misses the others — which is what happened between 2026-08-25 and
+ * 2026-09-07, when the prewarm warmed the whole sellable span (500ms) while
+ * every run over recent days wanted 20ms.
+ *
+ * Derived from the table above rather than restated, so a new cadence entry
+ * grows the warm set without anyone remembering to come here.
+ */
+export function bookCadenceChangeDays(venue) {
+  return (BOOK_CAPTURE[venue] ?? []).map((e) => e.from);
+}
+
 /**
  * The cadence ONE ASSET replays at within a run: the COARSEST its date range
  * contains. Ask per asset; there is no run-wide answer by design.

package/api/lib/data-taxonomy.mjs

@@ -21,14 +21,44 @@ export const DATASETS = {
   book: 'Full-depth order-book snapshots',
   best_bid_ask: 'Top of book, unthrottled — the same best bid/ask price_change carries, at every update rather than the capture cadence; prices only, no sizes, so depth still needs book or price_change',
   price_change: 'Order-book deltas with best bid/ask',
-  last_trade_price: 'Every trade print',
+  last_trade_price: 'Trade prints, unthrottled',
   markets: 'Per-market metadata, strike and settlement outcome',
   tick_size_change: 'Tick-size changes',
   orderbook: 'Order-book snapshots (Predict.fun)',
-  klines: 'OHLCV candles derived from the settlement feed',
+  klines: 'OHLC candles derived from the settlement feed, with a tick count — no trade volume; the settlement feed is a price feed',
   other: 'Uncategorised',
 };
 
+/**
+ * The same descriptions in Chinese.
+ *
+ * HERE, not in the page that renders them. Two of these lines state the
+ * SETTLEMENT BASIS — which TWAP stream settles which market — and CLAUDE.md
+ * pins that fact to four places that must move together. A Chinese copy living
+ * in a component would be a fifth, and it would drift the way every other
+ * hand-copy in this repo has: the basis already moved once (5-minute markets
+ * settled on the 30s stream until 2026-08-07, on the 60s stream after), and an
+ * AI assistant quoted a stale copy of our coverage back to a customer.
+ *
+ * Sitting beside DATASETS means changing one entry puts the other on screen in
+ * the same diff. data-taxonomy.test.mjs asserts the key sets match, so a new
+ * dataset cannot land with only one language.
+ */
+export const DATASETS_ZH = {
+  prices: '结算价流，逐 tick（Chainlink 瞬时流）',
+  twap30s: 'TWAP 30 秒结算流——5 分钟市场改用 60 秒回看之前的结算线，至今仍逐日归档',
+  twap60s: 'TWAP 60 秒结算流——5 分钟与 15 分钟市场都判定在它上面',
+  book: '全深度盘口快照',
+  best_bid_ask: '盘口顶部，未抽稀——与 price_change 携带的是同一个最优买卖价，但每次更新都出一行，而不是按采集节奏；只有价格没有挂单量，深度仍需 book 或 price_change',
+  price_change: '盘口增量，带最优买卖价',
+  last_trade_price: '成交流，未抽稀',
+  markets: '每个市场的元数据、strike 与结算结果',
+  tick_size_change: '最小变动价位的变更',
+  orderbook: '盘口快照（Predict.fun）',
+  klines: '由结算价流推导的 OHLC K 线，带 tick 计数——没有成交量，结算流是价格流不是成交流',
+  other: '未归类',
+};
+
 const num = (s) => (s == null ? null : s);
 
 /**

package/cli/local-data.mjs

@@ -4,7 +4,7 @@
 // R2. Both go through runner/events.mjs for the row -> event mapping, because
 // the docs make a promise about exactly this pair:
 //
-//     The identical files, same checksums, same coverage report. A backtest
+//     The identical files, byte for byte, with the same checksums. A backtest
 //     here and a backtest on your own machine after subscribing read the same
 //     bytes — that is the point of offering it.
 //

package/index.d.ts

@@ -12,6 +12,13 @@
 
 export type Side = 'UP' | 'DOWN';
 
+/**
+ * How a market settled. `'TIE'` is a 50:50 settlement — Predict.fun resolves
+ * an end price equal to the start price this way, and every UP and DOWN
+ * contract pays $0.50.
+ */
+export type Outcome = Side | 'TIE';
+
 export declare const SIDES: readonly ['UP', 'DOWN'];
 
 /** One level of resting depth: [price, size]. */
@@ -129,7 +136,7 @@ export interface Ctx<P = Record<string, unknown>> {
    * one. Recorded for the cross-check panel, never enforced — a mismatch is
    * information, not a failed run.
    */
-  assert_outcome(market: unknown, outcome: Side): void;
+  assert_outcome(market: unknown, outcome: Outcome): void;
 }
 
 /**
@@ -207,7 +214,7 @@ export declare class Order {
  *     onTick(ctx: Ctx, tick: Tick): Order | null
  *     onBook(ctx: Ctx, book: BookView): Order | null
  *     onTrade(ctx: Ctx, trade: Tick): Order | null
- *     onSettle(ctx: Ctx, market: Market, outcome: Side): void
+ *     onSettle(ctx: Ctx, market: Market, outcome: Outcome): void
  */
 export declare class Strategy<P = Record<string, unknown>> {
   /** Params from the manifest, injected by the runner before the first hook. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "outcometick",
-  "version": "1.6.4",
+  "version": "1.6.5",
   "description": "Strategy SDK and CLI for outcometick prediction-market backtests",
   "type": "module",
   "license": "MIT",

package/runner/engine/portfolio.mjs

@@ -12,8 +12,24 @@
 
 import { matchOrder, isSide } from './book.mjs';
 
-/** Settlement value of one contract, given the official outcome. */
-export const contractValue = (side, outcome) => (outcome === side ? 1 : 0);
+/**
+ * A market that settled 50:50. Predict.fun resolves end_price == start_price
+ * this way: both outcome tokens pay half a dollar.
+ */
+export const OUTCOME_TIE = 'TIE';
+
+/** Every official outcome a market can settle on. */
+export const OUTCOMES = Object.freeze(['UP', 'DOWN', OUTCOME_TIE]);
+
+/**
+ * Settlement value of one contract, given the official outcome.
+ *
+ * MUST MATCH otengine.py `contract_value`, and `scripts/audit-report.py`.
+ */
+export const contractValue = (side, outcome) => {
+  if (outcome === OUTCOME_TIE) return 0.5;
+  return outcome === side ? 1 : 0;
+};
 
 const EPS = 1e-9;
 

package/runner/engine/report.mjs

@@ -8,6 +8,8 @@
 // Nothing in this module can see the strategy. It reads the trade and fill logs
 // the engine produced, so a report cannot be tuned by the thing it is judging.
 
+import { contractValue } from './portfolio.mjs';
+
 /** Entry-price buckets for the calibration panel. */
 export const CALIBRATION_BUCKETS = Object.freeze([
   [0.0, 0.1], [0.1, 0.2], [0.2, 0.3], [0.3, 0.4], [0.4, 0.5],
@@ -181,10 +183,11 @@ export function metrics(trades, { feesPaid = 0, days = 1 } = {}) {
 /**
  * Mean realised edge per contract, in dollars.
  *
- * A binary token bought at p is worth 1 if its side settles and 0 otherwise, so
- * the edge on one contract is (outcome - p). Only settled trades carry an
- * outcome; a trade closed early is edge against the market, not against the
- * truth, and is excluded rather than scored as if it had settled.
+ * A binary token bought at p is worth 1 if its side settles and 0 otherwise
+ * (0.5 on a TIE — `contractValue`), so the edge on one contract is
+ * (outcome - p). Only settled trades carry an outcome; a trade closed early is
+ * edge against the market, not against the truth, and is excluded rather than
+ * scored as if it had settled.
  */
 export function edgePerContract(trades) {
   const settled = trades.filter((t) => t.how === 'settled' && t.entry_px != null && t.outcome);
@@ -192,8 +195,7 @@ export function edgePerContract(trades) {
   let contracts = 0;
   let edge = 0;
   for (const t of settled) {
-    const won = t.outcome === t.side ? 1 : 0;
-    edge += (won - t.entry_px) * t.size;
+    edge += (contractValue(t.side, t.outcome) - t.entry_px) * t.size;
     contracts += t.size;
   }
   return contracts > 0 ? edge / contracts : 0;
@@ -207,8 +209,7 @@ export function brier(trades) {
   const settled = trades.filter((t) => t.how === 'settled' && t.entry_px != null && t.outcome);
   if (!settled.length) return null;
   return mean(settled.map((t) => {
-    const won = t.outcome === t.side ? 1 : 0;
-    return (t.entry_px - won) ** 2;
+    return (t.entry_px - contractValue(t.side, t.outcome)) ** 2;
   }));
 }
 
@@ -268,7 +269,7 @@ export function calibration(trades) {
     const inBucket = settled.filter((t) => t.entry_px >= lo && t.entry_px < hi);
     if (!inBucket.length) return null;
     const implied = mean(inBucket.map((t) => t.entry_px));
-    const realized = mean(inBucket.map((t) => (t.outcome === t.side ? 1 : 0)));
+    const realized = mean(inBucket.map((t) => contractValue(t.side, t.outcome)));
     return {
       bucket: `${lo.toFixed(2)}-${hi.toFixed(2)}`,
       lo,
@@ -298,8 +299,8 @@ export function baselines(marketSummaries, { size = 1 } = {}) {
   const out = { always_up: 0, always_down: 0, always_favourite: 0 };
   for (const m of marketSummaries) {
     if (!m.outcome || m.up_px == null || m.down_px == null) continue;
-    out.always_up += ((m.outcome === 'UP' ? 1 : 0) - m.up_px) * size;
-    out.always_down += ((m.outcome === 'DOWN' ? 1 : 0) - m.down_px) * size;
+    out.always_up += (contractValue('UP', m.outcome) - m.up_px) * size;
+    out.always_down += (contractValue('DOWN', m.outcome) - m.down_px) * size;
     // The favourite is the side the market thinks is MORE likely, and on a
     // binary market the price IS the implied probability — so it is the DEARER
     // side, not the cheaper one. This was inverted: the panel labelled "always
@@ -307,7 +308,7 @@ export function baselines(marketSummaries, { size = 1 } = {}) {
     // handed customers a backwards comparison to judge their strategy against.
     const favSide = m.up_px >= m.down_px ? 'UP' : 'DOWN';
     const favPx = Math.max(m.up_px, m.down_px);
-    out.always_favourite += ((m.outcome === favSide ? 1 : 0) - favPx) * size;
+    out.always_favourite += (contractValue(favSide, m.outcome) - favPx) * size;
   }
   return {
     always_up: r2(out.always_up),

package/runner/events.mjs

@@ -6,7 +6,7 @@
 //
 // The lesson this is applying is the one runner/conformance already enforces
 // for the two engines: two implementations of the same rules drift, and the
-// drift is silent. "The identical files, same checksums, same coverage report"
+// drift is silent. "The identical files, byte for byte, with the same checksums"
 // is a published promise about `ot run` versus a queued run — it cannot be true
 // if local and remote decode the archive differently.
 
@@ -14,6 +14,7 @@ import { classifyPath } from '../api/lib/data-taxonomy.mjs';
 import { resolveSettlementStream, degradingCoverage, inputKeys } from '../api/lib/backtest-datasets.mjs';
 import { bookThrottleMs } from '../api/lib/backtest-contract.mjs';
 import { Book } from './engine/book.mjs';
+import { OUTCOME_TIE, OUTCOMES } from './engine/portfolio.mjs';
 
 /**
  * Coerce a field to a number, or null.
@@ -146,16 +147,33 @@ function predictRecord(row) {
   const closeMs = num(row.end_sec) == null ? null : num(row.end_sec) * 1000;
   const start = num(row.start_price);
   const end = num(row.end_price);
-  // RESOLVED is the venue's own word for "this is final". An OPEN market has no
-  // outcome even if both prices are present — they are live quotes then, not a
-  // settlement, and treating them as one would hand a strategy the answer.
-  // Same rule, and the same reason: only a RESOLVED market with two readable
-  // prices has an outcome. A tie is not a guess either — the venue settles it
-  // one way and we do not know which, so the market-day is dropped.
-  const outcome = String(row.status).toUpperCase() === 'RESOLVED'
-    && start != null && end != null && end !== start
-    ? (end > start ? 'UP' : 'DOWN')
-    : null;
+  // `end_price` is the settlement marker, NOT `status`.
+  //
+  // This used to require status === 'RESOLVED', on the theory that an OPEN
+  // market's prices are live quotes rather than a settlement. Both halves were
+  // wrong. `end_price` is written only by the settlement backfill, which is
+  // driven by `end_price IS NULL` and drops a market from its re-read queue the
+  // moment it lands — so `status` is whatever the venue last said while we were
+  // still polling, and it freezes there. There is no row in the whole table
+  // with status RESOLVED and no end_price, so the implication runs one way
+  // only: end_price present ⇒ settled.
+  //
+  // MEASURED 2026-09-08, all assets: 1245 markets, every one of them with an
+  // end_price, but only 1104 said RESOLVED. The check discarded 39/873 of the
+  // 5-minute markets (4.5%) and 21/291 of the 15-minute ones (7.2%) — reported
+  // to the customer as "outcome could not be read" while the outcome was right
+  // there, and billed for, because a market-day charges whole.
+  //
+  // A TIE IS ITS OWN OUTCOME. Predict.fun settles end_price == start_price
+  // 50:50 — every UP and every DOWN contract pays $0.50 (`contractValue`).
+  // It used to be dropped because the engines only knew UP/DOWN, which cost the
+  // customer 0.53–1.20% of the 5-minute markets they paid for, reported as
+  // "outcome could not be read". Never "fix" a tie by picking a side: half of
+  // them would be scored backwards.
+  let outcome = null;
+  if (start != null && end != null) {
+    outcome = end > start ? 'UP' : end < start ? 'DOWN' : OUTCOME_TIE;
+  }
   return {
     market_id: String(row.market_id ?? row.condition_id ?? ''),
     slug: row.category_slug ?? null,
@@ -582,7 +600,7 @@ export function buildSlugIndex(markets) {
  * The coverage block, in ONE shape.
  *
  * The docs promise a local run and a queued run produce "the identical files,
- * same checksums, same coverage report". They already shared the decoder and
+ * byte for byte, with the same checksums". They already shared the decoder and
  * the feed list; the coverage object was still built twice, so `ot run` emitted
  * five keys where the queue emitted ten, and anyone diffing the two saw a
  * schema difference rather than an answer. A field a local run genuinely cannot
@@ -834,7 +852,7 @@ export function marketUnusable(market, inWindow) {
   // nothing to merge — replayed it out of the cache anyway.
   if (!market.asset) return 'market has no asset';
   if (market.stream == null) return 'settlement stream could not be resolved';
-  if (market.outcome !== 'UP' && market.outcome !== 'DOWN') {
+  if (!OUTCOMES.includes(market.outcome)) {
     return 'outcome could not be read';
   }
   if (!inWindow || inWindow.length === 0) return 'no events inside the market window';

package/runner/harness/node/sdk/index.d.ts

@@ -12,6 +12,13 @@
 
 export type Side = 'UP' | 'DOWN';
 
+/**
+ * How a market settled. `'TIE'` is a 50:50 settlement — Predict.fun resolves
+ * an end price equal to the start price this way, and every UP and DOWN
+ * contract pays $0.50.
+ */
+export type Outcome = Side | 'TIE';
+
 export declare const SIDES: readonly ['UP', 'DOWN'];
 
 /** One level of resting depth: [price, size]. */
@@ -129,7 +136,7 @@ export interface Ctx<P = Record<string, unknown>> {
    * one. Recorded for the cross-check panel, never enforced — a mismatch is
    * information, not a failed run.
    */
-  assert_outcome(market: unknown, outcome: Side): void;
+  assert_outcome(market: unknown, outcome: Outcome): void;
 }
 
 /**
@@ -207,7 +214,7 @@ export declare class Order {
  *     onTick(ctx: Ctx, tick: Tick): Order | null
  *     onBook(ctx: Ctx, book: BookView): Order | null
  *     onTrade(ctx: Ctx, trade: Tick): Order | null
- *     onSettle(ctx: Ctx, market: Market, outcome: Side): void
+ *     onSettle(ctx: Ctx, market: Market, outcome: Outcome): void
  */
 export declare class Strategy<P = Record<string, unknown>> {
   /** Params from the manifest, injected by the runner before the first hook. */

package/runner/harness/protocol.mjs

@@ -6,6 +6,7 @@
 // untrusted output — the container is the boundary, not the harness.
 //
 import { createHmac, timingSafeEqual } from 'node:crypto';
+import { OUTCOMES } from '../engine/portfolio.mjs';
 
 // This is also the reason the REPORT is not computed inside. Metrics,
 // calibration, latency and slippage are all derived outside, in one shared
@@ -159,7 +160,7 @@ export function parseTrade(raw) {
     opened_ms: finite(raw.opened_ms) ? raw.opened_ms : null,
     closed_ms: finite(raw.closed_ms) ? raw.closed_ms : null,
     how: typeof raw.how === 'string' ? raw.how : 'exit',
-    outcome: raw.outcome === 'UP' || raw.outcome === 'DOWN' ? raw.outcome : undefined,
+    outcome: OUTCOMES.includes(raw.outcome) ? raw.outcome : undefined,
   };
 }
 
@@ -232,7 +233,7 @@ export function parseResult(raw) {
       market_id: typeof m.market_id === 'string' ? m.market_id : null,
       asset: typeof m.asset === 'string' ? m.asset : null,
       interval: typeof m.interval === 'string' ? m.interval : null,
-      outcome: m.outcome === 'UP' || m.outcome === 'DOWN' ? m.outcome : null,
+      outcome: OUTCOMES.includes(m.outcome) ? m.outcome : null,
       up_px: finite(m.up_px) ? m.up_px : null,
       down_px: finite(m.down_px) ? m.down_px : null,
       stream: typeof m.stream === 'string' ? m.stream : null,

package/runner/harness/python/otengine.py

@@ -321,7 +321,14 @@ def match_order(book: Book, order: dict) -> dict:
     }
 
 
-def contract_value(side: str, outcome: str) -> int:
+OUTCOME_TIE = "TIE"
+
+
+def contract_value(side: str, outcome: str) -> float:
+    # A tie settles 50:50: both outcome tokens pay half a dollar. MUST MATCH
+    # portfolio.mjs `contractValue`.
+    if outcome == OUTCOME_TIE:
+        return 0.5
     return 1 if outcome == side else 0