pokertools-arena 0.4.0

package/docs/releases/RELEASE_NOTES.md

@@ -0,0 +1,171 @@
+# Release notes
+
+## 0.4.0 — Methodology, reproducibility and repository organization
+
+This release does not redesign the 0.3.0 decision foundations. It makes the
+benchmark more rigorous, separates the questions being answered, and reorganizes
+the repository so there is one source of truth for code, tools, tests and
+documentation.
+
+### Repository
+
+- Browser application source now lives under `src/` (`src/app.js`,
+  `src/index.html`, `src/styles.css`, `src/lib/decision-core.js`,
+  `src/benchmark/scenarios.js`, `src/env/arena-env.js`, `src/shims/crypto.cjs`,
+  `src/assets/`). There are no duplicate root copies.
+- Developer-only implementation lives under `tools/diagnostics/` and
+  `tools/release/`; tests are grouped into `tests/unit`, `tests/integration`,
+  `tests/real` and `tests/analysis`; documentation lives under `docs/`.
+- `build.mjs`, `bin/pokertools-arena.mjs`, every import, npm script, GitHub
+  workflow and documentation link were updated for the new layout.
+
+### Methodology
+
+- **Paired fixed-state corpus** (`tools/diagnostics/corpus.js`): immutable,
+  production-shaped decision states covering strict legality/dominance, value
+  betting, bluffing, preflop, hand recognition and representation sensitivity.
+  Gold answers exist only where strict dominance or an explicit synthetic
+  opponent policy makes them deterministic.
+- **Paired flat-vs-hierarchical test** (`tools/diagnostics/paired.js`): the same
+  model, state, context, mode and representation under both architectures, with
+  deterministic interleaving and a recorded `experimentSeed`. This is the
+  primary architecture comparison; real tournaments are end-to-end validation.
+- **Family vs sizing correctness** are reported separately, with sizing accuracy
+  conditional on a correct family, plus final-action accuracy.
+- **`fragmentation_flip_rate`**: the share of paired runs whose broad family
+  changes when only the number of same-family sizing choices changes, across
+  menus A/B/C/D and multiple states.
+- **Exact entropy validation and domain labelling**: `familyEntropyBits`,
+  `sizingEntropyBits` and `flatActionEntropyBits`; a generic “entropy” is never
+  reported.
+- **Standardized counters** (`tools/diagnostics/counters.js`): `pokerDecisions`,
+  `familyModelCalls`, `sizingModelCalls`, `spectatorModelCalls`,
+  `totalModelCalls`, `httpRequests`, `httpRetries`, `rateLimitResponses`,
+  `decisionErrors`, `fallbackActions`, `protocolFallbacks`, with asserted
+  relationships.
+- **Wilson 95% confidence intervals and sample sizes** for behavioral
+  proportions, so 2/2 and 100/100 are not presented with equal strength.
+- **One generated summary** (`tools/diagnostics/report.js`) drives every
+  human-readable report; a release test fails if committed documentation drifts
+  from the machine-readable totals.
+- **Spectator explanations default off** in rigorous runs; when enabled they are
+  isolated and counted separately.
+- **Size-bucket boundary audit** for tiny/huge stacks, min-bet/min-raise edges,
+  all-in below min raise, all-in near LARGE, pot smaller than the big blind,
+  heads-up, multiway and post-elimination states.
+
+### Testing and CI
+
+- `npm run test:unit`, `test:integration`, `test:real`, `test:tournament-ab`,
+  `report:diagnostics` and `release:archive` replace the ad-hoc script names.
+- CI runs install → build → release checks → unit/fairness → integration and
+  never requires real API credentials. Real diagnostics run from a manual,
+  secret-gated workflow.
+- The release archive is built from the new layout, excludes secrets/logs/dist,
+  and is verified by an archive-content regression test.
+
+### Compatibility
+
+- The browser build, GitHub Pages deployment, `npx pokertools-arena` launcher and
+  automatic `.env` bootstrap are preserved.
+- `@pokertools/engine@1.0.20` and `@pokertools/evaluator@1.0.20` are unchanged.
+- The `.env` file is never moved, printed or archived.
+
+## 0.3.0 — Fair hierarchical decisions, Strategy/Raw modes, deterministic hand evaluation
+
+This release is a fairness and correctness release. It changes how the benchmark
+turns a poker state into a decision so that CHECK, CALL, FOLD, BET and RAISE are
+represented fairly for **every** model, regardless of how many bet sizes an
+arena happens to generate.
+
+### The problem
+
+A single passive strategy was represented by one class (e.g. `CHECK`) while a
+single aggressive strategy could be represented by many classes (`BET 1 BB`,
+`BET 2 BB`, `BET 3 BB`, …, `BET ALL-IN`). Under a flat argmax this fragmenting
+of the aggressive probability mass made passive actions look dominant even when
+the model's total aggressive probability was larger.
+
+### What changed
+
+- **Hierarchical decision architecture (`hierarchical-v1`).** Every model is now
+  asked two questions:
+  1. **Action family** — `CHECK`/`BET` when nothing is owed, or
+     `FOLD`/`CALL`/`RAISE` when facing a bet. Only legal families are exposed.
+  2. **Size** — only when the family is `BET` or `RAISE`, from a deterministic,
+     engine-validated size set (`SMALL`, `MEDIUM`, `LARGE`, `ALL_IN`).
+  A single passive strategy is one family; a single aggressive strategy is one
+  family. The model cannot change the family during the sizing step.
+- **One canonical decision contract.** `src/lib/decision-core.js` is the single
+  source of truth for decision state, action families, sizing choices, Jev
+  questions, chat schemas and the final engine action. Production, diagnostics
+  and tests all use the same functions.
+- **Deterministic sizing.** `legalAggressiveSizes(engine, seat, family)` clamps
+  to the available stack, respects the minimum bet/raise, deduplicates and drops
+  near-duplicate amounts, always includes all-in when materially distinct, and
+  works for short stacks (a single `ALL_IN` or `SMALL`/`ALL_IN` is valid).
+- **No prose in the primary decision.** Chat models no longer return
+  `publicReason` inside the action call. The primary contract contains only
+  typed decision fields. Spectator explanations are a separate, isolated,
+  off-the-clock concern (disabled by default; Jev never gets fabricated prose).
+- **Strategy / Raw benchmark modes.** A tournament-wide setting:
+  * **Strategy** — every model receives a deterministic `heroHand`
+    (`{ category, description }`) generated by `@pokertools/evaluator`.
+  * **Raw cognition** — no `heroHand`; models infer strength from raw cards.
+  The mode applies to all seats and is recorded in tournament state, logs,
+  reports and replays. Opponent hand evaluations are never exposed.
+- **Representation modes.** `canonical_json` (default), `compact_json` and
+  `markdown`, applied to every seat.
+- **Shared action clock.** The family and size calls share one abort signal and
+  one action clock. A model does not receive a fresh timer for the sizing stage.
+- **Decision event schema.** `decisionMeta` now carries
+  `decisionArchitecture`, `family` and `sizing` (choice, probabilities,
+  confidence, latency) plus `finalAction`. Events record `primaryDecisionLatencyMs`
+  (family latency + sizing latency, excluding spectator explanations).
+- **Legacy aggregation.** `aggregateActionProbabilitiesByFamily` folds old flat
+  probability vectors into family mass for replay and log analysis, labelled
+  “Aggregated from legacy flat action probabilities”. Historical selected actions
+  are never changed.
+- **Jev telemetry.** Internal identifiers (`A0`, `A1`, …) are translated through
+  the actual choice map. Spectators see family probabilities, sizing
+  probabilities, confidence bands, aggression tendency and bluff-opportunity
+  telemetry rather than invented text rationales.
+- **Diagnostics.** New `action_fragmentation`, `flat vs hierarchical`, `probe`
+  matrix and family-entropy/telemetry sections in
+  `tests/real/real-decision-diagnostics.mjs`; new offline fairness suite
+  `tests/unit/hierarchical-decision-tests.mjs`; real tournament A/B harness
+  `tests/real/real-tournament-ab.mjs`; concise summary builder
+  `tests/analysis/diagnostics-summary.mjs`.
+
+### Compatibility
+
+- Flat legacy mode is retained **only** as a diagnostics baseline
+  (`decisionArchitecture: "flat"`). Hierarchical is the production default.
+- `@pokertools/engine@1.0.20` and `@pokertools/evaluator@1.0.20` are unchanged.
+- Existing `.env` bootstrap, GitHub Pages and `npx pokertools-arena` workflows
+  are unchanged.
+
+### Measured effect (real API, 2026-09-19)
+
+369 decisions across Gemma, Qwen and Jev, 0 request errors, 415 HTTP requests.
+
+Action-fragmentation experiment on identical river states:
+
+| Menu | Gemma | Qwen | Jev |
+| --- | --- | --- | --- |
+| A · CHECK / BET ALL-IN | 0% | 89% | 100% |
+| B · CHECK / BET SMALL / ALL-IN | 0% | 56% | 56% |
+| C · CHECK / BET SMALL / MEDIUM / LARGE / ALL-IN | 0% | 56% | 33% |
+| D · hierarchical | 0% | 44% | 100% |
+
+Jev's aggressive-selection rate collapsed from 100% to 33% purely by adding
+almost-identical bet-size classes, and the hierarchical architecture restored
+it to 100%. This is the option-count asymmetry the release removes. Jev's mean
+family aggressive probability mass rose from 45% (fragmented flat) to 56%
+(hierarchical), and its selected-family probability from 37% to 73%.
+
+Strict diagnostics were preserved: Layer A (action-id mapping) 100%, Layer D
+(strictly dominated) 100% flat / 94% hierarchical, Layer B (raw hand
+recognition) 62% — the same cross-model weakness as before, and the reason
+Strategy mode exists.
+

package/docs/verification/0.3.x.md

@@ -0,0 +1,250 @@
+# pokertools-arena 0.3.x — technical verification record
+
+Fairness/correctness release: hierarchical decisions for every model, Strategy/Raw
+benchmark modes, deterministic hand evaluation, and a prose-free primary decision
+contract.
+
+## 1. Implementation summary
+
+### Canonical decision core (`src/lib/decision-core.js`)
+
+- `legalActionFamilies(legalActions, { toCall })` — the one canonical family set.
+  Free check exposes `check` + (`bet`|`raise`); facing a bet exposes
+  `fold`/`call`/(`raise`). Never exposes `fold` when `check` is free; never
+  exposes `bet` and `raise` together; throws on any arena invariant violation.
+- `planAggressiveSizes` / `aggressiveSizesForState` / `legalAggressiveSizes` —
+  deterministic, engine-validated sizing. At most four buckets
+  (`small` ≈33% pot, `medium` ≈67%, `large` ≈100%, `all_in`), clamped to the
+  stack, respecting the minimum bet/raise, deduplicated, near-duplicates removed,
+  all-in only when materially distinct, correct for short stacks.
+- `buildHierarchicalDecision`, `familyCriteria`, `sizeCriteria`,
+  `chatFamilySchema`, `chatSizeSchema`, `buildJevFamilyQuestions`,
+  `buildJevSizeQuestions` — one representation of the hierarchy for every adapter.
+- `resolveHierarchicalAction` — resolves `(family, size)` to one validated
+  engine action; the deterministic size amount is authoritative.
+- `decideHierarchical` — the two-stage executor: one shared `combineAbort`
+  signal (one action clock), family call then optional size call, no prose,
+  flat menus stripped from hierarchical prompts, request/usage accounting.
+- `applyBenchmarkMode` / `stripHeroHand` — Strategy adds a deterministic,
+  hero-only `heroHand`; Raw withholds it.
+- `renderDecisionState` — `canonical_json` / `compact_json` / `markdown`.
+- `aggregateActionProbabilitiesByFamily` / `probabilityStats` — legacy flat
+  probability folding into family mass, plus entropy/top-second-gap stats.
+- `diagnosticsCounters` — process-local HTTP request/retry/rate-limit counters.
+
+### Production (`src/app.js`)
+
+- Hierarchical is the production default; flat legacy is diagnostics-only.
+- Tournament-wide `benchmarkMode`, `decisionArchitecture`, `representation`,
+  `spectatorExplanations` settings, recorded in tournament meta, events and
+  replays.
+- Deterministic engine-validated size set built once per decision and shared by
+  the request and the UI.
+- Final action re-validated by PokerTools after both stages.
+- Spectator explanations run after the move in an isolated serial queue with an
+  8-second budget, never feed model context, and never count toward primary
+  latency. Jev gets typed telemetry, never fabricated prose.
+- `decisionMeta` carries `decisionArchitecture`, `family`, `sizing`,
+  `finalAction`; events carry `primaryDecisionLatencyMs`.
+- Current Decision panel shows stage 1 (`Action family`, "Stage 1 of 2 · action")
+  and stage 2 (`BET size`, "Stage 2 of 2 · sizing") with identical geometry for
+  all models.
+- Recent Decisions and replay show translated family/sizing telemetry; legacy
+  flat events show "Aggregated from legacy flat action probabilities" without
+  changing the historical action. Raw `A0/A1` identifiers are no longer shown in
+  the primary UI.
+- New UI: Benchmark mode selector (Strategy/Raw), and a Diagnostics/developer
+  section for Decision architecture, Representation and Spectator explanations.
+
+### Diagnostics and tests
+
+- `tests/unit/hierarchical-decision-tests.mjs` — 16 offline fairness assertions.
+- `tests/real/real-decision-diagnostics.mjs` — hierarchical strict diagnostics,
+  `action_fragmentation` (flat A/B/C vs hierarchical D), four-way probe matrix,
+  flat-vs-hierarchical and Jev family-telemetry tables, acceptance answers,
+  HTTP request accounting, `--from-json` offline re-render.
+- `tests/real/real-tournament-ab.mjs` — real flat-vs-hierarchical tournament A/B.
+- `tests/analysis/diagnostics-summary.mjs` — concise release report with `--merge`.
+- `tools/release/archive.mjs` — source archive builder with secret/exclusion guards.
+
+### Release
+
+- Version `0.3.0` in `package.json` and `package-lock.json`.
+- `RELEASE_NOTES.md`, `CONTEXT.md`, `THIRD_PARTY_NOTICES.md`, updated README and
+  `tests/README.md`, new `0.3.0` CSS section, release-check invariants.
+
+## 2. Bugs found and fixed
+
+1. **Jev hierarchical questions were double-wrapped.** `buildJevFamilyQuestions`
+   returned `{ action_family: { type: 'choice', … } }`, which the transport
+   wrapped again into `questions.action_family.action_family`; OpenRouter rejected
+   it (`invalid_union`, "No matching discriminator"). Fixed to return the bare
+   choice object.
+2. **Hierarchical sizing lost the deterministic amount.** `resolveHierarchicalAction`
+   fell back to the nearest flat candidate when the exact amount was absent,
+   silently replacing e.g. a 33%-pot size with a different amount. Fixed so the
+   validated deterministic size amount is authoritative.
+3. **`player` was out of scope** in the production final-validation path; changed
+   to `agent.id`.
+4. **Flat menus leaked into hierarchical prompts**, giving Jev both the family
+   question and a flat action list. Fixed by stripping `legalActions` from
+   hierarchical state and text.
+5. **Legacy flat-event aggregation required typed saved actions.** Added
+   description-based inference so old logs aggregate correctly.
+6. **Tournament A/B `playersRemaining` mismatch** — the harness counted only
+   live stacks while production counts still-seated players; fixed to match.
+7. **Tournament A/B percentage formatting** double-multiplied already-fractional
+   values; fixed with a value formatter and proper denominator counts.
+8. **Offline re-render wiped transport counters**; fixed to preserve saved
+   counters (and the saved run files were restored).
+
+## 3. Before/after diagnostic results
+
+Broad run: 369 decisions, 415 HTTP requests, 0 request errors.
+
+| Metric | Before (flat) | After (hierarchical) |
+| --- | --- | --- |
+| Layer A action-id mapping | 100% | n/a (flat-only by design) |
+| Layer B hand recognition | 62% | 62% (unchanged, cross-model weakness) |
+| Layer D strictly dominated | 100% | 94% |
+| Strict overall | 83% | 94% |
+| Jev family entropy (bits) | 0.34 | 0.80 |
+| Jev selected-family probability | 37% | 73% |
+| Jev mean aggressive family mass | 45% | 56% |
+
+## 4. Flat vs hierarchical comparison
+On identical shared action scenarios (fragmentation/probe menus excluded):
+
+| Model | Architecture | Agg rate | Check rate | Mean agg family mass | Mean latency |
+| --- | --- | --- | --- | --- | --- |
+| Gemma | Flat | 40% | 20% | — | 1583ms |
+| Gemma | Hierarchical | 40% | 20% | — | 2176ms |
+| Qwen | Flat | 40% | 20% | — | 7197ms |
+| Qwen | Hierarchical | 33% | 27% | — | 5663ms |
+| Jev | Flat | 40% | 20% | 40% | 407ms |
+| Jev | Hierarchical | 60% | 0% | 46% | 777ms |
+
+### Fragmentation experiment (aggressive-selection rate by menu)
+
+| Menu | Gemma | Qwen | Jev |
+| --- | --- | --- | --- |
+| A · CHECK / BET ALL-IN | 0% | 89% | 100% |
+| B · CHECK / BET SMALL / ALL-IN | 0% | 56% | 56% |
+| C · CHECK / BET SMALL / MEDIUM / LARGE / ALL-IN | 0% | 56% | 33% |
+| D · hierarchical | 0% | 44% | 100% |
+
+Jev's aggression collapsed from 100% to 33% purely by adding almost-identical
+bet-size classes, and hierarchy restored it to 100%.
+
+### Real tournament A/B (12 hands/arch, 10000 stack, 50/100 blinds, 5 hands/level, ×1.5)
+
+| Model | Architecture | Decisions | Agg opps | Aggressive | Agg rate |
+| --- | --- | --- | --- | --- | --- |
+| Gemma | Flat | 36 | 36 | 6 | 17% |
+| Gemma | Hierarchical | 26 | 23 | 11 | 48% |
+| Qwen | Flat | 35 | 34 | 13 | 38% |
+| Qwen | Hierarchical | 12 | 12 | 2 | 17% |
+| Jev | Flat | 30 | 30 | 2 | 7% |
+| Jev | Hierarchical | 24 | 21 | 6 | 29% |
+
+163 tournament decisions, 0 errors, 0 fallbacks. Win rate is not a conclusion at
+this sample size.
+
+### Representation sensitivity (accuracy on the fixed-answer action scenarios)
+
+All representations scored 100% for all three models, with aggressive rate
+varying only within small-sample noise (Gemma 20–40%, Qwen 20–40%, Jev 20–40%).
+No provider needs a richer representation: canonical JSON, minimal JSON, flat
+JSON, raw text, markdown, semantic keys and canonical+heroHand all carry the
+same semantics.
+
+### Context ablation
+
+Accuracy was 100% in every context variant for every model. Jev's aggressive
+rate stayed at 100% for immediate/action-history/public-stats/full context and
+50% for recent-hands (small sample); no context field is required for legality
+and none is provider-specific.
+
+## 5. Fairness verification
+
+Automated (`npm run test:hierarchical`, 16 assertions) plus `decision-diagnostics`:
+
+1. Same canonical decision semantics for all models.
+2. Identical action families for the same engine state.
+3. Identical sizing candidates for the same engine state.
+4. Strategy/Raw mode applies globally, never per seat.
+5. `heroHand` is deterministic.
+6. `heroHand` describes the hero only.
+7. Opponent cards remain hidden.
+8. Opponent hand evaluation is never exposed.
+9. `recentHands`/`publicPlayerStats` equivalent across adapters.
+10. Jev criteria exactly match the chat schema enums.
+11. Chat models cannot select a size not presented to Jev.
+12. Jev cannot select a size not presented to chat models.
+13. Final engine actions are validated after both stages.
+14. Free `CHECK` never exposes `FOLD`.
+15. The total action timer spans both hierarchical stages (one abort signal).
+16. Spectator explanations cannot affect future model context.
+17. Spectator explanation latency is not counted as primary action latency.
+18. Diagnostic perfect-information fixtures cannot enter tournament mode.
+
+## 6. Jev diagnosis after fragmentation is removed
+
+- Fragmentation, not poker policy, drove most of the observed passivity. The
+  two-choice menu produced 100% aggression; five aggressive classes produced 33%;
+  hierarchy restored 100% on the same states.
+- Jev's aggressive probability mass was always substantial but fragmented
+  (flat family entropy 0.34, selected-family probability 37%). Hierarchy raised
+  selected-family probability to 73% and entropy to 0.80.
+- On the 20-rep river probe, Jev bets the wheel straight 100% of the time with
+  hierarchy (both raw and heroHand), with mean aggressive family mass 61–82%.
+- Residual passivity (e.g. flat 7% aggressive rate in one real tournament) is
+  best explained by the model's own policy and by raw-card hand recognition, not
+  by the option list. The arena now presents identical, symmetric choices to
+  every model.
+
+## 7. Exact commands run
+
+```bash
+npm install
+npm test
+node tests/real/real-decision-diagnostics.mjs --experiments strict,hierarchical,fragmentation,probe --reps 3 --cap 380 --delay 50 --out logs/release-0.3.0
+node tests/real/real-decision-diagnostics.mjs --experiments probe --reps 20 --cap 250 --delay 50 --out logs/release-0.3.0
+node tests/real/real-decision-diagnostics.mjs --experiments representations,context,herohand --reps 2 --cap 320 --delay 50 --out logs/release-0.3.0
+node tests/real/real-tournament-ab.mjs --hands 12 --cap 150 --models gemma,qwen,jev --architecture flat,hierarchical --delay 60 --out logs/release-0.3.0
+node tests/analysis/diagnostics-summary.mjs --dir logs/release-0.3.0 --diagnostics <broad.json> --merge <probe.json> --tournament <ab.json> --out logs/release-0.3.0/diagnostics-summary.md
+node tools/release/archive.mjs --out pokertools-arena-0.3.0.tar.gz
+```
+
+## 8. npm test result
+
+`npm test` passes: build, release-check, `.env` bootstrap, `@pokertools/engine`
+integration, decision scenarios, offline diagnostics, and the new hierarchical
+fairness suite.
+
+## 9. Real API request/error counts
+
+- Broad run: 369 decisions, 415 HTTP requests, 0 errors (1 retry, 1 rate-limit event).
+- Probe (20 reps): 240 decisions, 323 HTTP requests, 0 errors.
+- Representation/context/heroHand run: recorded in its own report.
+- Tournament A/B: 163 decisions, 0 errors, 0 fallbacks.
+- Total: >750 real decisions, 0 decision errors.
+
+## 10. Remaining caveats
+
+- Layer B (raw hand recognition) remains 62% for all models; Strategy mode exists
+  precisely because of this, and Raw mode keeps the recognition benchmark alive.
+- Hierarchical Layer D was 94% vs 100% flat on 36 samples (Qwen bet a smaller
+  value size or checked in two synthetic always-calls spots); this is a model
+  behavior, not an arena legality issue, and the sample is small.
+- Win rate is not used as a conclusion at these sample sizes.
+- The tournament A/B uses the same action clock but hierarchical aggressive
+  decisions require two calls; observed latencies are reported rather than
+  normalized.
+
+## 11. Release archive
+
+`pokertools-arena-0.3.0.tar.gz` — full source archive (source, tests,
+diagnostics, bin, browser shims, GitHub workflows, `package.json`, lockfile,
+documentation). Excludes `.env`, secrets, generated logs, `dist/`, and
+`node_modules`. Verified: 49 entries, no real `.env`, no API key.

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "pokertools-arena",
+  "version": "0.4.0",
+  "description": "Browser-first AI poker benchmark powered by @pokertools/engine with generic OpenAI-compatible endpoints, optional OpenRouter/Jev Decisions routing, deterministic hierarchical decisions, paired fixed-state methodology, and reproducible reporting.",
+  "type": "module",
+  "bin": {
+    "pokertools-arena": "bin/pokertools-arena.mjs"
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "src/",
+    "docs/",
+    "README.md",
+    "LICENSE",
+    ".env.example"
+  ],
+  "scripts": {
+    "start": "node bin/pokertools-arena.mjs",
+    "start:chrome": "node bin/pokertools-arena.mjs --chrome",
+    "build": "node build.mjs",
+    "og": "rsvg-convert -w 1200 -h 630 -o src/assets/og-image.png src/assets/og-image.svg",
+    "check": "node --check src/app.js && node --check src/benchmark/scenarios.js && node --check build.mjs && node --check bin/pokertools-arena.mjs && node tests/release-check.mjs",
+    "test": "npm run build && npm run check && npm run test:unit && npm run test:integration",
+    "test:unit": "node tests/unit/decision-scenarios.mjs && node tests/unit/decision-diagnostics.mjs && node tests/unit/hierarchical-decision-tests.mjs && node tests/unit/methodology-tests.mjs && node tests/unit/size-bucket-tests.mjs && node tests/unit/paired-architecture-tests.mjs && node tests/unit/archive-content.mjs && node tests/unit/report-consistency.mjs",
+    "test:integration": "node tests/integration/pokertools-integration.mjs && node tests/integration/env-bootstrap.mjs",
+    "test:diagnostics": "node tests/real/real-decision-diagnostics.mjs",
+    "test:diagnostics:dry": "node tests/real/real-decision-diagnostics.mjs --dry-run",
+    "test:real": "node tests/real/real-decision-diagnostics.mjs && node tests/real/real-paired-corpus.mjs",
+    "test:tournament-ab": "node tests/real/real-tournament-ab.mjs",
+    "test:engine": "node tests/integration/pokertools-integration.mjs",
+    "test:env": "node tests/integration/env-bootstrap.mjs",
+    "test:scenarios": "node tests/unit/decision-scenarios.mjs",
+    "test:diagnostics:offline": "node tests/unit/decision-diagnostics.mjs",
+    "test:hierarchical": "node tests/unit/hierarchical-decision-tests.mjs",
+    "test:tournament": "node tests/real/real-tournament-ab.mjs",
+    "report:diagnostics": "node tests/analysis/release-report.mjs",
+    "report:release": "node tests/analysis/release-report.mjs --docs",
+    "analyze:decisions": "node tests/analysis/diagnostics-analyze.mjs",
+    "summarize": "node tests/analysis/diagnostics-summary.mjs",
+    "release:archive": "node tools/release/archive.mjs",
+    "test:browser": "node bin/pokertools-arena.mjs --chrome",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "poker",
+    "llm",
+    "benchmark",
+    "openrouter",
+    "openai",
+    "jev",
+    "pokertools",
+    "ai-agents"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pokertools-arena/pokertools-arena.github.io.git"
+  },
+  "homepage": "https://pokertools-arena.github.io/",
+  "bugs": {
+    "url": "https://github.com/pokertools-arena/pokertools-arena.github.io/issues"
+  },
+  "dependencies": {
+    "@pokertools/engine": "1.0.20",
+    "@pokertools/evaluator": "1.0.20"
+  },
+  "devDependencies": {
+    "esbuild": "^0.28.2"
+  }
+}