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"]