From b54c80884d1295f99f88e0fab59f0b3c6ef71602 Mon Sep 17 00:00:00 2001
From: Michael Ryaboy <michael@context.dev>
Date: Fri, 25 Sep 2026 16:04:26 -0700
Subject: [PATCH] Add Market: poll a simulated audience on which option it
 prefers

POST /v1/market/compare asks a panel of simulated US adults which of 2-4
short options they prefer: taglines, pricing framings, feature choices.
The audience is plain English. It resolves once against a 285k-persona
corpus (Nemotron-Personas-USA, CC BY 4.0) in a separate market database:
hybrid tsvector + pgvector retrieval shortlists candidates, one Jev Score
per candidate grades membership with ruling-out level semantics, and a
seeded weighted sample fixes the panel, so the same audience string always
polls the same people and repeated calls are comparable experiments.

Each panelist answers one Choice with the options in shared state. Shares
aggregate by probability mass rather than argmax - Jev is deliberately
consistent, and argmax voting herds near-identical personas onto one
option, fabricating 99/1 splits no human panel produces. Option order is
counterbalanced and the share it moves is reported as position_bias;
intervals use the Kish effective sample size; segments split by age, sex,
education, region and marital status at n >= 25.

Billing mirrors classification: token reservation extended before every
provider call, settled to measured usage. The MCP account server gains
compare_market_preference, wired only when the market callback exists, and
a pin test keeps the free five-tool list from quietly returning. Retrieval
sets hnsw.ef_search in-transaction because HNSW otherwise caps any LIMIT
at 40 rows. MARKET_DATABASE_URL is optional; without it the endpoint
answers 503 and nothing else changes.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 .github/workflows/deploy.yml |   5 +-
 scripts/market-corpus.py     | 163 +++++++++++++
 scripts/market-live.ts       | 108 +++++++++
 src/docs.ts                  |  39 ++++
 src/http/account-api.ts      |   2 +
 src/http/market.ts           | 263 +++++++++++++++++++++
 src/http/mcp.ts              |  27 ++-
 src/market.ts                | 442 +++++++++++++++++++++++++++++++++++
 src/mcp.ts                   |  53 ++++-
 src/openapi.ts               |  47 ++++
 test/api-contract.test.ts    |  10 +
 test/market.test.ts          | 198 ++++++++++++++++
 tests/runtime-config.test.ts |   4 +-
 wrangler.example.toml        |   2 +
 14 files changed, 1357 insertions(+), 6 deletions(-)
 create mode 100644 scripts/market-corpus.py
 create mode 100644 scripts/market-live.ts
 create mode 100644 src/http/market.ts
 create mode 100644 src/market.ts
 create mode 100644 test/market.test.ts

diff --git a/.github/workflows/deploy.yml b/.github/workflows/deploy.yml
index fb4f12c..c5ccae0 100644
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -169,12 +169,13 @@ jobs:
           CHUNKLAYA_TOKEN: ${{ secrets.CHUNKLAYA_TOKEN }}
           DGEMMA_URL: ${{ secrets.DGEMMA_URL }}
           DGEMMA_TOKEN: ${{ secrets.DGEMMA_TOKEN }}
+          MARKET_DATABASE_URL: ${{ secrets.MARKET_DATABASE_URL }}
         run: |
           node --input-type=module -e '
             import { writeFileSync } from "node:fs";
-            const { DATABASE_URL, CHUNKLAYA_URL, CHUNKLAYA_TOKEN, DGEMMA_URL, DGEMMA_TOKEN } = process.env;
+            const { DATABASE_URL, CHUNKLAYA_URL, CHUNKLAYA_TOKEN, DGEMMA_URL, DGEMMA_TOKEN, MARKET_DATABASE_URL } = process.env;
             writeFileSync(process.env.RUNNER_TEMP + "/classifier-secrets.json",
-              JSON.stringify({ DATABASE_URL, ...(CHUNKLAYA_URL && CHUNKLAYA_TOKEN ? { CHUNKLAYA_URL, CHUNKLAYA_TOKEN } : {}), ...(DGEMMA_URL && DGEMMA_TOKEN ? { DGEMMA_URL, DGEMMA_TOKEN } : {}) }), { mode: 0o600 });
+              JSON.stringify({ DATABASE_URL, ...(CHUNKLAYA_URL && CHUNKLAYA_TOKEN ? { CHUNKLAYA_URL, CHUNKLAYA_TOKEN } : {}), ...(DGEMMA_URL && DGEMMA_TOKEN ? { DGEMMA_URL, DGEMMA_TOKEN } : {}), ...(MARKET_DATABASE_URL ? { MARKET_DATABASE_URL } : {}) }), { mode: 0o600 });
           '
           npx wrangler deploy --secrets-file "$RUNNER_TEMP/classifier-secrets.json"
 
diff --git a/scripts/market-corpus.py b/scripts/market-corpus.py
new file mode 100644
index 0000000..cfd97b4
--- /dev/null
+++ b/scripts/market-corpus.py
@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+"""Load the Market persona corpus into Postgres.
+
+Reads Nemotron-Personas-USA parquet shards (CC-BY-4.0, NVIDIA), renders each
+row into a ~420-character panel text plus structured attributes, embeds the
+text with OpenAI text-embedding-3-small at 512 dimensions through OpenRouter,
+and bulk-inserts into market_personas. Resumable: rows whose id is already
+present are skipped, so a crashed run restarts where it stopped.
+
+Env: MARKET_DATABASE_URL_DIRECT (or DATABASE_URL), OPENROUTER_EMBED_KEY.
+Usage: python3 market-corpus.py <shard.parquet> [<shard.parquet> ...]
+"""
+import json, os, sys, time, urllib.request, urllib.error
+from concurrent.futures import ThreadPoolExecutor
+
+import duckdb
+import psycopg
+
+DB = os.environ.get("MARKET_DATABASE_URL_DIRECT") or os.environ["DATABASE_URL"]
+KEY = os.environ["OPENROUTER_EMBED_KEY"]
+EMBED_URL = "https://openrouter.ai/api/v1/embeddings"
+MODEL = "openai/text-embedding-3-small"
+DIMS = 512
+BATCH = 384          # texts per embedding request
+WORKERS = 6          # concurrent embedding requests
+ROWS_PER_SHARD = 1_000_000  # id space per shard; ids are shard_index * this + row
+
+REGION = {  # census regions, for the segments table
+    "Connecticut":"Northeast","Maine":"Northeast","Massachusetts":"Northeast","New Hampshire":"Northeast",
+    "Rhode Island":"Northeast","Vermont":"Northeast","New Jersey":"Northeast","New York":"Northeast","Pennsylvania":"Northeast",
+    "Illinois":"Midwest","Indiana":"Midwest","Michigan":"Midwest","Ohio":"Midwest","Wisconsin":"Midwest",
+    "Iowa":"Midwest","Kansas":"Midwest","Minnesota":"Midwest","Missouri":"Midwest","Nebraska":"Midwest",
+    "North Dakota":"Midwest","South Dakota":"Midwest",
+    "Delaware":"South","Florida":"South","Georgia":"South","Maryland":"South","North Carolina":"South",
+    "South Carolina":"South","Virginia":"South","District of Columbia":"South","West Virginia":"South",
+    "Alabama":"South","Kentucky":"South","Mississippi":"South","Tennessee":"South",
+    "Arkansas":"South","Louisiana":"South","Oklahoma":"South","Texas":"South",
+    "Arizona":"West","Colorado":"West","Idaho":"West","Montana":"West","Nevada":"West",
+    "New Mexico":"West","Utah":"West","Wyoming":"West","Alaska":"West","California":"West",
+    "Hawaii":"West","Oregon":"West","Washington":"West",
+}
+
+def age_band(age):
+    for lo, hi in ((18,24),(25,34),(35,44),(45,54),(55,64),(65,120)):
+        if lo <= age <= hi:
+            return f"{lo}-{hi}" if hi < 120 else "65+"
+    return "under-18"
+
+def clip_sentence(text, limit):
+    """Trim at the last sentence boundary within limit; hard-cut as a fallback."""
+    if not text or len(text) <= limit:
+        return text or ""
+    cut = text[:limit]
+    dot = cut.rfind(". ")
+    return cut[: dot + 1] if dot > limit // 2 else cut
+
+MARITAL = {"married_present": "married", "married_absent": "married, spouse away",
+           "never_married": "single", "divorced": "divorced", "widowed": "widowed", "separated": "separated"}
+
+def humanize(value):
+    return (value or "").replace("_", " ").strip()
+
+def render(row):
+    (persona, prof, sex, age, marital, edu, field, occ, city, state, hobbies) = row
+    bits = [f"{age}-year-old {humanize(sex).lower()}, {MARITAL.get(marital, humanize(marital))}."]
+    edu_txt = humanize(edu) or "unknown education"
+    if field:
+        edu_txt += f" in {humanize(field)}"
+    bits.append(f"Occupation: {humanize(occ) or 'unknown'} ({edu_txt}).")
+    bits.append(f"Lives in {city}, {state}.")
+    bits.append(clip_sentence(prof or persona or "", 240))
+    if hobbies:
+        take = [h.strip() for h in hobbies[:3] if h and h.strip()]
+        if take:
+            bits.append("Interests: " + "; ".join(take) + ".")
+    text = " ".join(b for b in bits if b)
+    attrs = {
+        "age": age, "age_band": age_band(age), "sex": humanize(sex).lower(),
+        "marital": MARITAL.get(marital, humanize(marital)),
+        "education": humanize(edu), "occupation": humanize(occ), "state": state,
+        "region": REGION.get(state, "Other"),
+    }
+    return text, attrs
+
+def embed(texts, tries=6):
+    body = json.dumps({"model": MODEL, "input": texts, "dimensions": DIMS}).encode()
+    for attempt in range(tries):
+        req = urllib.request.Request(EMBED_URL, data=body, headers={
+            "Authorization": f"Bearer {KEY}", "Content-Type": "application/json"})
+        try:
+            with urllib.request.urlopen(req, timeout=120) as r:
+                data = json.load(r)
+            vecs = [d["embedding"] for d in sorted(data["data"], key=lambda d: d["index"])]
+            if len(vecs) != len(texts) or any(len(v) != DIMS for v in vecs):
+                raise ValueError("embedding response shape mismatch")
+            return vecs
+        except (urllib.error.HTTPError, urllib.error.URLError, ValueError, TimeoutError, OSError) as e:
+            status = getattr(e, "code", None)
+            if attempt == tries - 1:
+                raise
+            time.sleep(min(2 ** attempt + 1, 30) if status in (429, None) else 2)
+
+def main(shards):
+    with psycopg.connect(DB) as check:
+        done = {r[0] for r in check.execute("SELECT id FROM market_personas").fetchall()}
+    print(f"resume: {len(done)} rows already loaded", flush=True)
+
+    conn = psycopg.connect(DB, autocommit=True)
+    inserted = 0
+    started = time.time()
+    pool = ThreadPoolExecutor(max_workers=WORKERS)
+    for si, shard in enumerate(shards):
+        base = si * ROWS_PER_SHARD
+        rel = duckdb.connect().execute(f"""
+            SELECT persona, professional_persona, sex, age, marital_status,
+                   education_level, bachelors_field, occupation, city, state,
+                   hobbies_and_interests_list
+            FROM read_parquet('{shard}')
+            WHERE age >= 18
+            {"LIMIT " + os.environ["MARKET_MAX_ROWS"] if os.environ.get("MARKET_MAX_ROWS") else ""}""")
+        batch_rows, batch_ids, futures = [], [], []
+
+        def flush(rows, ids):
+            texts_attrs = [render(r) for r in rows]
+            texts = [t for t, _ in texts_attrs]
+            vecs = embed(texts)
+            payload = [
+                (pid, text, json.dumps(attrs), "[" + ",".join(f"{x:.5f}" for x in vec) + "]")
+                for pid, (text, attrs), vec in zip(ids, texts_attrs, vecs)
+            ]
+            with conn.cursor() as cur:
+                cur.executemany(
+                    "INSERT INTO market_personas (id, panel_text, attrs, embedding) "
+                    "VALUES (%s, %s, %s, %s) ON CONFLICT (id) DO NOTHING", payload)
+            return len(payload)
+
+        row_index = 0
+        while True:
+            chunk = rel.fetchmany(BATCH)
+            if not chunk:
+                break
+            ids = list(range(base + row_index, base + row_index + len(chunk)))
+            row_index += len(chunk)
+            keep = [(r, i) for r, i in zip(chunk, ids) if i not in done]
+            if not keep:
+                continue
+            rows = [r for r, _ in keep]
+            kept_ids = [i for _, i in keep]
+            futures.append(pool.submit(flush, rows, kept_ids))
+            if len(futures) >= WORKERS * 2:
+                for f in futures:
+                    inserted += f.result()
+                futures = []
+                rate = inserted / max(time.time() - started, 1)
+                print(f"shard {si}: {row_index} read, {inserted} inserted total, {rate:.0f} rows/s", flush=True)
+        for f in futures:
+            inserted += f.result()
+        print(f"shard {si} complete: {row_index} rows read", flush=True)
+    pool.shutdown()
+    print(f"DONE: {inserted} inserted in {time.time()-started:.0f}s", flush=True)
+
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/scripts/market-live.ts b/scripts/market-live.ts
new file mode 100644
index 0000000..ff9b33c
--- /dev/null
+++ b/scripts/market-live.ts
@@ -0,0 +1,108 @@
+/**
+ * Live Market pipeline harness: retrieval → membership → panel → votes,
+ * against the real corpus and real Jev, without the worker or billing.
+ *
+ *   bun --env-file=.dev.vars scripts/market-live.ts "<audience>" "<option a>" "<option b>" [population] [decision]
+ *
+ * Requires DATABASE_URL (market corpus), TYPESAFE_API_KEY, and — for vector
+ * retrieval — OPENROUTER_EMBED_KEY in the environment.
+ */
+import { neon } from "@neondatabase/serverless";
+import { jevKeys } from "../src/jev";
+import { newMeter } from "../src/cost";
+import {
+  aggregate,
+  readMarketRequest,
+  runVotes,
+  samplePanel,
+  scoreMembership,
+  seededRandom,
+  sha256Hex,
+  voteBatches,
+  MARKET_CORPUS_VERSION,
+  MEMBERSHIP_SHORTLIST,
+  type PanelMember,
+} from "../src/market";
+
+const [audience, a, b, populationRaw, decisionRaw] = process.argv.slice(2);
+if (!audience || !a || !b) {
+  console.error('usage: bun scripts/market-live.ts "<audience>" "<option a>" "<option b>" [population] [decision]');
+  process.exit(1);
+}
+const request = readMarketRequest({
+  audience,
+  options: [a, b],
+  population: populationRaw ? Number(populationRaw) : 200,
+  ...(decisionRaw ? { decision: decisionRaw } : {}),
+});
+
+const sql = neon(process.env.MARKET_DATABASE_URL ?? process.env.DATABASE_URL!);
+const keys = jevKeys(process.env as Record<string, string>)!;
+const meter = newMeter();
+const t0 = Date.now();
+const lap = (label: string) => console.log(`${label}: ${((Date.now() - t0) / 1000).toFixed(1)}s, spend $${meter.usd.toFixed(4)}`);
+
+// 1. Embed the audience (optional).
+let embedding: string | null = null;
+if (process.env.OPENROUTER_EMBED_KEY) {
+  const response = await fetch("https://openrouter.ai/api/v1/embeddings", {
+    method: "POST",
+    headers: { authorization: `Bearer ${process.env.OPENROUTER_EMBED_KEY}`, "content-type": "application/json" },
+    body: JSON.stringify({ model: "openai/text-embedding-3-small", input: [request.audience], dimensions: 512 }),
+  });
+  const data = await response.json() as { data?: { embedding: number[] }[] };
+  if (data.data?.[0]) embedding = `[${data.data[0].embedding.map((x) => x.toFixed(5)).join(",")}]`;
+}
+lap(`embed (${embedding ? "ok" : "SKIPPED"})`);
+
+// 2. Retrieve.
+const shortlist = (embedding
+  ? (await sql.transaction((tx) => [
+      tx`SET LOCAL hnsw.ef_search = 1000`,
+      tx`
+      WITH vec AS (SELECT id FROM market_personas ORDER BY embedding <=> ${embedding}::halfvec(512) LIMIT 1000),
+           kw AS (SELECT id FROM market_personas
+                  WHERE tsv @@ websearch_to_tsquery('english', ${request.audience})
+                  ORDER BY ts_rank(tsv, websearch_to_tsquery('english', ${request.audience})) DESC LIMIT 1400)
+      SELECT p.id, p.panel_text FROM market_personas p
+      WHERE p.id IN (SELECT id FROM vec UNION SELECT id FROM kw)`,
+    ]))[1]
+  : await sql`
+      SELECT id, panel_text FROM market_personas
+      WHERE tsv @@ websearch_to_tsquery('english', ${request.audience})
+      ORDER BY ts_rank(tsv, websearch_to_tsquery('english', ${request.audience})) DESC LIMIT 2200`
+) as { id: number; panel_text: string }[];
+lap(`retrieve (${shortlist.length} candidates)`);
+
+// 3. Membership scoring.
+const audienceId = await sha256Hex(`${MARKET_CORPUS_VERSION}\n${request.audience}\n${request.population}`);
+const random = seededRandom(audienceId);
+const scored = shortlist
+  .map((row) => ({ row, key: random() }))
+  .sort((x, y) => x.key - y.key)
+  .slice(0, MEMBERSHIP_SHORTLIST)
+  .map(({ row }) => ({ id: row.id, text: row.panel_text }));
+const weights = await scoreMembership(keys, request.audience, scored, meter);
+const histogram = [0, 0, 0, 0, 0];
+for (const w of weights) histogram[Math.min(4, Math.floor(w * 4))]++;
+lap(`membership (weights 0-.25/.25-.5/.5-.75/.75-1/1: ${histogram.join("/")})`);
+
+// 4. Panel.
+const members = scored.map((candidate, i) => ({ id: candidate.id, weight: weights[i] })).filter((m) => m.weight > 0);
+const panelIds = samplePanel(members, request.population, audienceId);
+const textById = new Map(scored.map((candidate) => [candidate.id, candidate.text]));
+const attrsRows = await sql`SELECT id, attrs FROM market_personas WHERE id = ANY(${panelIds.map((m) => m.id)})` as { id: number; attrs: Record<string, unknown> }[];
+const attrsById = new Map(attrsRows.map((row) => [row.id, row.attrs]));
+const panel = new Map<number, PanelMember>(panelIds.map((m) => [m.id, { id: m.id, weight: m.weight, attrs: attrsById.get(m.id) ?? {} }]));
+console.log(`panel: ${panelIds.length} of ${members.length} eligible`);
+for (const m of panelIds.slice(0, 3)) console.log(`  · w=${m.weight.toFixed(2)} ${textById.get(m.id)?.slice(0, 130)}`);
+
+// 5. Votes.
+const batches = voteBatches(request.options, panelIds.map((m) => ({ id: m.id, text: textById.get(m.id)! })), request.decision);
+const { votes, failedRespondents } = await runVotes(keys, batches, request.options, meter);
+lap(`votes (${votes.length} answered, ${failedRespondents} failed)`);
+
+// 6. Aggregate.
+const result = aggregate(request, audienceId, scored.length, panel, votes);
+console.log(JSON.stringify(result, null, 1));
+lap("total");
diff --git a/src/docs.ts b/src/docs.ts
index 6cf505d..0725e66 100644
--- a/src/docs.ts
+++ b/src/docs.ts
@@ -328,6 +328,45 @@ TEN-MILLION-TOKEN JOBS
   available until expiry. Signup credit alone does not enable this feature.
 
 
+MARKET
+
+  POST /v1/market/compare polls a simulated audience on which of 2-4 short
+  options it prefers: taglines, headlines, product descriptions, pricing
+  framings, feature choices. Requires an account API key; billed per token
+  like classification.
+
+    {"audience": "US public school teachers",
+     "options": [{"id": "summer", "content": "..."},
+                 {"id": "raise", "content": "..."}],
+     "decision": "Which employment offer would you choose?",
+     "population": 150}
+
+  The audience is plain English. It resolves against a 285,000-persona corpus
+  derived from Nemotron-Personas-USA (CC BY 4.0, NVIDIA; census-grounded US
+  adults): hybrid keyword and vector retrieval shortlists candidates, one Jev
+  Score per candidate grades how squarely the person fits the audience, and a
+  seeded weighted sample fixes the panel. The same audience string and
+  population always poll the same simulated people, so repeated calls are
+  comparable experiments. The first call for an audience pays the membership
+  scoring (about $0.015 and 15 seconds at the default population); later
+  calls reuse the panel and answer in about a second.
+
+  Each panelist answers one Choice question with the options in shared
+  context. Answers are aggregated by probability mass — a panelist who would
+  pick A 70% of the time contributes 0.7 to A, not 1 — under the panelist's
+  membership weight. Option order is counterbalanced across the panel and the
+  share moved by order is reported as position_bias: treat a gap smaller than
+  the position bias as a tie. mean_certainty says how torn individual
+  panelists were, interval is a 95% band under the Kish effective sample
+  size, and segments splits the answer by age, sex, education, region and
+  marital status wherever at least 25 panelists share a value.
+
+  Market estimates relative preference between the options you supply. It
+  does not estimate conversion, purchase rates or market size, and the corpus
+  is the adult population of the United States, so audiences outside it are
+  refused rather than approximated.
+
+
 LEGACY CHUNKLAYA
 
   Explicit model: "chunklaya" keeps the legacy opt-in service, Laya behind a
diff --git a/src/http/account-api.ts b/src/http/account-api.ts
index 3b835b8..6e1c50d 100644
--- a/src/http/account-api.ts
+++ b/src/http/account-api.ts
@@ -2,6 +2,7 @@ import legacy, { type Env } from "../index";
 import { AppError, type AppEnv } from "../server/db";
 import { accountReadRoutes } from "./account";
 import { accountClassification } from "./classification";
+import { accountMarket } from "./market";
 import { accountMcp } from "./mcp";
 
 /** Account responses, including failures, must remain readable by browser API clients. */
@@ -16,6 +17,7 @@ export async function accountApi(request: Request, env: AppEnv & Env, ctx: Execu
   try {
     response = await accountReadRoutes(request, env)
       ?? await accountMcp(request, env, ctx)
+      ?? await accountMarket(request, env, ctx)
       ?? await accountClassification(request, env, "API", ctx);
   } catch (error) {
     response = Response.json({ error: error instanceof AppError ? error.message : "Unable to complete this request." }, {
diff --git a/src/http/market.ts b/src/http/market.ts
new file mode 100644
index 0000000..1c8a14b
--- /dev/null
+++ b/src/http/market.ts
@@ -0,0 +1,263 @@
+/**
+ * POST /v1/market/compare — account-billed market preference.
+ *
+ * The audience resolves once and is cached in market_audiences forever, keyed
+ * by sha256(corpus version + audience text): retrieval (hybrid keyword +
+ * vector over market_personas) shortlists candidates, one Jev Score per
+ * candidate grades membership, and a seeded weighted sample fixes the panel.
+ * The same audience string therefore always polls the same simulated people,
+ * which is what makes two experiments against one audience comparable.
+ *
+ * Billing mirrors classification: a token reservation is extended before
+ * every provider call and settled to measured usage. The one OpenRouter
+ * embedding per audience miss (~30 tokens) is infrastructure cost like the
+ * database query, deliberately outside the meter: an unpriced model row
+ * would push every settlement into review.
+ */
+
+import { neon } from "@neondatabase/serverless";
+import type { Env } from "../index";
+import { jevKeys } from "../jev";
+import { newMeter } from "../cost";
+import rates from "../retail-rates.json";
+import { AppError, type AppEnv } from "../server/db";
+import { authorizeAndReserve } from "../server/usage";
+import { parseTokenRateCard, priceTokens } from "../server/token-pricing";
+import { extendTokenReservation, providerCallBound } from "../server/token-reservation";
+import { refundTokenReservation, settleTokenReservation } from "../server/token-ledger";
+import { writeAccountAnalytics } from "../server/analytics/write";
+import {
+  aggregate,
+  MARKET_RECIPE_VERSION,
+  assertOptionsFit,
+  MARKET_CORPUS_VERSION,
+  MarketError,
+  MEMBERSHIP_SHORTLIST,
+  readMarketRequest,
+  runVotes,
+  samplePanel,
+  scoreMembership,
+  seededRandom,
+  sha256Hex,
+  voteBatches,
+  type MarketRequest,
+  type PanelMember,
+} from "../market";
+
+const card = parseTokenRateCard(JSON.stringify(rates))!;
+const EMBED_URL = "https://openrouter.ai/api/v1/embeddings";
+const EMBED_MODEL = "openai/text-embedding-3-small";
+const EMBED_DIMS = 512;
+
+type MarketEnv = AppEnv & Partial<Env> & { MARKET_DATABASE_URL?: string };
+
+/** The audience embedding; null degrades retrieval to keywords only. */
+async function embedAudience(env: MarketEnv, audience: string): Promise<string | null> {
+  if (!env.OPENROUTER_API_KEY) return null;
+  try {
+    const response = await fetch(EMBED_URL, {
+      method: "POST",
+      headers: { authorization: `Bearer ${env.OPENROUTER_API_KEY}`, "content-type": "application/json" },
+      body: JSON.stringify({ model: EMBED_MODEL, input: [audience], dimensions: EMBED_DIMS }),
+      signal: AbortSignal.timeout(15_000),
+    });
+    if (!response.ok) return null;
+    const data = await response.json() as { data?: { embedding?: number[] }[] };
+    const vector = data.data?.[0]?.embedding;
+    if (!Array.isArray(vector) || vector.length !== EMBED_DIMS) return null;
+    return `[${vector.map((x) => x.toFixed(5)).join(",")}]`;
+  } catch {
+    return null;
+  }
+}
+
+type StoredPanel = { id: number; w: number }[];
+
+/** Resolve or build the audience panel. Returns members and the shortlist size. */
+async function resolveAudience(
+  env: MarketEnv,
+  sql: ReturnType<typeof neon<false, false>>,
+  request: MarketRequest,
+  audienceId: string,
+  meter: ReturnType<typeof newMeter>,
+): Promise<{ panel: StoredPanel; candidates: number }> {
+  const cached = await sql`SELECT panel, candidates FROM market_audiences WHERE id = ${audienceId}` as { panel: StoredPanel; candidates: number }[];
+  if (cached.length) return { panel: cached[0].panel, candidates: cached[0].candidates };
+
+  const embedding = await embedAudience(env, request.audience);
+  const shortlist = (embedding
+    ? (await sql.transaction((tx) => [
+        tx`SET LOCAL hnsw.ef_search = 1000`,
+        tx`
+        WITH vec AS (SELECT id FROM market_personas ORDER BY embedding <=> ${embedding}::halfvec(512) LIMIT 1000),
+             kw AS (SELECT id FROM market_personas
+                    WHERE tsv @@ websearch_to_tsquery('english', ${request.audience})
+                    ORDER BY ts_rank(tsv, websearch_to_tsquery('english', ${request.audience})) DESC LIMIT 1400)
+        SELECT p.id, p.panel_text FROM market_personas p
+        WHERE p.id IN (SELECT id FROM vec UNION SELECT id FROM kw)`,
+      ]))[1]
+    : await sql`
+        SELECT id, panel_text FROM market_personas
+        WHERE tsv @@ websearch_to_tsquery('english', ${request.audience})
+        ORDER BY ts_rank(tsv, websearch_to_tsquery('english', ${request.audience})) DESC LIMIT 2200`
+  ) as { id: number; panel_text: string }[];
+
+  if (shortlist.length < 25) {
+    throw new MarketError(
+      `Only ${shortlist.length} corpus personas resembled this audience. The corpus is ${MARKET_CORPUS_VERSION} (US general population); describe the audience with occupations or demographics it can contain.`,
+      422,
+    );
+  }
+
+  // A shortlist larger than the scoring budget is sampled, never truncated by
+  // rank: the top of a similarity ranking is the most stereotypical slice.
+  const random = seededRandom(audienceId);
+  const scored = shortlist
+    .map((row) => ({ row, key: random() }))
+    .sort((a, b) => a.key - b.key)
+    .slice(0, MEMBERSHIP_SHORTLIST)
+    .map(({ row }) => ({ id: row.id, text: row.panel_text }));
+
+  const keys = jevKeys(env as Parameters<typeof jevKeys>[0]);
+  if (!keys) throw new MarketError("Inference is not configured.", 503);
+  const weights = await scoreMembership(keys, request.audience, scored, meter);
+  const members = scored
+    .map((candidate, index) => ({ id: candidate.id, weight: Number(weights[index].toFixed(4)) }))
+    .filter((member) => member.weight > 0);
+
+  const panel = samplePanel(members, request.population, audienceId).map((member) => ({ id: member.id, w: member.weight }));
+  if (panel.length < 25) {
+    throw new MarketError(
+      `Only ${panel.length} of ${scored.length} shortlisted personas fit this audience; the corpus cannot represent it. Try a broader or more US-general audience.`,
+      422,
+    );
+  }
+  await sql`
+    INSERT INTO market_audiences (id, query, corpus_version, panel, candidates)
+    VALUES (${audienceId}, ${request.audience}, ${MARKET_CORPUS_VERSION}, ${JSON.stringify(panel)}::jsonb, ${scored.length})
+    ON CONFLICT (id) DO NOTHING`;
+  return { panel, candidates: scored.length };
+}
+
+export async function accountMarket(request: Request, env: MarketEnv, _ctx: ExecutionContext): Promise<Response | null> {
+  if (new URL(request.url).pathname !== "/v1/market/compare") return null;
+  if (!/^Bearer\s+classifier_agent_/i.test(request.headers.get("authorization") || "")) return null;
+  if (request.method !== "POST") throw new AppError(405, "Use POST for market comparisons.");
+  if (!env.MARKET_DATABASE_URL) throw new AppError(503, "Market is not configured for this deployment.");
+
+  const text = await request.text();
+  if (new TextEncoder().encode(text).length > 100_000) throw new AppError(413, "Request is too large.");
+  let body: Record<string, unknown>;
+  try { body = JSON.parse(text); } catch { throw new AppError(400, "Send valid JSON."); }
+  if (!body || typeof body !== "object" || Array.isArray(body)) throw new AppError(400, "Send a JSON object.");
+
+  let marketRequest: MarketRequest;
+  try {
+    marketRequest = readMarketRequest(body);
+    assertOptionsFit(marketRequest.options);
+  } catch (error) {
+    if (error instanceof MarketError) throw new AppError(error.status, error.message);
+    throw error;
+  }
+
+  const reservation = await authorizeAndReserve(request, env, 0, marketRequest.population, {
+    type: "API · Market", meteringMode: "tokens",
+  });
+  if (!reservation) throw new AppError(401, "Missing account credential.");
+
+  const meter = newMeter();
+  let admissionError: AppError | undefined;
+  let reservationQueue = Promise.resolve();
+  meter.beforeCall = (provider, model, maxOutput) => {
+    const admission = reservationQueue.then(async () => {
+      if (admissionError) throw admissionError;
+      try { await extendTokenReservation(env.APP_DB, reservation.id, providerCallBound(card, provider, model, maxOutput)); }
+      catch (error) {
+        admissionError = error instanceof AppError ? error : new AppError(503, "Credit reservation is temporarily unavailable.");
+        throw admissionError;
+      }
+    });
+    reservationQueue = admission.catch(() => {});
+    return admission;
+  };
+
+  const started = Date.now();
+  const tokens = () => {
+    const sum = (field: "inputTokens" | "outputTokens" | "cachedInputTokens") =>
+      meter.tokens.length && meter.tokens.every((row) => row[field] !== null)
+        ? meter.tokens.reduce((total, row) => total + row[field]!, 0) : null;
+    return { inputTokens: sum("inputTokens"), outputTokens: sum("outputTokens"), cachedInputTokens: sum("cachedInputTokens") };
+  };
+  const analytics = (success: boolean, retailCostUsd: number | null) => writeAccountAnalytics(env, {
+    accountId: reservation.accountId, keyId: reservation.agentId, requestId: reservation.id, source: "API", tier: "smart",
+    status: success ? "success" : "error", items: marketRequest.population, ...tokens(),
+    model: "market," + meter.tokens.map((row) => row.model).join(","),
+    providerCostUsd: meter.tokens.length ? meter.usd : null, retailCostUsd, latencyMs: Date.now() - started,
+  });
+
+  let result;
+  try {
+    const sql = neon(env.MARKET_DATABASE_URL);
+    const audienceId = await sha256Hex(`${MARKET_CORPUS_VERSION}\n${MARKET_RECIPE_VERSION}\n${marketRequest.audience}\n${marketRequest.population}`);
+    const { panel: stored, candidates } = await resolveAudience(env, sql, marketRequest, audienceId, meter);
+
+    const ids = stored.map((member) => member.id);
+    const rows = await sql`SELECT id, panel_text, attrs FROM market_personas WHERE id = ANY(${ids})` as
+      { id: number; panel_text: string; attrs: Record<string, unknown> }[];
+    const byId = new Map(rows.map((row) => [row.id, row]));
+    const panel = new Map<number, PanelMember>();
+    const votersInput: { id: number; text: string }[] = [];
+    for (const member of stored) {
+      const row = byId.get(member.id);
+      if (!row) continue;
+      panel.set(member.id, { id: member.id, weight: member.w, attrs: row.attrs });
+      votersInput.push({ id: member.id, text: row.panel_text });
+    }
+
+    const keys = jevKeys(env as Parameters<typeof jevKeys>[0]);
+    if (!keys) throw new MarketError("Inference is not configured.", 503);
+    const batches = voteBatches(marketRequest.options, votersInput, marketRequest.decision);
+    const { votes, failedRespondents } = await runVotes(keys, batches, marketRequest.options, meter);
+    if (!votes.length) throw new MarketError("No panel votes completed; the upstream model refused the whole panel. Retry shortly.", 502);
+
+    result = {
+      ...aggregate(marketRequest, audienceId, candidates, panel, votes),
+      ...(stored.length < marketRequest.population ? {
+        note: `Only ${stored.length} corpus personas fit this audience; the panel is smaller than the requested population and the interval reflects that.`,
+      } : {}),
+      failed_respondents: failedRespondents,
+      options: Object.fromEntries(marketRequest.options.map((option) => [option.id, option.content.slice(0, 80)])),
+    };
+    await reservationQueue;
+    if (admissionError) throw admissionError;
+  } catch (error) {
+    await reservationQueue;
+    await refundTokenReservation(env.APP_DB, reservation.id);
+    analytics(false, 0);
+    if (error instanceof MarketError) throw new AppError(error.status, error.message);
+    if (error instanceof AppError) throw error;
+    throw new AppError(502, "The market comparison failed. Your reserved balance was returned.");
+  }
+
+  const charge = priceTokens(card, meter.tokens);
+  let billingStatus = "settled";
+  try { await settleTokenReservation(env.APP_DB, reservation.id, charge, tokens()); }
+  catch { billingStatus = "review"; }
+  if (!charge) billingStatus = "review";
+  analytics(true, charge ? Number(charge.nanodollars) / 1e9 : null);
+
+  return Response.json({
+    ...result,
+    usage: {
+      ...tokens(),
+      models: meter.tokens.map((row) => ({ provider: row.provider, model: row.model, calls: row.calls })),
+    },
+    pricing: {
+      currency: "USD", rate_version: card.version,
+      total_usd: charge ? Number(charge.nanodollars) / 1e9 : null,
+      billing_status: billingStatus,
+    },
+  }, {
+    headers: { "cache-control": "no-store", "x-request-id": reservation.id, "x-billing-status": billingStatus },
+  });
+}
diff --git a/src/http/mcp.ts b/src/http/mcp.ts
index dbcdaa1..5bf454c 100644
--- a/src/http/mcp.ts
+++ b/src/http/mcp.ts
@@ -19,6 +19,31 @@ export async function accountMcp(
   )
     return null;
   await requireApiAccount(request, env);
+  const { accountMarket } = await import("./market");
+  const marketFn = async (body: Record<string, unknown>, original: Request) => {
+    try {
+      const response = await accountMarket(
+        new Request(new URL("/v1/market/compare", request.url), {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            authorization: original.headers.get("authorization") || "",
+            "cf-connecting-ip": request.headers.get("cf-connecting-ip") || "",
+          },
+          body: JSON.stringify(body),
+        }),
+        env,
+        ctx ?? ({ waitUntil() {} } as unknown as ExecutionContext),
+      );
+      if (!response) return { status: 401, body: { error: "Missing credential." } };
+      return { status: response.status, body: (await response.json()) as Record<string, unknown> };
+    } catch (error) {
+      return {
+        status: error instanceof AppError ? error.status : 500,
+        body: { error: error instanceof AppError ? error.message : "Unable to complete this request." },
+      };
+    }
+  };
   return handleMcp(
     request,
     productServer(async (body, original) => {
@@ -55,6 +80,6 @@ export async function accountMcp(
           },
         };
       }
-    }),
+    }, marketFn),
   );
 }
diff --git a/src/market.ts b/src/market.ts
new file mode 100644
index 0000000..5067491
--- /dev/null
+++ b/src/market.ts
@@ -0,0 +1,442 @@
+/**
+ * Market: ask a simulated population which of several options it prefers.
+ *
+ * The pipeline is retrieval (Postgres, hybrid keyword + vector), then a Jev
+ * Score per shortlisted persona for graded audience membership, then one Jev
+ * Choice per panelist for the vote. Everything here is pure logic over the
+ * shared Jev client; HTTP, billing and SQL live in http/market.ts.
+ *
+ * Two Jev jaggedness findings shape the vote packing. Accuracy falls when
+ * state carries unrelated detail, so batches stay small (VOTE_BATCH personas
+ * per request) even though the context budget would fit far more — personas
+ * dominate the token bill and are paid once per panel at any batch size, so
+ * smaller batches only re-send the two option texts. And a Choice may favour
+ * whichever option is listed first, so half the panel sees the criteria in
+ * each order; the gap between the two halves is reported as position_bias
+ * rather than hidden in the average.
+ */
+
+import {
+  estimateTokens,
+  jevAsk,
+  prepareJevBatches,
+  runJevBatches,
+  type JevAnswer,
+  type JevKeys,
+  type JevQuestionGroup,
+  type Question,
+} from "./jev";
+import type { Meter } from "./cost";
+
+export const MARKET_CORPUS_VERSION = "nemotron-personas-usa-v1";
+/** Folded into the audience id: bump when the membership or vote prompts change, so stale panels are never reused. */
+export const MARKET_RECIPE_VERSION = "r2";
+export const MAX_OPTIONS = 4;
+export const MAX_OPTION_CHARS = 2000;
+export const MAX_AUDIENCE_CHARS = 400;
+export const MIN_POPULATION = 50;
+export const MAX_POPULATION = 2000;
+export const DEFAULT_POPULATION = 500;
+/** Shortlist scored for membership on an audience miss. */
+export const MEMBERSHIP_SHORTLIST = 2200;
+/** Below this membership weight a candidate never enters the panel. */
+export const MIN_MEMBERSHIP_WEIGHT = 0.15;
+/** Personas per vote request: small on purpose; see the header comment. */
+const VOTE_BATCH = 40;
+const VOTE_CONCURRENCY = 6;
+
+export class MarketError extends Error {
+  constructor(message: string, readonly status: 400 | 404 | 422 | 502 | 503 = 400) {
+    super(message);
+  }
+}
+
+export type MarketOption = { id: string; content: string };
+export type MarketRequest = {
+  audience: string;
+  options: MarketOption[];
+  decision: string;
+  population: number;
+};
+
+/** Validate the request body; errors name the field and the accepted range. */
+export function readMarketRequest(body: Record<string, unknown>): MarketRequest {
+  const audience = typeof body.audience === "string" ? body.audience.trim() : "";
+  if (!audience) throw new MarketError("Provide an audience: one plain-English description of who should judge the options.");
+  if (audience.length > MAX_AUDIENCE_CHARS) throw new MarketError(`The audience description must be at most ${MAX_AUDIENCE_CHARS} characters.`);
+  if (!Array.isArray(body.options) || body.options.length < 2 || body.options.length > MAX_OPTIONS) {
+    throw new MarketError(`Provide 2-${MAX_OPTIONS} options to compare.`);
+  }
+  const ids = new Set<string>();
+  const options = body.options.map((raw, index) => {
+    const record: Record<string, unknown> = raw && typeof raw === "object" && !Array.isArray(raw) ? raw as Record<string, unknown> : { content: raw };
+    const content = typeof record.content === "string" ? record.content.trim() : "";
+    if (!content) throw new MarketError(`Option ${index + 1} needs a non-empty "content" string.`);
+    if (content.length > MAX_OPTION_CHARS) throw new MarketError(`Option ${index + 1} exceeds ${MAX_OPTION_CHARS} characters; Market compares short artifacts such as headlines, descriptions, or pricing copy.`);
+    const id = typeof record.id === "string" && /^[a-z0-9_-]{1,32}$/i.test(record.id) ? record.id : String.fromCharCode(97 + index);
+    if (ids.has(id)) throw new MarketError(`Duplicate option id "${id}".`);
+    ids.add(id);
+    return { id, content };
+  });
+  const decision = typeof body.decision === "string" && body.decision.trim()
+    ? body.decision.trim()
+    : "Which option would this person find more appealing?";
+  if (decision.length > 500) throw new MarketError("The decision question must be at most 500 characters.");
+  const population = body.population === undefined ? DEFAULT_POPULATION : Number(body.population);
+  if (!Number.isSafeInteger(population) || population < MIN_POPULATION || population > MAX_POPULATION) {
+    throw new MarketError(`population must be an integer between ${MIN_POPULATION} and ${MAX_POPULATION}.`);
+  }
+  return { audience, options, decision, population };
+}
+
+export type Candidate = { id: number; text: string };
+export type PanelMember = { id: number; weight: number; attrs: Record<string, unknown> };
+
+/** Deterministic 32-bit PRNG so the same audience always yields the same panel. */
+export function seededRandom(seed: string): () => number {
+  let h = 2166136261 >>> 0;
+  for (let i = 0; i < seed.length; i++) {
+    h ^= seed.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return () => {
+    h += 0x6d2b79f5;
+    let t = h;
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+/**
+ * Ruling-out semantics, because Jev reads literally: a broad behavioral
+ * audience ("adults who read news online daily") names a behavior no corpus
+ * profile records, and levels phrased as positive evidence score nearly
+ * everyone as adjacent. Membership asks what the profile rules out, so broad
+ * audiences keep most of the population at "plausible" while occupational
+ * audiences still exclude the profiles that contradict them.
+ */
+const MEMBERSHIP_LEVELS = [
+  "Clearly not in this audience: something in the profile rules them out",
+  "Unlikely: nothing rules them out, but the profile makes membership improbable",
+  "Plausible: nothing in the profile rules them out and the profile is consistent with this audience",
+  "Strong fit: the profile directly indicates this audience",
+];
+
+/** One Score question per shortlisted persona; packed by the shared batcher. */
+export function membershipGroups(audience: string, candidates: Candidate[]): JevQuestionGroup<number>[] {
+  return candidates.map((candidate, index) => {
+    const id = `p${candidate.id}`;
+    const question: Question = {
+      type: "score",
+      instructions: `How well does the person described in \`${id}\` fit this audience: ${JSON.stringify(audience)}? Judge only from that person's description.`,
+      criteria: MEMBERSHIP_LEVELS,
+    };
+    return { state: { id, text: candidate.text }, questions: { [id]: question }, value: index };
+  });
+}
+
+/** Graded membership: full weight for "squarely", half for "plausibly". */
+export function membershipWeight(answer: JevAnswer | undefined): number {
+  const p = answer?.probabilities;
+  if (!p) return 0;
+  const squarely = p["3"] ?? 0;
+  const plausibly = p["2"] ?? 0;
+  return Math.min(1, squarely + 0.5 * plausibly);
+}
+
+export async function scoreMembership(
+  keys: JevKeys,
+  audience: string,
+  candidates: Candidate[],
+  meter?: Meter,
+): Promise<number[]> {
+  const groups = membershipGroups(audience, candidates);
+  const answered = await runJevBatches(keys, prepareJevBatches(groups), meter);
+  const weights = new Array<number>(candidates.length).fill(0);
+  for (const { value: index, answers } of answered) {
+    weights[index] = membershipWeight(answers[`p${candidates[index].id}`]);
+  }
+  return weights;
+}
+
+/**
+ * Weighted sample without replacement (Efraimidis-Spirakis), seeded. Members
+ * keep their membership weight so aggregation can reweight the headline share.
+ */
+export function samplePanel(
+  candidates: { id: number; weight: number }[],
+  population: number,
+  seed: string,
+): { id: number; weight: number }[] {
+  const random = seededRandom(seed);
+  return candidates
+    .filter((candidate) => candidate.weight >= MIN_MEMBERSHIP_WEIGHT)
+    .map((candidate) => ({ candidate, key: Math.pow(random(), 1 / candidate.weight) }))
+    .sort((a, b) => b.key - a.key)
+    .slice(0, population)
+    .map(({ candidate }) => candidate);
+}
+
+export type VoteBatch = {
+  state: { id: string; text: string }[];
+  questions: Record<string, Question>;
+  /** Persona ids in this batch, keyed by question id. */
+  members: Map<string, number>;
+};
+
+/**
+ * Batches share the option texts through state and counterbalance criteria
+ * order by panel position: even panelists see options in the given order and
+ * odd panelists see them reversed, so a position preference cancels in the
+ * mean and surfaces as `position_bias`.
+ */
+export function voteBatches(
+  options: MarketOption[],
+  panel: { id: number; text: string }[],
+  decision: string,
+): VoteBatch[] {
+  const optionState = options.map((option) => ({ id: `option_${option.id}`, text: option.content }));
+  const forward = options.map((option) => `option_${option.id}`);
+  const names = forward.join(", ");
+  const batches: VoteBatch[] = [];
+  for (let start = 0; start < panel.length; start += VOTE_BATCH) {
+    const slice = panel.slice(start, start + VOTE_BATCH);
+    const questions: Record<string, Question> = {};
+    const members = new Map<string, number>();
+    slice.forEach((member, offset) => {
+      const position = start + offset;
+      const order = position % 2 === 0 ? forward : [...forward].reverse();
+      const id = `v${member.id}`;
+      questions[id] = {
+        type: "choice",
+        instructions:
+          `Consider only the person described in \`p${member.id}\` and the option texts ${names}. ` +
+          `${decision} Answer as that specific person would, from their occupation, life situation, and interests.`,
+        criteria: Object.fromEntries(order.map((name) => [name, null])),
+      };
+      members.set(id, member.id);
+    });
+    batches.push({
+      state: [...optionState, ...slice.map((member) => ({ id: `p${member.id}`, text: member.text }))],
+      questions,
+      members,
+    });
+  }
+  return batches;
+}
+
+export type Vote = { personaId: number; option: string; confidence: number; position: "forward" | "reversed"; probabilities: Record<string, number> };
+
+/**
+ * Run vote batches with bounded concurrency and partial tolerance: a failed
+ * batch after one halving retry costs its respondents, not the panel. Halving
+ * rebuilds both halves with the option state included, which the generic
+ * runner in jev.ts cannot do because its groups carry one state item each.
+ */
+export async function runVotes(
+  keys: JevKeys,
+  batches: VoteBatch[],
+  options: MarketOption[],
+  meter?: Meter,
+  ask: typeof jevAsk = jevAsk,
+): Promise<{ votes: Vote[]; failedRespondents: number }> {
+  const queue = [...batches];
+  const votes: Vote[] = [];
+  let failedRespondents = 0;
+  const optionState = new Set(options.map((option) => `option_${option.id}`));
+  const forwardFirst = `option_${options[0].id}`;
+
+  await Promise.all(
+    Array.from({ length: Math.min(VOTE_CONCURRENCY, queue.length) }, async () => {
+      while (queue.length) {
+        const batch = queue.shift();
+        if (!batch) break;
+        try {
+          const result = await ask(keys, batch.state, batch.questions, meter);
+          for (const [questionId, personaId] of batch.members) {
+            const answer = result.answers[questionId];
+            const question = batch.questions[questionId];
+            if (!answer?.choice || question.type !== "choice") continue;
+            const probabilities: Record<string, number> = {};
+            for (const [name, probability] of Object.entries(answer.probabilities ?? {})) {
+              probabilities[name.replace(/^option_/, "")] = probability;
+            }
+            votes.push({
+              personaId,
+              option: answer.choice.replace(/^option_/, ""),
+              confidence: answer.confidence ?? 0,
+              position: Object.keys(question.criteria)[0] === forwardFirst ? "forward" : "reversed",
+              probabilities,
+            });
+          }
+        } catch (error) {
+          const halvable = batch.members.size > 1;
+          if (halvable) {
+            const entries = [...batch.members.entries()];
+            const mid = Math.ceil(entries.length / 2);
+            for (const half of [entries.slice(0, mid), entries.slice(mid)]) {
+              const ids = new Set(half.map(([questionId]) => questionId));
+              const personaIds = new Set(half.map(([, personaId]) => `p${personaId}`));
+              queue.push({
+                state: batch.state.filter((item) => optionState.has(item.id) || personaIds.has(item.id)),
+                questions: Object.fromEntries(Object.entries(batch.questions).filter(([id]) => ids.has(id))),
+                members: new Map(half),
+              });
+            }
+          } else {
+            failedRespondents += batch.members.size;
+          }
+        }
+      }
+    }),
+  );
+  return { votes, failedRespondents };
+}
+
+export type SegmentRow = {
+  attribute: string;
+  value: string;
+  n: number;
+  preference: Record<string, number>;
+};
+
+export type MarketResult = {
+  corpus_version: string;
+  audience: string;
+  audience_id: string;
+  population: number;
+  answered: number;
+  candidates: number;
+  preference: Record<string, number>;
+  interval: Record<string, [number, number]>;
+  effective_sample_size: number;
+  position_bias: number | null;
+  /** Weighted mean of each panelist's strongest option probability: 0.5 = individually torn, 1 = individually certain. */
+  mean_certainty: number;
+  segments: SegmentRow[];
+  decision: string;
+};
+
+const SEGMENT_ATTRIBUTES = ["age_band", "sex", "education", "region", "marital"];
+const MIN_SEGMENT_N = 25;
+
+/** Weighted shares, a Kish-effective-sample interval, position bias, and the segment table. */
+export function aggregate(
+  request: MarketRequest,
+  audienceId: string,
+  candidates: number,
+  panel: Map<number, PanelMember>,
+  votes: Vote[],
+): MarketResult {
+  const totals: Record<string, number> = Object.fromEntries(request.options.map((option) => [option.id, 0]));
+  let weightSum = 0;
+  let weightSquares = 0;
+  const byPosition: Record<"forward" | "reversed", { first: number; total: number }> = {
+    forward: { first: 0, total: 0 },
+    reversed: { first: 0, total: 0 },
+  };
+  const segmentTotals = new Map<string, { n: number; weight: number; options: Record<string, number> }>();
+
+  let certaintySum = 0;
+  for (const vote of votes) {
+    const member = panel.get(vote.personaId);
+    if (!member || !(vote.option in totals)) continue;
+    const weight = member.weight;
+    // Probability-mass voting: a persona that would pick A 70% of the time
+    // contributes 0.7 to A, not 1.0. Argmax voting collapses within-person
+    // uncertainty, and because Jev is deliberately consistent, that collapse
+    // herds near-identical personas onto one option and fabricates 99/1
+    // splits no human panel would produce.
+    let mass = 0;
+    for (const option of request.options) mass += Math.max(0, vote.probabilities[option.id] ?? 0);
+    const shares: [string, number][] = mass > 0
+      ? request.options.map((option) => [option.id, Math.max(0, vote.probabilities[option.id] ?? 0) / mass])
+      : [[vote.option, 1]];
+    for (const [optionId, share] of shares) totals[optionId] += weight * share;
+    certaintySum += weight * Math.max(...shares.map(([, share]) => share));
+    weightSum += weight;
+    weightSquares += weight * weight;
+    const positionCell = byPosition[vote.position];
+    positionCell.total += 1;
+    if (vote.option === request.options[0].id) positionCell.first += 1;
+    for (const attribute of SEGMENT_ATTRIBUTES) {
+      const value = member.attrs[attribute];
+      if (typeof value !== "string" || !value) continue;
+      const key = `${attribute}\u0000${value}`;
+      const cell = segmentTotals.get(key) ?? { n: 0, weight: 0, options: Object.fromEntries(request.options.map((option) => [option.id, 0])) };
+      cell.n += 1;
+      cell.weight += weight;
+      for (const [optionId, share] of shares) cell.options[optionId] += weight * share;
+      segmentTotals.set(key, cell);
+    }
+  }
+
+  const answered = votes.filter((vote) => vote.option in totals).length;
+  const preference: Record<string, number> = {};
+  for (const option of request.options) preference[option.id] = weightSum > 0 ? round(totals[option.id] / weightSum) : 0;
+
+  // Kish effective sample size shrinks the interval honestly under reweighting.
+  const effective = weightSum > 0 ? (weightSum * weightSum) / weightSquares : 0;
+  const interval: Record<string, [number, number]> = {};
+  for (const option of request.options) {
+    const share = preference[option.id];
+    const margin = effective > 1 ? 1.96 * Math.sqrt((share * (1 - share)) / effective) : 0.5;
+    interval[option.id] = [round(Math.max(0, share - margin)), round(Math.min(1, share + margin))];
+  }
+
+  const positionBias =
+    byPosition.forward.total >= 20 && byPosition.reversed.total >= 20
+      ? round(Math.abs(byPosition.forward.first / byPosition.forward.total - byPosition.reversed.first / byPosition.reversed.total))
+      : null;
+
+  const overall = preference[request.options[0].id];
+  const segments = [...segmentTotals.entries()]
+    .filter(([, cell]) => cell.n >= MIN_SEGMENT_N && cell.weight > 0)
+    .map(([key, cell]) => {
+      const [attribute, value] = key.split("\u0000");
+      const rowPreference: Record<string, number> = {};
+      for (const option of request.options) rowPreference[option.id] = round(cell.options[option.id] / cell.weight);
+      return {
+        attribute,
+        value,
+        n: cell.n,
+        preference: rowPreference,
+        delta: Math.abs(rowPreference[request.options[0].id] - overall) * Math.sqrt(cell.n),
+      };
+    })
+    .sort((a, b) => b.delta - a.delta)
+    .slice(0, 6)
+    .map(({ delta: _delta, ...row }) => row);
+
+  return {
+    corpus_version: MARKET_CORPUS_VERSION,
+    audience: request.audience,
+    audience_id: audienceId,
+    population: request.population,
+    answered,
+    candidates,
+    preference,
+    interval,
+    effective_sample_size: Math.round(effective),
+    position_bias: positionBias,
+    mean_certainty: weightSum > 0 ? round(certaintySum / weightSum) : 0,
+    segments,
+    decision: request.decision,
+  };
+}
+
+const round = (value: number) => Number(value.toFixed(4));
+
+/** Options must be able to share a request with at least one persona. */
+export function assertOptionsFit(options: MarketOption[]): void {
+  const optionTokens = options.reduce((sum, option) => sum + estimateTokens(option.content) + 20, 0);
+  if (optionTokens > 8000) {
+    throw new MarketError("The options are too long to evaluate together; shorten them or compare fewer at once.", 422);
+  }
+}
+
+export async function sha256Hex(text: string): Promise<string> {
+  const bytes = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+  return [...new Uint8Array(bytes)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
diff --git a/src/mcp.ts b/src/mcp.ts
index 4b43c16..5a25b8f 100644
--- a/src/mcp.ts
+++ b/src/mcp.ts
@@ -121,7 +121,7 @@ function classifyOrError(status: number, body: Record<string, unknown>): ToolRes
 
 type Row = { label?: string; labels?: string[]; confidence?: number | null; scores?: Record<string, number> | null };
 
-export function productServer(classify: ClassifyFn): McpServer {
+export function productServer(classify: ClassifyFn, market?: ClassifyFn): McpServer {
   const urlProperties = {
     url: { type: "string", pattern: "^https?://", maxLength: 8192, description: "Scrape one public URL instead of inputs/items. Requires funded workspace access. Context.dev costs $0.0022 per billed attempt plus classification; long articles need Fast. Errors disclose retained charges. No automatic scrape retries." },
     include: { type: "array", items: { type: "string", enum: ["markdown", "html"] }, description: "With url: return article.markdown and/or article.html at no extra scrape cost. Omit for compact output." },
@@ -394,6 +394,57 @@ export function productServer(classify: ClassifyFn): McpServer {
       },
     },
   ];
+  if (market) tools.push({
+    name: "compare_market_preference",
+    title: "Ask a simulated audience which option it prefers",
+    description:
+      "Poll a panel of simulated US people (drawn from a 285k-persona census-grounded corpus) on which of 2-4 short options they prefer: " +
+      "taglines, headlines, product descriptions, pricing framings, feature choices, email subjects. " +
+      "Describe the audience in plain English; the same audience string always polls the same panel, so repeated calls are comparable A/B/n tests. " +
+      "Returns weighted preference shares with confidence intervals, per-segment splits (age, sex, education, region, marital), " +
+      "a position_bias diagnostic (how much option order moved answers; treat close results with high bias as ties), and mean_certainty " +
+      "(how torn individual panelists were). This estimates relative preference between options, not absolute conversion or purchase rates. " +
+      "A new audience costs ~$0.015 and ~15s to resolve; a cached audience answers in ~1s for ~$0.001-0.01 depending on population.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        audience: { type: "string", maxLength: 400, description: "Who should judge, in plain English: \"US public school teachers\", \"software developers who buy their own tools\", \"parents of young children in the suburbs\"." },
+        options: { type: "array", minItems: 2, maxItems: 4, items: { type: "object", properties: { id: { type: "string", pattern: "^[a-zA-Z0-9_-]{1,32}$" }, content: { type: "string", maxLength: 2000 } }, required: ["content"], additionalProperties: false }, description: "The alternatives to compare, each at most 2,000 characters." },
+        decision: { type: "string", maxLength: 500, description: "The question each panelist answers. Defaults to which option they find more appealing." },
+        population: { type: "integer", minimum: 50, maximum: 2000, default: 500, description: "Panel size. 150-500 suits iteration; use more for final calls." },
+      },
+      required: ["audience", "options"],
+      additionalProperties: false,
+    },
+    outputSchema: {
+      type: "object",
+      properties: {
+        preference: { type: "object", additionalProperties: { type: "number" }, description: "Weighted share per option id; sums to 1." },
+        interval: { type: "object", additionalProperties: { type: "array", items: { type: "number" } }, description: "95% interval per option under the Kish effective sample size." },
+        position_bias: { type: ["number", "null"], description: "Share moved by option order. A gap smaller than this is a tie." },
+        mean_certainty: { type: "number", description: "0.5 = individual panelists torn, 1 = individually certain." },
+        segments: { type: "array", items: { type: "object", properties: { attribute: { type: "string" }, value: { type: "string" }, n: { type: "integer" }, preference: { type: "object", additionalProperties: { type: "number" } } } }, description: "Largest demographic splits, at least 25 panelists each." },
+        answered: { type: "integer" },
+        candidates: { type: "integer", description: "Corpus personas that resembled the audience before membership scoring." },
+        pricing: { type: "object" },
+      },
+      required: ["preference"],
+    },
+    annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    async run(a, ctx) {
+      const r = await market(a, ctx.req);
+      if (r.status !== 200) return { text: JSON.stringify(r.body), structured: r.body, isError: true };
+      const d = r.body as { preference?: Record<string, number>; position_bias?: number | null; mean_certainty?: number; segments?: { attribute: string; value: string; n: number; preference: Record<string, number> }[] };
+      const shares = Object.entries(d.preference ?? {}).sort((p, q) => q[1] - p[1]);
+      const lines = shares.map(([id, share]) => `${(share * 100).toFixed(1)}%\t${id}`);
+      lines.push(`position bias ${d.position_bias == null ? "n/a" : (d.position_bias * 100).toFixed(1) + "%"}, mean certainty ${((d.mean_certainty ?? 0) * 100).toFixed(0)}%`);
+      for (const seg of (d.segments ?? []).slice(0, 4)) {
+        const top = Object.entries(seg.preference).sort((p, q) => q[1] - p[1])[0];
+        lines.push(`${seg.attribute}=${seg.value} (n=${seg.n}): ${top[0]} ${(top[1] * 100).toFixed(0)}%`);
+      }
+      return { text: lines.join("\n"), structured: r.body };
+    },
+  });
 
   return {
     name: "classifier.dev",
diff --git a/src/openapi.ts b/src/openapi.ts
index aaa6225..3a163b2 100644
--- a/src/openapi.ts
+++ b/src/openapi.ts
@@ -662,6 +662,53 @@ export const OPENAPI = {
       operationId: "cancelLongContextJob", tags: ["classify"], summary: "Refund an unfinished job",
       security: [{ accountKey: [] }], parameters: [JOB_ID], responses: JOB_RESPONSE,
     } },
+    "/v1/market/compare": {
+      post: {
+        operationId: "marketCompare",
+        summary: "Ask a simulated audience which option it prefers",
+        description: "Polls a panel drawn from a 285k-persona census-grounded US adult corpus on which of 2-4 short options it prefers. The audience is plain English; the same audience string and population always poll the same panel, so repeated calls are comparable experiments. The first call for an audience resolves and scores it (about $0.015, 15s at the default population); later calls reuse the panel and answer in about a second. Estimates relative preference only, never conversion or market size. Requires an account key; billed per token like classification.",
+        tags: ["classify"],
+        security: [{ accountKey: [] }],
+        requestBody: {
+          required: true,
+          content: { "application/json": { schema: {
+            type: "object",
+            required: ["audience", "options"],
+            additionalProperties: false,
+            properties: {
+              audience: { type: "string", maxLength: 400, description: "Who should judge, in plain English." },
+              options: { type: "array", minItems: 2, maxItems: 4, items: { type: "object", required: ["content"], additionalProperties: false, properties: { id: { type: "string", pattern: "^[a-zA-Z0-9_-]{1,32}$" }, content: { type: "string", maxLength: 2000 } } } },
+              decision: { type: "string", maxLength: 500, description: "The question each panelist answers; defaults to which option they find more appealing." },
+              population: { type: "integer", minimum: 50, maximum: 2000, default: 500 },
+            },
+          } } },
+        },
+        responses: {
+          "200": {
+            description: "Weighted preference shares with diagnostics.",
+            content: { "application/json": { schema: {
+              type: "object",
+              properties: {
+                preference: { type: "object", additionalProperties: { type: "number" }, description: "Probability-mass share per option id; sums to 1." },
+                interval: { type: "object", additionalProperties: { type: "array", items: { type: "number" }, minItems: 2, maxItems: 2 }, description: "95% band under the Kish effective sample size." },
+                position_bias: { type: ["number", "null"], description: "Share moved by option order; a gap smaller than this is a tie." },
+                mean_certainty: { type: "number", description: "0.5 = individual panelists torn, 1 = individually certain." },
+                effective_sample_size: { type: "integer" },
+                answered: { type: "integer" },
+                candidates: { type: "integer" },
+                segments: { type: "array", items: { type: "object", properties: { attribute: { type: "string" }, value: { type: "string" }, n: { type: "integer" }, preference: { type: "object", additionalProperties: { type: "number" } } } } },
+                audience_id: { type: "string" },
+                corpus_version: { type: "string" },
+                pricing: { type: "object" },
+                usage: { type: "object" },
+              },
+              required: ["preference", "answered"],
+            } } },
+          },
+          "422": { description: "The corpus cannot represent this audience; the error says why." },
+        },
+      },
+    },
     "/v1/classify": {
       post: {
         operationId: "classifyV1",
diff --git a/test/api-contract.test.ts b/test/api-contract.test.ts
index 8ec47b3..e4d2569 100644
--- a/test/api-contract.test.ts
+++ b/test/api-contract.test.ts
@@ -13,6 +13,7 @@ import worker from "../src/index";
 import type { Env } from "../src/index";
 import { ERROR_CODES, OPENAPI, UPSTREAM_CODE_PATTERN } from "../src/openapi";
 import { accountReadRoutes } from "../src/http/account";
+import { accountMarket } from "../src/http/market";
 import type { AppEnv } from "../src/server/db";
 
 const ctx = { waitUntil: () => {}, passThroughOnException: () => {} } as unknown as ExecutionContext;
@@ -305,6 +306,15 @@ describe("openapi.json", () => {
           expect((methods[method] as { security: unknown }).security).toEqual([{ accountKey: [] }]);
           continue;
         }
+        // Market is claimed by the account layer and fails closed without its
+        // corpus database configured.
+        if (route === "/v1/market/compare") {
+          await expect(accountMarket(new Request(`https://classifier.dev${route}`, {
+            method: "POST", headers: { authorization: "Bearer classifier_agent_x" },
+          }), {} as never, ctx)).rejects.toMatchObject({ status: 503 });
+          expect((methods[method] as { security: unknown }).security).toEqual([{ accountKey: [] }]);
+          continue;
+        }
         if (method === "post") init.body = route === "/v1/systemone"
           ? '{"state":"b please","model":"jev-latest","questions":{"category":{"type":"choice","criteria":{"a":null,"b":null}}}}'
           : route.startsWith("/api/") ? "{}" : '{"input":"b please","labels":["a","b"]}';
diff --git a/test/market.test.ts b/test/market.test.ts
new file mode 100644
index 0000000..44a0b3b
--- /dev/null
+++ b/test/market.test.ts
@@ -0,0 +1,198 @@
+import { describe, expect, test } from "bun:test";
+import {
+  aggregate,
+  membershipGroups,
+  membershipWeight,
+  readMarketRequest,
+  runVotes,
+  samplePanel,
+  seededRandom,
+  voteBatches,
+  type MarketRequest,
+  type PanelMember,
+  type Vote,
+} from "../src/market";
+import type { JevAnswer } from "../src/jev";
+
+const options = [
+  { id: "a", content: "Ask your users before you ship." },
+  { id: "b", content: "The data layer for AI agents." },
+];
+const request: MarketRequest = { audience: "US software developers", options, decision: "Which tagline is stronger?", population: 100 };
+
+describe("readMarketRequest", () => {
+  test("fills ids, decision, and population", () => {
+    const parsed = readMarketRequest({ audience: "devs", options: ["one", "two"] });
+    expect(parsed.options.map((option) => option.id)).toEqual(["a", "b"]);
+    expect(parsed.population).toBe(500);
+    expect(parsed.decision).toContain("appealing");
+  });
+
+  test("rejects missing audience, bad counts, oversized options, and bad population", () => {
+    expect(() => readMarketRequest({ options: ["x", "y"] })).toThrow("audience");
+    expect(() => readMarketRequest({ audience: "devs", options: ["only"] })).toThrow("2-4");
+    expect(() => readMarketRequest({ audience: "devs", options: ["x".repeat(2001), "y"] })).toThrow("2000");
+    expect(() => readMarketRequest({ audience: "devs", options: ["x", "y"], population: 7 })).toThrow("between");
+    expect(() => readMarketRequest({ audience: "devs", options: [{ id: "a", content: "x" }, { id: "a", content: "y" }] })).toThrow("Duplicate");
+  });
+});
+
+describe("panel sampling", () => {
+  test("is deterministic for a seed and honours the weight floor", () => {
+    const candidates = Array.from({ length: 500 }, (_, i) => ({ id: i, weight: i % 7 === 0 ? 0.05 : 0.3 + (i % 10) / 20 }));
+    const first = samplePanel(candidates, 100, "aud_x");
+    const second = samplePanel(candidates, 100, "aud_x");
+    expect(first.map((m) => m.id)).toEqual(second.map((m) => m.id));
+    expect(first).toHaveLength(100);
+    expect(first.every((m) => m.weight >= 0.15)).toBe(true);
+    expect(samplePanel(candidates, 100, "aud_y").map((m) => m.id)).not.toEqual(first.map((m) => m.id));
+  });
+
+  test("seededRandom streams differ by seed and repeat by seed", () => {
+    const a = seededRandom("one");
+    const b = seededRandom("one");
+    const c = seededRandom("two");
+    const roll = (f: () => number) => Array.from({ length: 5 }, f);
+    expect(roll(a)).toEqual(roll(b));
+    expect(roll(seededRandom("two"))).toEqual(roll(c));
+  });
+});
+
+describe("membership", () => {
+  test("groups carry one score question per candidate", () => {
+    const groups = membershipGroups("US nurses", [{ id: 7, text: "a nurse in Ohio" }]);
+    expect(groups).toHaveLength(1);
+    const question = Object.values(groups[0].questions)[0];
+    expect(question.type).toBe("score");
+    if (question.type === "score") expect(question.criteria).toHaveLength(4);
+    expect(question.instructions).toContain("p7");
+    expect(question.instructions).toContain("US nurses");
+  });
+
+  test("weight blends squarely and plausibly and survives missing answers", () => {
+    expect(membershipWeight({ score: 2.8, confidence: 0.9, probabilities: { "0": 0, "1": 0, "2": 0.2, "3": 0.8 } })).toBeCloseTo(0.9);
+    expect(membershipWeight({ score: 0.2, confidence: 0.9, probabilities: { "0": 0.9, "1": 0.1, "2": 0, "3": 0 } })).toBe(0);
+    expect(membershipWeight(undefined)).toBe(0);
+  });
+});
+
+describe("voteBatches", () => {
+  test("shares options through state and counterbalances criteria order", () => {
+    const panel = Array.from({ length: 90 }, (_, i) => ({ id: i, text: `person ${i}` }));
+    const batches = voteBatches(options, panel, "Which is stronger?");
+    expect(batches.length).toBe(3);
+    for (const batch of batches) {
+      expect(batch.state[0].id).toBe("option_a");
+      expect(batch.state[1].id).toBe("option_b");
+    }
+    const orders = new Set<string>();
+    for (const batch of batches) {
+      for (const question of Object.values(batch.questions)) {
+        if (question.type === "choice") orders.add(Object.keys(question.criteria).join(","));
+      }
+    }
+    expect(orders).toEqual(new Set(["option_a,option_b", "option_b,option_a"]));
+  });
+});
+
+describe("runVotes", () => {
+  const panel = Array.from({ length: 8 }, (_, i) => ({ id: i, text: `person ${i}` }));
+
+  test("collects votes and maps criteria back to option ids", async () => {
+    const batches = voteBatches(options, panel, "Which?");
+    const { votes, failedRespondents } = await runVotes({} as never, batches, options, undefined, async (_keys, _state, questions) => ({
+      model: "test",
+      answers: Object.fromEntries(Object.keys(questions).map((id) => [
+        id, { choice: "option_b", confidence: 0.8, probabilities: { option_a: 0.2, option_b: 0.8 } } satisfies JevAnswer,
+      ])),
+    }));
+    expect(failedRespondents).toBe(0);
+    expect(votes).toHaveLength(8);
+    expect(new Set(votes.map((vote) => vote.option))).toEqual(new Set(["b"]));
+    expect(new Set(votes.map((vote) => vote.position))).toEqual(new Set(["forward", "reversed"]));
+  });
+
+  test("halves failed batches so one bad request only costs its own respondents", async () => {
+    const batches = voteBatches(options, panel, "Which?");
+    let calls = 0;
+    const { votes, failedRespondents } = await runVotes({} as never, batches, options, undefined, async (_keys, state, questions) => {
+      calls++;
+      const personas = state.filter((item) => item.id.startsWith("p"));
+      if (personas.some((item) => item.id === "p3") && personas.length > 1) throw new Error("boom");
+      return {
+        model: "test",
+        answers: Object.fromEntries(Object.keys(questions).map((id) => [
+          id, { choice: "option_a", confidence: 0.7, probabilities: { option_a: 0.7, option_b: 0.3 } } satisfies JevAnswer,
+        ])),
+      };
+    });
+    expect(calls).toBeGreaterThan(1);
+    expect(votes.length + failedRespondents).toBe(8);
+    expect(failedRespondents).toBeLessThanOrEqual(1);
+    for (const batchVote of votes) expect(batchVote.option).toBe("a");
+  });
+});
+
+describe("aggregate", () => {
+  function buildPanel(n: number): Map<number, PanelMember> {
+    const panel = new Map<number, PanelMember>();
+    for (let i = 0; i < n; i++) {
+      panel.set(i, {
+        id: i, weight: 1,
+        attrs: { age_band: i < n / 2 ? "25-34" : "55-64", sex: i % 2 ? "male" : "female", education: "some college", region: "West", marital: "single" },
+      });
+    }
+    return panel;
+  }
+
+  test("weighted shares, interval, position bias, and segments", () => {
+    const panel = buildPanel(200);
+    const votes: Vote[] = [...panel.values()].map((member, index) => {
+      const prefersB = member.attrs.age_band === "25-34" ? index % 10 < 8 : index % 2 === 0;
+      return {
+        personaId: member.id,
+        option: prefersB ? "b" : "a",
+        confidence: 0.8,
+        position: (index % 2 === 0 ? "forward" : "reversed") as Vote["position"],
+        probabilities: prefersB ? { a: 0.2, b: 0.8 } : { a: 0.8, b: 0.2 },
+      };
+    });
+    const result = aggregate(request, "aud_1", 1500, panel, votes);
+    expect(result.answered).toBe(200);
+    expect(result.preference.a + result.preference.b).toBeCloseTo(1, 5);
+    expect(result.preference.b).toBeGreaterThan(0.5);
+    expect(result.interval.b[0]).toBeLessThan(result.preference.b);
+    expect(result.interval.b[1]).toBeGreaterThan(result.preference.b);
+    expect(result.effective_sample_size).toBe(200);
+    expect(result.position_bias).not.toBeNull();
+    const ageRows = result.segments.filter((segment) => segment.attribute === "age_band");
+    expect(ageRows.length).toBeGreaterThan(0);
+    const young = ageRows.find((segment) => segment.value === "25-34");
+    const old = ageRows.find((segment) => segment.value === "55-64");
+    if (young && old) expect(young.preference.b).toBeGreaterThan(old.preference.b);
+  });
+
+  test("unequal weights shrink the effective sample size", () => {
+    const panel = buildPanel(100);
+    for (const member of panel.values()) member.weight = member.id % 2 ? 1 : 0.2;
+    const votes: Vote[] = [...panel.values()].map((member) => ({
+      personaId: member.id, option: "a", confidence: 0.9, position: "forward" as const, probabilities: { a: 1, b: 0 },
+    }));
+    const result = aggregate(request, "aud_2", 900, panel, votes);
+    expect(result.effective_sample_size).toBeLessThan(100);
+    expect(result.preference.a).toBe(1);
+  });
+});
+
+describe("account MCP server", () => {
+  test("exposes the market tool exactly when a market callback is wired", async () => {
+    const { productServer } = await import("../src/mcp");
+    const noop = async () => ({ status: 200, body: {} });
+    expect(productServer(noop, noop).tools.map((tool) => tool.name)).toContain("compare_market_preference");
+    expect(productServer(noop).tools.map((tool) => tool.name)).not.toContain("compare_market_preference");
+    // The account layer passes that callback; a regression here silently
+    // serves the free five-tool list to paying MCP clients.
+    const source = await Bun.file(new URL("../src/http/mcp.ts", import.meta.url)).text();
+    expect(source).toContain("}, marketFn),");
+  });
+});
diff --git a/tests/runtime-config.test.ts b/tests/runtime-config.test.ts
index b75577e..7cb6a56 100644
--- a/tests/runtime-config.test.ts
+++ b/tests/runtime-config.test.ts
@@ -66,8 +66,8 @@ test("deployment migrates directly and gives the Worker only the pooled URL", ()
   expect(workflow).toContain("DATABASE_URL: ${{ secrets.DATABASE_URL_UNPOOLED }}\n        run: npm run db:migrate");
   // The Worker's secrets file carries the pooled URL and, only when both are
   // set, the chunklaya pair; the deploy step never sees the unpooled URL.
-  expect(workflow).toContain("const { DATABASE_URL, CHUNKLAYA_URL, CHUNKLAYA_TOKEN, DGEMMA_URL, DGEMMA_TOKEN } = process.env;");
-  expect(workflow).toContain("JSON.stringify({ DATABASE_URL, ...(CHUNKLAYA_URL && CHUNKLAYA_TOKEN ? { CHUNKLAYA_URL, CHUNKLAYA_TOKEN } : {}), ...(DGEMMA_URL && DGEMMA_TOKEN ? { DGEMMA_URL, DGEMMA_TOKEN } : {}) })");
+  expect(workflow).toContain("const { DATABASE_URL, CHUNKLAYA_URL, CHUNKLAYA_TOKEN, DGEMMA_URL, DGEMMA_TOKEN, MARKET_DATABASE_URL } = process.env;");
+  expect(workflow).toContain("JSON.stringify({ DATABASE_URL, ...(CHUNKLAYA_URL && CHUNKLAYA_TOKEN ? { CHUNKLAYA_URL, CHUNKLAYA_TOKEN } : {}), ...(DGEMMA_URL && DGEMMA_TOKEN ? { DGEMMA_URL, DGEMMA_TOKEN } : {}), ...(MARKET_DATABASE_URL ? { MARKET_DATABASE_URL } : {}) })");
   const deployStep = workflow.slice(workflow.indexOf("- name: Deploy\n"), workflow.indexOf("npx wrangler deploy"));
   expect(deployStep).not.toContain("UNPOOLED");
   expect(workflow).not.toContain("JSON.stringify({ DATABASE_URL_UNPOOLED:");
diff --git a/wrangler.example.toml b/wrangler.example.toml
index 4c58290..9c24bd9 100644
--- a/wrangler.example.toml
+++ b/wrangler.example.toml
@@ -20,6 +20,8 @@ region = "aws:us-west-2"
 
 # Set the pooled runtime URL as a Worker secret, never a plaintext var. CI uses
 # a separate direct DATABASE_URL_UNPOOLED secret for migrations.
+# MARKET_DATABASE_URL (optional) points POST /v1/market/compare at the persona
+# corpus database; without it the endpoint answers 503.
 [secrets]
 required = ["DATABASE_URL"]