@tangle-network/agent-bench 0.11.2 → 0.13.0

package/src/quant-arena/backtest.ts

@@ -1,218 +0,0 @@
-/**
- * Daily-bar event-loop backtester. Zero dependencies beyond the Node stdlib
- * (in fact: zero imports at all except the local types) so a reviewer can
- * audit the whole execution model in one file.
- *
- * Execution model (conservative by construction):
- *  - A signal decided at the close of day t is FILLED at the open of day t+1.
- *    Nothing trades on the bar that produced the decision.
- *  - Every rebalance pays `costBps + slippageBps` (basis points, one-way) on
- *    the dollars traded, deducted from cash at the fill.
- *  - No shorting, no leverage: weights >= 0, sum <= 1. Violations THROW —
- *    a strategy that asks for leverage is a broken candidate, not a clamped one.
- *  - Cash earns 0. A fully-invested target therefore carries a small negative
- *    cash balance equal to accumulated fees (fees financed at 0% — this only
- *    ever understates performance, never flatters it).
- *
- * Determinism: pure function of (bars, signals, config). No clock, no RNG.
- */
-
-import type { Bar, Signal } from './types.ts'
-
-export interface BacktestConfig {
-  /** One-way transaction cost, basis points of traded dollars. */
-  costBps: number
-  /** One-way slippage, basis points of traded dollars. */
-  slippageBps: number
-}
-
-export const TRADING_DAYS_PER_YEAR = 252
-
-export interface RangeStats {
-  /** First/last day index of the scored range (inclusive start, exclusive end). */
-  start: number
-  end: number
-  days: number
-  totalReturn: number
-  maxDrawdown: number
-  /** Annualized Sharpe of daily returns (rf = 0). 0 when volatility is 0. */
-  sharpe: number
-  /** Fills with |trade| > 1e-9 × equity, summed over the range. */
-  tradeCount: number
-  /** Σ traded dollars / equity at each rebalance (two-sided turnover). */
-  turnover: number
-}
-
-export interface BacktestResult {
-  dates: string[]
-  /** Equity at each day's close; equity[0] = 1 (all cash at the first close). */
-  equity: number[]
-  /** dailyReturns[i] = equity[i+1] / equity[i] - 1. */
-  dailyReturns: number[]
-  /** Per-day fill count / turnover fraction (index = fill day). */
-  fillsByDay: number[]
-  turnoverByDay: number[]
-  stats: RangeStats
-}
-
-const WEIGHT_EPS = 1e-9
-
-export function assertAligned(bars: Bar[][]): void {
-  if (bars.length === 0) throw new Error('backtest: empty universe')
-  const T = bars[0]!.length
-  if (T < 2) throw new Error('backtest: need at least 2 days of bars')
-  for (let k = 1; k < bars.length; k++) {
-    if (bars[k]!.length !== T) {
-      throw new Error(`backtest: ticker ${k} has ${bars[k]!.length} bars, ticker 0 has ${T} — unaligned`)
-    }
-    for (let t = 0; t < T; t++) {
-      if (bars[k]![t]!.date !== bars[0]![t]!.date) {
-        throw new Error(`backtest: date mismatch at t=${t}: ${bars[k]![t]!.date} vs ${bars[0]![t]!.date}`)
-      }
-    }
-  }
-}
-
-/** Validate one signal against the contract. Throws on violation. */
-export function assertSignal(signal: Signal, tickers: number, totalDays: number): void {
-  if (!Number.isInteger(signal.t) || signal.t < 0 || signal.t >= totalDays) {
-    throw new Error(`backtest: signal.t=${signal.t} outside [0, ${totalDays})`)
-  }
-  if (signal.weights.length !== tickers) {
-    throw new Error(`backtest: signal at t=${signal.t} has ${signal.weights.length} weights, universe has ${tickers}`)
-  }
-  let sum = 0
-  for (const w of signal.weights) {
-    if (!Number.isFinite(w)) throw new Error(`backtest: non-finite weight at t=${signal.t}`)
-    if (w < -WEIGHT_EPS) throw new Error(`backtest: negative weight ${w} at t=${signal.t} — no shorting`)
-    sum += w
-  }
-  if (sum > 1 + 1e-6) throw new Error(`backtest: weights sum ${sum} > 1 at t=${signal.t} — no leverage`)
-}
-
-/** Map of decision day -> target weights. A rebalance is executed ONLY at the
- *  open following an emitted signal; between signals, positions drift with
- *  prices (no silent daily re-targeting, no hidden fee drag). */
-export function fillSchedule(signals: Signal[], tickers: number, totalDays: number): Map<number, number[]> {
-  const sorted = [...signals].sort((a, b) => a.t - b.t)
-  for (let i = 1; i < sorted.length; i++) {
-    if (sorted[i]!.t === sorted[i - 1]!.t) {
-      throw new Error(`backtest: two signals share t=${sorted[i]!.t} — a strategy emits at most one target per day`)
-    }
-  }
-  const schedule = new Map<number, number[]>()
-  for (const s of sorted) {
-    assertSignal(s, tickers, totalDays)
-    schedule.set(s.t, s.weights)
-  }
-  return schedule
-}
-
-export function runBacktest(bars: Bar[][], signals: Signal[], config: BacktestConfig): BacktestResult {
-  assertAligned(bars)
-  const N = bars.length
-  const T = bars[0]!.length
-  const fills = fillSchedule(signals, N, T)
-  const feeRate = (config.costBps + config.slippageBps) / 10_000
-
-  const equity: number[] = new Array(T).fill(0)
-  const fillsByDay: number[] = new Array(T).fill(0)
-  const turnoverByDay: number[] = new Array(T).fill(0)
-  let cash = 1
-  const pos: number[] = new Array(N).fill(0)
-  equity[0] = 1
-
-  for (let t = 1; t < T; t++) {
-    // Overnight: yesterday's close -> today's open.
-    for (let k = 0; k < N; k++) {
-      const prevClose = bars[k]![t - 1]!.close
-      if (prevClose <= 0) throw new Error(`backtest: nonpositive close for ticker ${k} at t=${t - 1}`)
-      pos[k] = pos[k]! * (bars[k]![t]!.open / prevClose)
-    }
-    // Fill the target decided at yesterday's close, at today's open.
-    const target = fills.get(t - 1)
-    if (target !== undefined) {
-      let equityOpen = cash
-      for (let k = 0; k < N; k++) equityOpen += pos[k]!
-      if (equityOpen <= 0) throw new Error(`backtest: equity wiped out at t=${t}`)
-      let traded = 0
-      let fills = 0
-      for (let k = 0; k < N; k++) {
-        const desired = target[k]! * equityOpen
-        const delta = desired - pos[k]!
-        traded += Math.abs(delta)
-        if (Math.abs(delta) > WEIGHT_EPS * equityOpen) fills++
-        cash -= delta
-        pos[k] = desired
-      }
-      const fee = traded * feeRate
-      cash -= fee
-      fillsByDay[t] = fills
-      turnoverByDay[t] = traded / equityOpen
-    }
-    // Intraday: today's open -> today's close.
-    for (let k = 0; k < N; k++) {
-      const open = bars[k]![t]!.open
-      if (open <= 0) throw new Error(`backtest: nonpositive open for ticker ${k} at t=${t}`)
-      pos[k] = pos[k]! * (bars[k]![t]!.close / open)
-    }
-    let eq = cash
-    for (let k = 0; k < N; k++) eq += pos[k]!
-    equity[t] = eq
-  }
-
-  const dailyReturns: number[] = new Array(T - 1)
-  for (let i = 0; i < T - 1; i++) dailyReturns[i] = equity[i + 1]! / equity[i]! - 1
-
-  const result: BacktestResult = {
-    dates: bars[0]!.map((b) => b.date),
-    equity,
-    dailyReturns,
-    fillsByDay,
-    turnoverByDay,
-    stats: undefined as unknown as RangeStats,
-  }
-  result.stats = statsForRange(result, 0, T)
-  return result
-}
-
-/** Score a sub-range [start, end) of an existing backtest — the walk-forward
- *  window view. Positions carried into the window count; nothing after `end`
- *  leaks in. */
-export function statsForRange(result: BacktestResult, start: number, end: number): RangeStats {
-  const T = result.equity.length
-  if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end > T || end - start < 2) {
-    throw new Error(`statsForRange: bad range [${start}, ${end}) over ${T} days`)
-  }
-  const eq = result.equity.slice(start, end)
-  const totalReturn = eq[eq.length - 1]! / eq[0]! - 1
-  let peak = eq[0]!
-  let maxDrawdown = 0
-  for (const e of eq) {
-    if (e > peak) peak = e
-    const dd = (peak - e) / peak
-    if (dd > maxDrawdown) maxDrawdown = dd
-  }
-  const returns = result.dailyReturns.slice(start, end - 1)
-  const n = returns.length
-  const mean = returns.reduce((s, r) => s + r, 0) / n
-  const variance = n > 1 ? returns.reduce((s, r) => s + (r - mean) ** 2, 0) / (n - 1) : 0
-  const std = Math.sqrt(variance)
-  const sharpe = std > 0 ? (mean / std) * Math.sqrt(TRADING_DAYS_PER_YEAR) : 0
-  let tradeCount = 0
-  let turnover = 0
-  for (let t = start + 1; t < end; t++) {
-    tradeCount += result.fillsByDay[t]!
-    turnover += result.turnoverByDay[t]!
-  }
-  return {
-    start,
-    end,
-    days: end - start,
-    totalReturn,
-    maxDrawdown,
-    sharpe,
-    tradeCount,
-    turnover,
-  }
-}

package/src/quant-arena/data.test.mts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { readdir } from 'node:fs/promises'
-import {
-  HOLDOUT_DIR,
-  HOLDOUT_START,
-  IN_SAMPLE_DIR,
-  INDEX_TICKER,
-  loadInSample,
-  parseStooqCsv,
-} from './data.ts'
-
-describe('parseStooqCsv', () => {
-  it('parses the vendored CSV format', () => {
-    const bars = parseStooqCsv('Date,Open,High,Low,Close,Volume\n2020-01-02,10,11,9,10.5,12345\n2020-01-03,10.5,12,10,11,999\n', 'test')
-    expect(bars).toHaveLength(2)
-    expect(bars[0]).toEqual({ date: '2020-01-02', open: 10, high: 11, low: 9, close: 10.5, volume: 12345 })
-  })
-
-  it('fails loud on descending dates, bad prices, and foreign headers', () => {
-    expect(() => parseStooqCsv('Date,Open,High,Low,Close,Volume\n2020-01-03,10,11,9,10,1\n2020-01-02,10,11,9,10,1\n', 't')).toThrow(/ascending/)
-    expect(() => parseStooqCsv('Date,Open,High,Low,Close,Volume\n2020-01-02,0,11,9,10,1\n', 't')).toThrow(/nonpositive/)
-    expect(() => parseStooqCsv('Ticker,Per,Date\nX,D,2020\n', 't')).toThrow(/header/)
-  })
-})
-
-describe('vendored fixture integrity (in-sample side only — the holdout is not read here)', () => {
-  it('in-sample and holdout are physically separate directories with the same tickers', async () => {
-    const inFiles = (await readdir(IN_SAMPLE_DIR)).filter((f) => f.endsWith('.csv')).sort()
-    const outFiles = (await readdir(HOLDOUT_DIR)).filter((f) => f.endsWith('.csv')).sort()
-    expect(inFiles).toEqual(outFiles)
-    expect(inFiles).toContain(`${INDEX_TICKER}.csv`)
-    expect(inFiles.length).toBe(11)
-  })
-
-  it('loadInSample aligns the universe, leads with the index, and never crosses into the holdout era', async () => {
-    const aligned = await loadInSample()
-    expect(aligned.tickers[0]).toBe(INDEX_TICKER)
-    expect(aligned.tickers).toHaveLength(11)
-    expect(aligned.bars).toHaveLength(11)
-    for (const series of aligned.bars) expect(series).toHaveLength(aligned.dates.length)
-    expect(aligned.dates.length).toBeGreaterThan(1800)
-    expect(aligned.dates[aligned.dates.length - 1]! < HOLDOUT_START).toBe(true)
-  })
-})

package/src/quant-arena/data.ts

@@ -1,141 +0,0 @@
-/**
- * Vendored daily-bar data: Stooq-format CSVs (Date,Open,High,Low,Close,Volume)
- * committed under fixtures/data/. Two physically separate directories:
- *
- *   fixtures/data/insample/  — everything the campaign loop may read.
- *   fixtures/data/holdout/   — the FINAL 2 years. Loaded ONLY by the
- *                              certification path (holdout-certify.mts).
- *                              quant-loop.mts never imports `loadHoldout`.
- *
- * See fixtures/data/PROVENANCE.md for where the series come from.
- */
-
-import { readdir, readFile } from 'node:fs/promises'
-import { basename, join } from 'node:path'
-import { fileURLToPath } from 'node:url'
-import type { Bar } from './types.ts'
-
-export const DATA_DIR = fileURLToPath(new URL('./fixtures/data', import.meta.url))
-export const IN_SAMPLE_DIR = join(DATA_DIR, 'insample')
-export const HOLDOUT_DIR = join(DATA_DIR, 'holdout')
-/** First holdout date — insample bars must all be strictly before this. */
-export const HOLDOUT_START = '2024-07-01'
-/** The benchmark index ticker; always bars[0] in the aligned universe. */
-export const INDEX_TICKER = 'IDX'
-
-export interface AlignedBars {
-  /** tickers[0] === INDEX_TICKER; the rest sorted alphabetically. */
-  tickers: string[]
-  dates: string[]
-  /** bars[k] belongs to tickers[k]; every series shares the date axis. */
-  bars: Bar[][]
-}
-
-export function parseStooqCsv(text: string, source: string): Bar[] {
-  const lines = text.split('\n').map((l) => l.trim()).filter((l) => l.length > 0)
-  if (lines.length < 2) throw new Error(`${source}: empty CSV`)
-  const header = lines[0]!.toLowerCase()
-  if (!header.startsWith('date,open,high,low,close')) {
-    throw new Error(`${source}: unexpected header '${lines[0]}'`)
-  }
-  const bars: Bar[] = []
-  for (const line of lines.slice(1)) {
-    const cells = line.split(',')
-    if (cells.length < 5) throw new Error(`${source}: bad row '${line}'`)
-    const [date, open, high, low, close, volume] = cells
-    const bar: Bar = {
-      date: date!,
-      open: Number(open),
-      high: Number(high),
-      low: Number(low),
-      close: Number(close),
-      volume: volume !== undefined ? Number(volume) : 0,
-    }
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(bar.date)) throw new Error(`${source}: bad date '${bar.date}'`)
-    for (const v of [bar.open, bar.high, bar.low, bar.close]) {
-      if (!Number.isFinite(v) || v <= 0) throw new Error(`${source}: nonpositive price on ${bar.date}`)
-    }
-    bars.push(bar)
-  }
-  for (let i = 1; i < bars.length; i++) {
-    if (bars[i]!.date <= bars[i - 1]!.date) {
-      throw new Error(`${source}: dates not strictly ascending at ${bars[i]!.date}`)
-    }
-  }
-  return bars
-}
-
-/** Load every `<TICKER>.csv` in a directory and align on the intersection of
- *  dates. The index ticker leads; the rest follow alphabetically. */
-export async function loadBarsDir(dir: string): Promise<AlignedBars> {
-  const files = (await readdir(dir)).filter((f) => f.endsWith('.csv')).sort()
-  if (files.length === 0) throw new Error(`loadBarsDir: no CSVs in ${dir}`)
-  const byTicker = new Map<string, Bar[]>()
-  for (const file of files) {
-    const ticker = basename(file, '.csv')
-    byTicker.set(ticker, parseStooqCsv(await readFile(join(dir, file), 'utf8'), join(dir, file)))
-  }
-  if (!byTicker.has(INDEX_TICKER)) {
-    throw new Error(`loadBarsDir: ${dir} has no ${INDEX_TICKER}.csv — the universe needs its benchmark index`)
-  }
-  const tickers = [INDEX_TICKER, ...[...byTicker.keys()].filter((t) => t !== INDEX_TICKER).sort()]
-  let shared: Set<string> | null = null
-  for (const ticker of tickers) {
-    const tickerDates = new Set(byTicker.get(ticker)!.map((b) => b.date))
-    if (shared === null) {
-      shared = tickerDates
-    } else {
-      const carried: Set<string> = shared
-      shared = new Set([...carried].filter((d) => tickerDates.has(d)))
-    }
-  }
-  const dates = [...shared!].sort()
-  if (dates.length < 2) throw new Error(`loadBarsDir: fewer than 2 shared dates across ${dir}`)
-  const bars = tickers.map((ticker) => {
-    const wanted = new Set(dates)
-    return byTicker.get(ticker)!.filter((b) => wanted.has(b.date))
-  })
-  return { tickers, dates, bars }
-}
-
-/** The campaign loop's data. Fails loud if any bar strays into the holdout era. */
-export async function loadInSample(): Promise<AlignedBars> {
-  const aligned = await loadBarsDir(IN_SAMPLE_DIR)
-  const last = aligned.dates[aligned.dates.length - 1]!
-  if (last >= HOLDOUT_START) {
-    throw new Error(`loadInSample: in-sample data reaches ${last}, at/past the holdout start ${HOLDOUT_START}`)
-  }
-  return aligned
-}
-
-/** CERTIFICATION PATH ONLY (holdout-certify.mts). The final 2 years. */
-export async function loadHoldout(): Promise<AlignedBars> {
-  const aligned = await loadBarsDir(HOLDOUT_DIR)
-  const first = aligned.dates[0]!
-  if (first < HOLDOUT_START) {
-    throw new Error(`loadHoldout: holdout data starts ${first}, before the holdout start ${HOLDOUT_START}`)
-  }
-  return aligned
-}
-
-/** In-sample followed by holdout on one axis — what the certification run
- *  backtests so lookback indicators are warm when the holdout period begins.
- *  Returns the concatenated universe plus the index of the first holdout day. */
-export function concatForCertification(insample: AlignedBars, holdout: AlignedBars): { aligned: AlignedBars; holdoutStartIndex: number } {
-  if (insample.tickers.join(',') !== holdout.tickers.join(',')) {
-    throw new Error('concatForCertification: in-sample and holdout universes differ')
-  }
-  const lastIn = insample.dates[insample.dates.length - 1]!
-  const firstOut = holdout.dates[0]!
-  if (firstOut <= lastIn) {
-    throw new Error(`concatForCertification: holdout starts ${firstOut}, not after in-sample end ${lastIn}`)
-  }
-  return {
-    aligned: {
-      tickers: insample.tickers,
-      dates: [...insample.dates, ...holdout.dates],
-      bars: insample.bars.map((series, k) => [...series, ...holdout.bars[k]!]),
-    },
-    holdoutStartIndex: insample.dates.length,
-  }
-}

package/src/quant-arena/driver.test.mts

@@ -1,253 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import { runBacktest } from './backtest.ts'
-import { generateSignalsFromStrategy, runIncremental, strategyFromGenerateSignals } from './driver.ts'
-import { truncationInvariance } from './leak-audit.ts'
-import { rebalance, targetsToWeights } from './oms.ts'
-import { generateSignals as buyHold } from './strategies/buy-hold-index/strategy.ts'
-import { generateSignals as equalWeight } from './strategies/equal-weight/strategy.ts'
-import { generateSignals as smaCrossover } from './strategies/sma-crossover/strategy.ts'
-import type { Bar, Signal, Strategy, StrategyContext } from './types.ts'
-
-/** Deterministic wiggly price path (no RNG — reproducible). */
-function syntheticBars(n: number, tickers: number): Bar[][] {
-  return Array.from({ length: tickers }, (_, k) =>
-    Array.from({ length: n }, (_, t) => {
-      const close = 100 + 10 * Math.sin(t / 7 + k) + 0.05 * t
-      const open = 100 + 10 * Math.sin((t - 0.5) / 7 + k) + 0.05 * t
-      return {
-        date: `d${String(t).padStart(4, '0')}`,
-        open,
-        high: Math.max(open, close) + 1,
-        low: Math.min(open, close) - 1,
-        close,
-        volume: 1000,
-      }
-    }),
-  )
-}
-
-const symbolsFor = (bars: Bar[][]): string[] => bars.map((_, k) => (k === 0 ? 'IDX' : `T${k}`))
-const config = (bars: Bar[][]) => ({ costBps: 10, slippageBps: 5, symbols: symbolsFor(bars) })
-
-describe('runIncremental — structural history visibility', () => {
-  const bars = syntheticBars(120, 3)
-
-  it('every onBar call sees exactly bars[0..t] and nothing beyond', () => {
-    let calls = 0
-    const spy: Strategy = {
-      onBar(ctx: StrategyContext) {
-        calls++
-        for (let k = 0; k < ctx.history.length; k++) {
-          expect(ctx.history[k]!.length).toBe(ctx.t + 1)
-          // The future is ABSENT, not merely guarded.
-          expect(ctx.history[k]![ctx.t + 1]).toBeUndefined()
-          expect(ctx.history[k]![ctx.t]!.date).toBe(bars[k]![ctx.t]!.date)
-        }
-        return null
-      },
-    }
-    runIncremental(bars, spy, config(bars))
-    expect(calls).toBe(120)
-  })
-
-  it('driver equity path is bit-identical to runBacktest on the collected decisions', () => {
-    const strategy = strategyFromGenerateSignals(smaCrossover)
-    const run = runIncremental(bars, strategy, config(bars))
-    const reference = runBacktest(bars, run.decisions, { costBps: 10, slippageBps: 5 })
-    expect(run.equityByDay.length).toBe(reference.equity.length)
-    for (let t = 0; t < run.equityByDay.length; t++) {
-      expect(run.equityByDay[t]).toBe(reference.equity[t])
-    }
-  })
-
-  it('ctx.weights and ctx.equity reflect the drifted portfolio', () => {
-    const seen: Array<{ t: number; equity: number; weightSum: number }> = []
-    const holdIndex: Strategy = {
-      onBar(ctx) {
-        seen.push({ t: ctx.t, equity: ctx.equity, weightSum: ctx.weights.reduce((s, w) => s + w, 0) })
-        return ctx.t === 0 ? [{ symbol: 'IDX', weight: 1 }] : null
-      },
-    }
-    const run = runIncremental(bars, holdIndex, config(bars))
-    expect(seen[0]!.equity).toBe(1)
-    expect(seen[0]!.weightSum).toBe(0) // all cash before the first fill
-    // After the t=0 decision fills at t=1's open, the book is ~fully invested.
-    expect(seen[1]!.weightSum).toBeGreaterThan(0.99)
-    expect(run.decisions).toEqual([{ t: 0, weights: [1, 0, 0] }])
-  })
-
-  it('a decision on the final bar is recorded but produces no fill', () => {
-    const lastBarOnly: Strategy = {
-      onBar(ctx) {
-        return ctx.t === bars[0]!.length - 1 ? [{ symbol: 'IDX', weight: 1 }] : null
-      },
-    }
-    const run = runIncremental(bars, lastBarOnly, config(bars))
-    expect(run.decisions.length).toBe(1)
-    expect(run.equityByDay.every((e) => e === 1)).toBe(true) // never traded
-  })
-
-  it('fail-closed on contract violations from onBar', () => {
-    const short: Strategy = { onBar: () => [{ symbol: 'IDX', weight: -0.2 }] }
-    expect(() => runIncremental(bars, short, config(bars))).toThrow(/long-only|negative/)
-    const levered: Strategy = {
-      onBar: () => [
-        { symbol: 'IDX', weight: 0.8 },
-        { symbol: 'T1', weight: 0.5 },
-      ],
-    }
-    expect(() => runIncremental(bars, levered, config(bars))).toThrow(/sum.*> 1/)
-    const unknown: Strategy = { onBar: () => [{ symbol: 'NOPE', weight: 0.5 }] }
-    expect(() => runIncremental(bars, unknown, config(bars))).toThrow(/unknown symbol/)
-  })
-})
-
-describe('batch-compat shim — the 3 pinned baselines run unchanged', () => {
-  const bars = syntheticBars(400, 4)
-
-  for (const [name, generateSignals] of [
-    ['buy-hold-index', buyHold],
-    ['equal-weight', equalWeight],
-    ['sma-crossover', smaCrossover],
-  ] as const) {
-    it(`${name}: incremental drive reproduces the batch signals exactly`, () => {
-      const batch = generateSignals(bars)
-      const incremental = generateSignalsFromStrategy(strategyFromGenerateSignals(generateSignals))(bars)
-      expect(incremental).toEqual(batch)
-    })
-  }
-})
-
-describe('leak audit under the v2 harness', () => {
-  const bars = syntheticBars(400, 3)
-
-  /** Deliberately leaky: sizes today's weight by TOMORROW's return (same
-   *  fixture class as leak-audit.test.mts, which keeps guarding the v1 path). */
-  const peekAhead = (input: Bar[][]): Signal[] => {
-    const T = input[0]!.length
-    const signals: Signal[] = []
-    for (let t = 0; t < T - 1; t++) {
-      const up = input[0]![t + 1]!.close > input[0]![t]!.close
-      signals.push({ t, weights: input.map((_, k) => (k === 0 && up ? 1 : 0)) })
-    }
-    return signals
-  }
-
-  /** Leaky via whole-series statistics over the FULL sample. */
-  const fullSampleMax = (input: Bar[][]): Signal[] => {
-    const maxClose = Math.max(...input[0]!.map((b) => b.close))
-    const T = input[0]!.length
-    const signals: Signal[] = []
-    for (let t = 0; t < T; t++) {
-      signals.push({ t, weights: input.map((_, k) => (k === 0 ? input[0]![t]!.close / maxClose : 0)) })
-    }
-    return signals
-  }
-
-  it('v1 truncation audit still catches both leaky strategies as written', () => {
-    expect(truncationInvariance(peekAhead, bars, { warmupDays: 50 }).clean).toBe(false)
-    expect(truncationInvariance(fullSampleMax, bars, { warmupDays: 50 }).clean).toBe(false)
-  })
-
-  it('the incremental harness neutralizes the batch peek-ahead (its signal can never fire)', () => {
-    // Under the driver the shim hands the strategy TRUNCATED history: the
-    // peek-ahead can only emit a signal for day t once it has seen t+1, so
-    // "today's" signal never exists at decision time — zero trades, leak
-    // structurally neutralized (and still caught as written by the v1 audit).
-    const run = runIncremental(bars, strategyFromGenerateSignals(peekAhead), config(bars))
-    expect(run.decisions).toEqual([])
-    expect(run.orders).toEqual([])
-  })
-
-  it('a v2-native strategy reaching past today crashes on absent data — fail-closed', () => {
-    const v2Peeker: Strategy = {
-      onBar(ctx) {
-        // ctx.history physically ends at today; tomorrow is undefined.
-        const up = ctx.history[0]![ctx.t + 1]!.close > ctx.history[0]![ctx.t]!.close
-        return up ? [{ symbol: 'IDX', weight: 1 }] : null
-      },
-    }
-    expect(() => runIncremental(bars, v2Peeker, config(bars))).toThrow()
-  })
-
-  it('the incremental harness defuses whole-series leaks into causal decisions', () => {
-    // Driven bar-by-bar, "max over the whole series" becomes "max up to
-    // today": different decisions than the batch run, but causal — the
-    // truncation audit on the DRIVEN strategy is clean by construction.
-    const driven = generateSignalsFromStrategy(strategyFromGenerateSignals(fullSampleMax))
-    expect(truncationInvariance(driven, bars, { warmupDays: 50 }).clean).toBe(true)
-    expect(driven(bars)).not.toEqual(fullSampleMax(bars))
-  })
-})
-
-describe('oms — the shared rebalancer', () => {
-  it('targetsToWeights expands sparse targets and enforces the contract', () => {
-    const symbols = ['IDX', 'A', 'B']
-    expect(targetsToWeights([{ symbol: 'A', weight: 0.6 }], symbols)).toEqual([0, 0.6, 0])
-    expect(() => targetsToWeights([{ symbol: 'A', weight: 0.6 }, { symbol: 'A', weight: 0.1 }], symbols)).toThrow(
-      /twice/,
-    )
-    expect(() => targetsToWeights([{ symbol: 'A', weight: Number.NaN }], symbols)).toThrow(/non-finite/)
-  })
-
-  it('sizes orders LEAN-style: qty = (targetWeight * equity - positionValue) / price', () => {
-    const orders = rebalance({
-      targets: [
-        { symbol: 'A', weight: 0.5 },
-        { symbol: 'B', weight: 0 },
-      ],
-      symbols: ['IDX', 'A', 'B'],
-      equity: 2,
-      prices: [100, 50, 20],
-      positionValues: [0, 0.5, 0.5],
-      t: 42,
-      tag: 'cand-x',
-    })
-    expect(orders).toEqual([
-      // buy A: (0.5 * 2 - 0.5) / 50 = 0.01 shares
-      { clientOrderId: 'qa-t42-A', symbol: 'A', side: 'buy', qty: 0.01, type: 'market', tif: 'day', tag: 'cand-x' },
-      // sell B to flat: 0.5 / 20 = 0.025 shares
-      { clientOrderId: 'qa-t42-B', symbol: 'B', side: 'sell', qty: 0.025, type: 'market', tif: 'day', tag: 'cand-x' },
-    ])
-  })
-
-  it('suppresses dust and emits nothing on a no-op rebalance', () => {
-    const orders = rebalance({
-      targets: [{ symbol: 'A', weight: 0.5 }],
-      symbols: ['IDX', 'A'],
-      equity: 1,
-      prices: [100, 50],
-      positionValues: [0, 0.5],
-      t: 7,
-    })
-    expect(orders).toEqual([])
-  })
-
-  it('order ids are deterministic per (t, symbol)', () => {
-    const make = () =>
-      rebalance({
-        targets: [{ symbol: 'A', weight: 0.3 }],
-        symbols: ['IDX', 'A'],
-        equity: 1,
-        prices: [100, 50],
-        positionValues: [0, 0],
-        t: 9,
-      })
-    expect(make()).toEqual(make())
-    expect(make()[0]!.clientOrderId).toBe('qa-t9-A')
-  })
-
-  it('strategies cannot smuggle orders: only weights cross the seam', () => {
-    // The driver hands onBar's return value to targetsToWeights, which
-    // rejects anything that is not {symbol, weight} rows summing sanely.
-    const bars = syntheticBars(30, 2)
-    const smuggler = {
-      onBar: () => [{ symbol: 'IDX', weight: 0.5, side: 'buy', qty: 999 }],
-    } as unknown as Strategy
-    // Extra fields are ignored — the OMS reads ONLY symbol + weight; the
-    // emitted order comes out of the shared sizing rule, not the strategy.
-    const run = runIncremental(bars, smuggler, { costBps: 10, slippageBps: 5, symbols: ['IDX', 'T1'] })
-    expect(run.orders.every((o) => o.qty < 1)).toBe(true)
-    expect(run.orders[0]!.clientOrderId).toMatch(/^qa-t0-IDX$/)
-  })
-})