@vibes.diy/api-svc 14.3.87 → 14.3.90

package/intern/mercury-first-build.js

@@ -3,29 +3,19 @@ import { and, eq } from "drizzle-orm";
 import { type } from "arktype";
 import { lazyType } from "@vibes.diy/api-types/lazy-type";
 import { sanitizeRoomShortlist } from "@vibes.diy/prompts";
-import { KNOWN_VALUES_DIRECT_CONTROLS, ONE_TREE_PER_PERSON } from "./agent-session-instruction.js";
 import { keepsToThemselves as keepsToThemselvesWords } from "./keeps-to-themselves.js";
+import { KNOWN_VALUES_DIRECT_CONTROLS } from "./agent-session-instruction.js";
 import { poufRoomCatalog, poufRoomSlugs } from "./pouf-room-catalog.js";
 import { vibeFontCatalog, vibeFontSlugs } from "./vibe-font-catalog.js";
 import { slugWordBag } from "./ensure-slug-binding.js";
 import { MERCURY_CAPABILITY_TRIGGERS } from "./mercury-capability-triggers.js";
 import { parseRetryAfterMs, readFailureBody, waitMs } from "../public/provider-errors.js";
-import { MERCURY_BREAKER, MERCURY_MIN_ATTEMPT_MS, MERCURY_STAGE_BUDGET_MS, MercuryCircuitBreaker, MercuryStageError, mercuryBudget, mercuryRetryWaitMs, mercuryTesterRetryWaitMs, MERCURY_TESTER_FANOUT, MERCURY_TESTER_REQUEST_DEADLINE_MS, MERCURY_TESTER_STAGE_BUDGET_MS, } from "./mercury-resilience.js";
+import { MERCURY_BREAKER, MERCURY_MIN_ATTEMPT_MS, MercuryCircuitBreaker, MercuryStageError, mercuryBudget, mercuryTesterRetryWaitMs, MERCURY_TESTER_FANOUT, MERCURY_TESTER_REQUEST_DEADLINE_MS, MERCURY_TESTER_STAGE_BUDGET_MS, } from "./mercury-resilience.js";
 export const MERCURY_FIRST_BUILD_MODEL = "inception/mercury-2.5";
 export const MERCURY_FIRST_BUILD_REASONING = { effort: "none" };
-export const MERCURY_OPUS_PLANNER_MODEL = "~anthropic/claude-opus-latest";
-export const MERCURY_OPUS_PLANNER_DEADLINE_MS = 240_000;
-export const MERCURY_OPUS_PLANNER_BUDGET_MS = 300_000;
-export const MERCURY_OPUS_PLANNER_FANOUT = 1;
-export const MERCURY_OPUS_PLANNER_MAX_TOKENS = 8_000;
-export const MERCURY_OPUS_PLANNER_BREAKER = new MercuryCircuitBreaker();
 export const MERCURY_HAIKU_PLANNER_MODEL = "anthropic/claude-haiku-5.5";
-export const MERCURY_HAIKU_PLANNER_DEADLINE_MS = 40_000;
-export const MERCURY_HAIKU_PLANNER_BUDGET_MS = 50_000;
 export const MERCURY_HAIKU_PLANNER_BREAKER = new MercuryCircuitBreaker();
 function plannerModel(planner) {
-    if (planner === "opus")
-        return { id: MERCURY_OPUS_PLANNER_MODEL };
     if (planner === "haiku")
         return { id: MERCURY_HAIKU_PLANNER_MODEL, reasoning: { enabled: false } };
     return { id: MERCURY_FIRST_BUILD_MODEL, reasoning: MERCURY_FIRST_BUILD_REASONING };
@@ -33,9 +23,6 @@ function plannerModel(planner) {
 function plannerAskedModel(planner) {
     return plannerModel(planner ?? "mercury").id;
 }
-export const MERCURY_CALL_DEADLINE_MS = 8_000;
-export const MERCURY_CALL_ATTEMPTS = 2;
-export const MERCURY_TRANSIENT_RETRIES = 3;
 const MERCURY_TRANSIENT_STATUSES = new Set([429, 502, 503, 504]);
 class MercuryTransientError extends Error {
     status;
@@ -59,104 +46,12 @@ export const MERCURY_FLAGS = [
     "boardGame",
     "sensitive",
 ];
-export const MERCURY_BRIEF_FIELDS = ["opening", "access", "seed", "look", "pairs", "icon"];
-export const MERCURY_SHAPE_SYSTEM = `You classify a person's one-message request for a small web app before a build brief is written. Return only JSON.
-
-archetype, exactly one:
-- personal: one person's own tool ("for me", "my", "private", a tracker, a log, a list, a journal) with no other people named.
-- group: the person names other people who use it with them (we, our, friends, family, team, club, kids, housemates, partner, members, a foursome).
-- publish: the person writes and other people only read (a blog, menu, gallery, portfolio, schedule, zine, "everyone can read").
-- intake: strangers or customers submit something without signing up and the person sees the submissions (orders, bookings, requests, sign-ups, replies, reports from the public).
-- open: anyone with the link joins in and adds their own bit (a shared wall, canvas, feed, leaderboard game, community board, swap board, "anyone can post").
-- toy: a game, simulator, visual, sound or generator that keeps little or nothing (scores at most).
-Tie-breaks: group means other people open the app on their own devices; a calculator, splitter or tool used on one phone "with friends" at the table is personal. toy is for games, simulators and visual or sound toys; a tool that analyzes, estimates, designs, counts, tracks or logs stores records and is personal. A "feed of information" pulled from the internet is personal with backend true. A test or nonsense phrase is still a request: make the most playful literal app of it (a "squash bloom soothsayer" is a fortune teller about squash) and classify that.
-
-coreAction: the one thing the person does most in this app, as a short verb phrase in their own words ("tap once per glass", "paste the group chat", "lasso cows"). It becomes the biggest control on the first screen.
-kind: 2-6 word noun phrase for the app in the person's own nouns. who: who it is for, 2-8 words.
-recordNames: 1-5 short singular record type names the app stores (toys may have just "score" or none).
-flags, each true only when the request itself needs it:
-- ai: the app must read, write or judge free text or photos with a language model (extract facts from pasted words, answer questions, generate text, chat, analyze a picture, suggest recipes).
-- composer: ai is true AND the person types or pastes their own words or photos as the way records get in.
-- imageGen: the app generates pictures.
-- backend: server work the page cannot do: scheduled reminders or digests, a live feed pulled from outside, secret dealing, email.
-- calendar: dates on a calendar, bookings by slot, recurring events, paystub periods.
-- audio: sound or music playback or synthesis.
-- threeD: 3D graphics, a simulator, a world you move through.
-- charts: heatmaps, graphs, statistics views.
-- boardGame: a turn-based card or board game.
-- sensitive: health, money of real people, kids, or the word private.`;
-export function mercuryShapeSchema() {
-    return {
-        type: "object",
-        additionalProperties: false,
-        required: ["archetype", "coreAction", "kind", "who", "recordNames", ...MERCURY_FLAGS],
-        properties: {
-            archetype: { type: "string", enum: [...MERCURY_ARCHETYPES] },
-            coreAction: { type: "string" },
-            kind: { type: "string" },
-            who: { type: "string" },
-            recordNames: { type: "array", items: { type: "string" } },
-            ...Object.fromEntries(MERCURY_FLAGS.map((f) => [f, { type: "boolean" }])),
-        },
-    };
-}
-export function mercuryShapeMessages(o) {
-    return [
-        { role: "system", content: [{ type: "text", text: MERCURY_SHAPE_SYSTEM }] },
-        { role: "user", content: [{ type: "text", text: `Person's words: "${o.personWords}"` }] },
-    ];
-}
-const shapeParsed = lazyType(() => type({
-    archetype: type.enumerated(...MERCURY_ARCHETYPES),
-    coreAction: "string",
-    kind: "string",
-    who: "string",
-    recordNames: "string[]",
-    ai: "boolean",
-    composer: "boolean",
-    imageGen: "boolean",
-    backend: "boolean",
-    calendar: "boolean",
-    audio: "boolean",
-    threeD: "boolean",
-    charts: "boolean",
-    boardGame: "boolean",
-    sensitive: "boolean",
-}));
-export function parseMercuryShape(raw) {
-    const p = shapeParsed(raw);
-    if (p instanceof type.errors)
-        return Result.Err(`mercury shape: ${p.summary}`);
-    if (p.coreAction.trim().length === 0)
-        return Result.Err("mercury shape: empty coreAction");
-    return Result.Ok({
-        archetype: p.archetype,
-        coreAction: p.coreAction.trim(),
-        kind: p.kind.trim(),
-        who: p.who.trim(),
-        recordNames: p.recordNames,
-        flags: {
-            ai: p.ai,
-            composer: p.composer,
-            imageGen: p.imageGen,
-            backend: p.backend,
-            calendar: p.calendar,
-            audio: p.audio,
-            threeD: p.threeD,
-            charts: p.charts,
-            boardGame: p.boardGame,
-            sensitive: p.sensitive,
-        },
-    });
-}
 const COMPOSER_WORDS = /paste|photo|picture|own words|however they|repl(y|ies)|in their words|type in|jot/;
-const BACKEND_WORDS = /remind|notif|email|digest|schedul|every (day|week|morning|monday)|nag|feed|sync|server|secret|deal|webhook|cron|poll/;
 const PRIVATE_WORDS = /\b(private|just for me|only me|for myself)\b/;
-const MULTIPLAYER_WORDS = /\b(friends? can join|multiplayer|same world)\b/;
-export function fixMercuryShape(shape, personWords, opts = {}) {
+const MULTIPLAYER_WORDS = /\b(friends? can join|multi-?players?|same world)\b/;
+export function fixMercuryShape(shape, personWords) {
     const m = personWords.toLowerCase();
     const composer = shape.flags.ai && shape.flags.composer && COMPOSER_WORDS.test(m);
-    const backend = shape.flags.backend && (opts.keepBackend === true || BACKEND_WORDS.test(m));
     const privateAsk = PRIVATE_WORDS.test(m);
     const keepsToThemselves = keepsToThemselvesWords(personWords);
     const keepsPersonal = keepsToThemselves && shape.archetype !== "toy" && shape.archetype !== "personal";
@@ -172,28 +67,25 @@ export function fixMercuryShape(shape, personWords, opts = {}) {
             .map((r) => r.trim())
             .filter((r) => r.length > 0)
             .slice(0, 5),
-        flags: { ...shape.flags, composer, backend },
+        flags: { ...shape.flags, composer, threeD: shape.flags.threeD || mercuryBlockWorldNamed(personWords) },
         ...(keepsToThemselves ? { keepsToThemselves: true } : {}),
     };
 }
-const draftShapeParsed = lazyType(() => type({
+const briefShapeParsed = lazyType(() => type({
     archetype: type.enumerated(...MERCURY_ARCHETYPES),
     coreAction: "string",
     recordNames: "string[]",
     capabilities: type.enumerated(...MERCURY_FLAGS).array(),
 }));
-export function mercuryBackendWordsNamed(personWords) {
-    return BACKEND_WORDS.test(personWords.toLowerCase());
-}
-export function parseMercuryDraftShape(raw, personWords) {
-    const p = draftShapeParsed(raw);
+export function parseMercuryBriefShape(raw, personWords) {
+    const p = briefShapeParsed(raw);
     if (p instanceof type.errors)
         return Result.Err(`mercury classification: ${p.summary}`);
     if (p.coreAction.trim().length === 0)
         return Result.Err("mercury classification: empty coreAction");
     const caps = new Set(p.capabilities);
     const flags = Object.fromEntries(MERCURY_FLAGS.map((f) => [f, caps.has(f)]));
-    return Result.Ok(fixMercuryShape({ archetype: p.archetype, coreAction: p.coreAction.trim(), kind: "", who: "", recordNames: p.recordNames, flags }, personWords, { keepBackend: true }));
+    return Result.Ok(fixMercuryShape({ archetype: p.archetype, coreAction: p.coreAction.trim(), recordNames: p.recordNames, flags }, personWords));
 }
 function setFlags(flags) {
     return MERCURY_FLAGS.filter((f) => flags[f]);
@@ -210,14 +102,7 @@ function splitMercurySlugs(v) {
 export function mercuryAddressEncoding() {
     const strings = (v) => Array.isArray(v) && v.every((t) => typeof t === "string");
     return {
-        properties: { title: { type: "string" }, slugs: { type: "array", items: { type: "string" } } },
-        rule: "The title is the app's name in Title Case, two or three words in its own vocabulary. The slugs are three short kebab-case addresses for that one app, as an array of three strings; each becomes a web address and they need not repeat the title.",
-        ask: "title: the app's name, two or three words; slugs: an array of three short kebab-case addresses",
-        hints: {
-            title: "the app's name, two or three words in its own vocabulary",
-            slugs: "three short kebab-case addresses for the app",
-        },
-        example: (title, slugs) => [`title: ${title}`, `slugs: ${JSON.stringify(slugs)}`],
+        rule: "The title is the app's name in Title Case, two or three words in its own vocabulary. The slugs are three short kebab-case addresses for that one app, comma-separated; each becomes a web address.",
         decode: (reply) => {
             const repairs = new Set();
             let title;
@@ -247,7 +132,6 @@ export function mercuryAddressEncoding() {
                 return Result.Err("slugs-shape");
             return Result.Ok({ ...(title === undefined ? {} : { title }), slugs, repairs: [...repairs] });
         },
-        salvage: (json) => (strings(json) && json.length === 3 ? { slugs: json } : undefined),
     };
 }
 export const MERCURY_ADDRESS = mercuryAddressEncoding();
@@ -256,559 +140,25 @@ export function mercurySlugWordsSentence(words) {
         ? ""
         : `Fold a different one of these words into each slug, picking the ones that best suit the app; the title stays in the app's own words: ${words.join(", ")}.`;
 }
-const MERCURY_SLOT_HINTS = {
-    opening: "one sentence: what it is, who it is for, and the moment that makes it fun to open",
-    access: "who owns the object, who else is let in, what a visitor sees; the archetype's shape",
-    seed: "demo: a lively cast and where each one stands, in words: who is ahead, what is overdue, what just happened",
-    look: "one scene: surface, palette, card shape, one gesture of mood",
-    icon: "one object from the app's world",
-};
-export const MERCURY_OWN_WORLD_SEED_HINT = "demo: a lively cast and where each one stands, in words, in states this app's own records hold";
-function replyKey(f) {
-    return f === "seed" ? "demo" : f;
-}
 export const MERCURY_ROOMS_HINT = "an array of 2 or 3 room slugs from the room list";
-export const MERCURY_ROOMS_ASK = `Also rooms: ${MERCURY_ROOMS_HINT}.`;
 export const MERCURY_FONT_HINT = "one font slug from the font list";
-export const MERCURY_FONT_ASK = `Also font: ${MERCURY_FONT_HINT}.`;
-export const MERCURY_CLASSIFY_HINTS = {
-    archetype: "one of personal, group, publish, intake, open, toy: the ownership shape that fits the person's words",
-    coreAction: "the one thing the person does most in this app, a short verb phrase in their own words",
-    recordNames: "an array of 1 to 5 short singular record type names the app stores",
-    capabilities: "an array naming only the capabilities this request needs, from the capability list; empty when none",
-};
-function withClassifyFirst(obj, classify, value) {
-    if (!classify)
-        return obj;
-    return { ...Object.fromEntries(Object.keys(MERCURY_CLASSIFY_HINTS).map((k) => [k, value(k)])), ...obj };
-}
-export function mercuryAnswerSkeleton(fields, opts = {}) {
-    const lead = (o) => withClassifyFirst(o, opts.classify === true, (k) => `<${MERCURY_CLASSIFY_HINTS[k]}>`);
-    const obj = {};
-    const recordsRules = opts.recordsRules === true;
-    const seedHint = recordsRules
-        ? MERCURY_RECORDS_SEED_HINT
-        : opts.juice === "own-world"
-            ? MERCURY_OWN_WORLD_SEED_HINT
-            : MERCURY_SLOT_HINTS.seed;
-    const screensHint = recordsRules ? MERCURY_RECORDS_SCREENS_HINT : MERCURY_DEPTH_SCREENS_HINT;
-    for (const f of fields) {
-        if (f === "pairs")
-            for (const [k, hint] of Object.entries(MERCURY_ADDRESS.hints))
-                obj[k] = `<${hint}>`;
-        else
-            obj[replyKey(f)] = `<${f === "seed" ? seedHint : MERCURY_SLOT_HINTS[f]}>`;
-    }
-    const withRecords = (o) => recordsRules ? withRecordsKeys(o, `<${MERCURY_RECORDS_HINT}>`, `<${MERCURY_RULES_HINT}>`) : o;
-    if (opts.story === true || opts.preamble === true) {
-        const outline = withRecords(opts.screens === true ? withScreensKey(obj, `<${screensHint}>`) : obj);
-        const whole = withWholeKeys(outline, {
-            ...(opts.story === true ? { story: `<${MERCURY_STORY_HINT}>` } : {}),
-            ...(opts.preamble === true ? { preamble: `<${MERCURY_WHOLE_PREAMBLE_HINT}>` } : {}),
-        });
-        if (opts.rooms === true)
-            whole.rooms = `<${MERCURY_ROOMS_HINT}>`;
-        if (opts.font === true)
-            whole.font = `<${MERCURY_FONT_HINT}>`;
-        return JSON.stringify(lead(whole), null, 1);
-    }
-    const out = withRecords(opts.screens === true ? withScreensKey(obj, `<${screensHint}>`) : obj);
-    if (opts.rooms === true)
-        out.rooms = `<${MERCURY_ROOMS_HINT}>`;
-    if (opts.font === true)
-        out.font = `<${MERCURY_FONT_HINT}>`;
-    return JSON.stringify(lead(out), null, 1);
-}
-const MERCURY_EXEMPLARS = [
-    {
-        archetype: "personal",
-        opening: "A glaze test notebook for a home potter, where opening the kiln means a fresh tile to rate.",
-        access: "Each signed-in person has their own notebook object (keyed on their handle, named for the app, renameable in settings); glazes and tiles carry the notebook id so a studio mate could be let in later. The creator reads and writes it alone.",
-        demo: "demo: the owner's notebook with Tenmoku the favourite glaze, Shino just mixed and Celadon still untested; tiles fired recently, the Chun blue one the best yet, an Ash tile cracked last week and still waiting for a good one.",
-        look: "Earthy studio: oatmeal background, iron-red accents, chunky rounded tile cards.",
-        title: "Glaze Ledger",
-        slugs: ["glaze-ledger", "kiln-tile-book", "glaze-notes"],
-        icon: "a glazed test tile beside a small kiln",
-    },
-    {
-        archetype: "group",
-        opening: "A tool library for one neighbourhood block, shared by the households on it, where a returned ladder lights up for the next borrower.",
-        access: "Each signed-in person starts with their own block library object. Households are let in with the platform's HandleInput invite screen, which writes a membership into the library; members read every tool and write their own loans. The library list shows shared ones with ViewerTag.",
-        demo: 'demo: the library "Maple Street Tools" with the owner\'s own membership plus @priya and @tomas; the ladder out with @priya and due back soon, the tile saw overdue with @tomas, the pressure washer just returned and waiting for its next loan.',
-        look: "Workshop pegboard: plywood tones, safety-orange accents, square tool cards with big status chips.",
-        title: "Block Tools",
-        slugs: ["block-tools", "maple-street-shelf", "borrow-board"],
-        icon: "a hand drill inside a house outline",
-    },
-    {
-        archetype: "publish",
-        opening: "A taco truck menu board the owner updates from their phone and customers read, where a sold-out stamp lands the moment the last plate goes.",
-        access: "The owner's menu object is keyed on their handle. Menu items are written by the owner and readable by everyone, signed in or not. Shaped so a co-owner could be let in later.",
-        demo: "demo: the owner's menu across tacos, sides and drinks; the al pastor sold out just now, the horchata nearly gone, a new salsa added this morning, and today's note from the owner.",
-        look: "Street-food bright: chalkboard dark with chalk-white type and chili-red price tags.",
-        title: "Taco Today",
-        slugs: ["taco-today", "truck-board", "menu-chalk"],
-        icon: "a chalkboard with a taco drawn on it",
-    },
-    {
-        archetype: "intake",
-        opening: "An appointment book for a dog grooming salon: clients book without signing up, and the groomer watches the day fill in.",
-        access: "Two sides. Clients book anonymously: anyone, signed in or not, can create a booking record on the salon object and reads back the confirmation they just made. The groomer, signed in as the salon's owner, reads and updates every booking.",
-        demo: "demo: the owner's salon with bookings in every state; Biscuit checked in just now, Juno booked for later today, Pepper still waiting on confirmation, Moss cancelled yesterday.",
-        look: "Clean salon: pale mint, charcoal type, generous slot buttons easy to tap one-handed.",
-        title: "Groom Book",
-        slugs: ["groom-book", "salon-slots", "paws-diary"],
-        icon: "a dog brush beside a clock face",
-    },
-    {
-        archetype: "open",
-        opening: "A lost-and-found board for a music festival that anyone with the link can post to, where a found tag turns a post green.",
-        access: "The owner creates the board and names it for the app. Any visitor with the link reads the whole board and writes their own posts; each poster edits or removes what they wrote, keyed on the record's creator. The board creator can remove anything.",
-        demo: "demo: the festival board with posts from a handful of handles; @lin's lost phone found just now, @ari's jacket still missing since last night, a set of keys claimed this morning.",
-        look: "Festival poster: cream paper, bold two-colour print, pinned-note cards with torn edges.",
-        title: "Festival Finds",
-        slugs: ["festival-finds", "lost-tent", "found-it"],
-        icon: "a tent peg tied with a ribbon",
-    },
-    {
-        archetype: "toy",
-        opening: "A hex-grid pong game with a slow-motion ball, where a long rally sets the board glowing.",
-        access: "Each signed-in player keeps a best score record keyed on their handle; a shared Top Scores list shows everyone's best with ViewerTag.",
-        demo: "demo: score records from a small cast; @rin on top, the owner close behind and climbing, @bo just joined with no score yet, so the Top Scores list opens filled.",
-        look: "Neon arcade: deep navy, electric cyan ball, glowing hex outlines.",
-        title: "Hex Pong",
-        slugs: ["hex-pong", "slow-rally", "honey-paddle"],
-        icon: "a hexagonal paddle and a glowing ball",
-    },
-];
-export function mercuryFieldArchetypes(archetype) {
-    return [archetype, ...MERCURY_ARCHETYPES.filter((a) => a !== archetype).slice(0, 2)];
-}
-const MERCURY_EXEMPLAR_CLASSIFICATION = {
-    personal: { coreAction: "rate a fresh test tile", records: ["glaze", "tile"] },
-    group: { coreAction: "borrow a tool", records: ["library", "membership", "tool", "loan"] },
-    publish: { coreAction: "mark a dish sold out", records: ["menu", "menu item"] },
-    intake: { coreAction: "book a grooming slot", records: ["salon", "booking"] },
-    open: { coreAction: "post a lost or found item", records: ["board", "post"] },
-    toy: { coreAction: "keep the rally going", records: ["score"] },
-};
-const MERCURY_EXEMPLAR_RECORDS = {
-    personal: {
-        records: "notebook (name); glaze (name, recipe, cone, notes); tile (glaze, fired on, rating, note)",
-        rules: "each glaze shows its best-rated tile; a cracked tile never counts toward its glaze's rating",
-    },
-    group: {
-        records: "library (name); membership (library, handle); tool (name, condition); loan (tool, borrower, due back, returned at)",
-        rules: "a tool is out with one borrower at a time; returning it frees it for the next borrower",
-    },
-    publish: {
-        records: "menu (name, today's note); menu item (name, price, section, sold out)",
-        rules: "a sold-out item stays on the board, stamped, until the owner clears it",
-    },
-    intake: {
-        records: "salon (name, hours); booking (dog, owner's name, service, slot, status)",
-        rules: "one booking per slot; a cancelled booking frees its slot",
-    },
-    open: {
-        records: "board (name); post (lost or found, item, where seen, note, found)",
-        rules: "each poster edits only their own posts; a found tag turns the post green",
-    },
-    toy: {
-        records: "score (player, best rally)",
-        rules: "only each player's best rally is kept",
-    },
-};
-function exemplarClassificationLine(a) {
-    const c = MERCURY_EXEMPLAR_CLASSIFICATION[a];
-    return `archetype: ${a}; core action: ${c.coreAction}; records: ${c.records.join(", ")}; capabilities: none`;
-}
-function exemplarBlock(e, address, classify = false, recordsRules = false) {
-    const rr = MERCURY_EXEMPLAR_RECORDS[e.archetype];
-    return [
-        `## Example [${e.archetype}]`,
-        "",
-        ...(classify ? [`- ${exemplarClassificationLine(e.archetype)}`] : []),
-        `- opening: ${e.opening}`,
-        `- access: ${e.access}`,
-        ...(recordsRules ? [`- records: ${rr.records}`, `- rules: ${rr.rules}`] : []),
-        `- ${e.demo}`,
-        `- look: ${e.look}`,
-        ...address.example(e.title, e.slugs).map((line) => `- ${line}`),
-        `- icon: ${e.icon}`,
-    ].join("\n");
-}
-export function mercuryExemplarField(archetype, address = MERCURY_ADDRESS, recordsRules = false) {
-    const byArchetype = new Map(MERCURY_EXEMPLARS.map((e) => [e.archetype, e]));
-    const blocks = mercuryFieldArchetypes(archetype).flatMap((a) => {
-        const e = byArchetype.get(a);
-        return e === undefined ? [] : [exemplarBlock(e, address, false, recordsRules)];
-    });
-    return [
-        `## How to read this field
-
-Each example below is one whole brief, tagged with the ownership archetype it fits:
-
-- [personal]  one person's own tool: private, records keyed to their own object so a friend could be let in later.
-- [group]     a named set of people (friends, family, team, club, housemates): the owner invites them by handle, members read and write; the invite screen is part of this first build.
-- [publish]   the owner writes, everyone reads: a blog, menu, gallery, zine, schedule.
-- [intake]    strangers submit without signing in (orders, bookings, requests, RSVPs); the owner sees and manages what came in.
-- [open]      anyone with the link joins and writes their own bit: a shared wall, a canvas, a leaderboard game. Each person edits what they made.
-- [toy]       a game or visual that keeps little or nothing: scores or a save slot at most.
-
-Derive the person's app the way the example with their archetype derives its own, and write each part without its tag. The examples' subjects, record names and cast belong to the examples alone; every noun comes from the person's words.`,
-        ...blocks,
-    ].join("\n\n");
-}
-export const MERCURY_ONECALL_TRIPLES = [
-    ["personal", "group", "publish"],
-    ["intake", "open", "toy"],
-    ["group", "intake", "toy"],
-    ["personal", "publish", "open"],
-];
-const MERCURY_FIELD_TAGS = `- [personal]  one person's own tool: private, records keyed to their own object so a friend could be let in later.
-- [group]     a named set of people (friends, family, team, club, housemates): the owner invites them by handle, members read and write; the invite screen is part of this first build.
-- [publish]   the owner writes, everyone reads: a blog, menu, gallery, zine, schedule.
-- [intake]    strangers submit without signing in (orders, bookings, requests, RSVPs); the owner sees and manages what came in.
-- [open]      anyone with the link joins and writes their own bit: a shared wall, a canvas, a leaderboard game. Each person edits what they made.
-- [toy]       a game or visual that keeps little or nothing: scores or a save slot at most.`;
-export function mercuryOneCallField(draft, address = MERCURY_ADDRESS, recordsRules = false) {
-    const byArchetype = new Map(MERCURY_EXEMPLARS.map((e) => [e.archetype, e]));
-    const triple = MERCURY_ONECALL_TRIPLES[Math.abs(draft) % MERCURY_ONECALL_TRIPLES.length];
-    const blocks = triple.flatMap((a) => {
-        const e = byArchetype.get(a);
-        return e === undefined ? [] : [exemplarBlock(e, address, true, recordsRules)];
-    });
-    return [
-        `## How to read this field
-
-Each example below is one whole brief, tagged with the ownership archetype it fits; three of the six archetypes are shown:
-
-${MERCURY_FIELD_TAGS}
-
-First decide which archetype fits the person's words, then derive their app the way the example with that archetype derives its own, or, when no example has it, the way the examples derive theirs, and write each part without its tag. The examples' subjects, record names and cast belong to the examples alone; every noun comes from the person's words.`,
-        ...blocks,
-    ].join("\n\n");
-}
-export const MERCURY_BRIEF_FLOORS = `Floors for every brief: each screen names at least two visible controls and one state that changes (a colour, a ribbon, a sort order, a chip, a badge); the demo names a lively cast and where each one stands (who is winning, what is overdue, what just landed, who has nothing yet); the opening names the one moment that makes the app fun to open. All of it in the person's own nouns and in words rather than numbers, and nothing their words did not imply.`;
-export const MERCURY_DEMO_RULE = `The demo part starts with "demo:" and names a lively cast and where each one stands, in words: who is ahead, what is overdue, what just happened, what is still waiting; dates and counts are the builder's to pick, so the demo uses words like recently, just now, last week, nearly, still. Every demo record is one the app's own Add could write.`;
-export const MERCURY_OWN_WORLD_DEMO_RULE = `The demo part starts with "demo:" and names a lively cast and where each one stands, in words, named in the app's own world: the states and progress this app's own records hold; dates and counts are the builder's to pick, so the demo uses words like recently, just now, last week, nearly, still. Every demo record is one the app's own Add could write.`;
-export const MERCURY_OWN_WORLD_BRIEF_FLOORS = `Floors for every brief: each screen names at least two visible controls and one state that changes (a colour, a ribbon, a sort order, a chip, a badge); the demo names a lively cast and where each one stands, in the app's own world and in states its own records hold; the opening names the one moment that makes the app fun to open. All of it in the person's own nouns and in words rather than numbers, and nothing their words did not imply.`;
-export const MERCURY_DEPTH_RULE = `Each screen also names one deeper interaction behind its main control, whichever this app's core action calls for: an undo, a long-press, a drag to reorder, an inline edit, or a filter chip.`;
-export const MERCURY_DEPTH_SCREENS_HINT = `1. the core action as the biggest control, two visible controls, one state that changes, one deeper interaction behind the main control (an undo, a long-press, a drag to reorder, an inline edit or a filter chip), why it exists; 2. ...; 3. ...`;
-export const MERCURY_RECORDS_RULE = `The records part names each record type the app stores, with its fields, as "volunteer (name, shift, note)". The rules part names the one to three computations or invariants the ask hinges on, in the person's terms — for example "close each tab as the fewest who-pays-whom transfers and save each payment", "a second sign-up under the same name updates that volunteer", "the band has a fixed lineup of five players and every player appears on each setlist", "every Friday email the summary to the coach's address". The screens build on the records and the rules.`;
-export const MERCURY_RECORDS_SCREENS_RULE = `The screens part names two or three screens; each one says what it shows from the records and what the person does there for this ask, and the screen that carries out a rule says so. At most one screen adds a deeper interaction, and only where the ask implies one.`;
-export const MERCURY_RECORDS_DEMO_RULE = `The demo part starts with "demo:" and is lively, in the app's own world: a small cast with names and the records the screens would show, in the states this app's own records hold. When the person typed data — items, amounts, names, a list — the demo carries every piece of it verbatim, quantities included ("half a bag" stays "half a bag"); dates and counts they did not give are the builder's to pick. Every demo record is one the app's own Add could write.`;
-export const MERCURY_ASK_WORDS_RULE = `Keep the ask's genre and capability words exactly as the person wrote them — 3D, first-person, email, a named recipient, a schedule, a fixed number of people — in the opening, the rules or the screens.`;
-export const MERCURY_RECORDS_BRIEF_FLOORS = `Floors for every brief: every record names its fields; the rules carry the computation or invariant the ask hinges on; each screen shows and does something this ask needs; the demo is lively and carries the person's own typed data word for word; the opening names the one moment that makes the app fun to open. All of it in the person's own nouns, and nothing their words did not imply.`;
-export const MERCURY_RECORDS_HINT = `each record type the app stores, with its fields: "name (field, field, field); name (field, field)"`;
-export const MERCURY_RULES_HINT = `the one to three computations or invariants the ask hinges on, in the person's terms`;
-export const MERCURY_RECORDS_SCREENS_HINT = `1. the core action's screen: what it shows from the records and what the person does there for this ask, and the rule it carries out; 2. ...; 3. ...`;
-export const MERCURY_RECORDS_SEED_HINT = "demo: a lively cast and the records the screens show, in the app's own world, with every item, amount and name the person typed, verbatim";
-export const MERCURY_CHOPPED_RECORDS_SEED_LINE = `- seed: a small, lively world in the app's own words — a cast with quoted names and the records the screens would show, in the states this app's own records hold; any data the person typed (items, amounts, names, quantities) appears in it verbatim. Every seeded record is one the app's own Add could write.`;
 const MERCURY_FIRST_PERSON_TRIGGER = "  - a first-person walk around a place";
 export const MERCURY_BLOCK_WORLD_TRIGGER = "  - a Minecraft-style block world to build and break blocks in";
-const MERCURY_BLOCK_WORLD_WORDS = /\b(minecraft|voxels?|block[- ]world|blocky|sandbox game)\b|\b(build|place|break|mine)\w*\b[^.]{0,30}\bblocks\b/i;
+const MERCURY_BLOCK_WORLD_WORDS = /\b(minecraft|voxels?|block[- ]world|blocky|sandbox game)\b|\b(?:build|place|break|mine|dig)(?:s|ing)?(?:\s+(?:and|or|&)\s+(?:build|place|break|mine|dig)(?:s|ing)?)?\s+(?:the\s+|some\s+)?blocks\b/i;
 export function mercuryBlockWorldNamed(personWords) {
     return MERCURY_BLOCK_WORLD_WORDS.test(personWords);
 }
-const MERCURY_STORY_FOOD = /soup|sauce|ferment|recipe|potluck|beverage|dinner|grocer|food|menu|cook|kitchen|meal|drink|cafe|restaurant|bake|snack|taco/i;
-export const MERCURY_STORY_EXAMPLE_SOUP = "Mia opens the app to post today's soups by taking a picture of the kitchen recipe via the platform camera widget, right after the morning prep; she also sets the inventory level via an onscreen slider… customers at the queue browse the menu and make selections by clicking the quantity buttons on their phones.";
-export const MERCURY_STORY_EXAMPLE_BIKE = "Dev opens the app to post today's repair queue by taking a picture of each bike's tag via the platform camera widget, right after the shop opens; he also sets each repair's progress via an onscreen slider… riders waiting at the counter browse the queue and pick their pickup time by turning the time picker on their phones.";
-export function mercuryStoryExample(personWords) {
-    return MERCURY_STORY_FOOD.test(personWords) ? MERCURY_STORY_EXAMPLE_BIKE : MERCURY_STORY_EXAMPLE_SOUP;
-}
-export function mercuryStoryRule(example) {
-    return `The story part is a short scene of three to five sentences: one person from the demo cast uses the app through its core loop, and every step names its on-screen action: which control they use, the platform widget when one applies (the camera, a slider, a quantity stepper, a picker), and what changes on screen; then who else sees it and which control they use. The shape, shown for a different app: "${example}" That example's subject, cast, nouns and widgets belong to it alone; use a platform widget only when the person's app needs one. Every step of the story is something the screens offer, and the story stays inside the person's words.`;
-}
-export const MERCURY_STORY_HINT = "three to five sentences: one person from the demo cast using the app through its core loop, every step naming its on-screen action: which control they use, the platform widget if one applies (camera, slider, quantity stepper, picker), and what changes on screen; then who else sees it and which control they use";
-export const MERCURY_WHOLE_PREAMBLE_RULE = `The preamble part is spoken to the person who asked, just before the app is built: plain sentences in their own words, starting with "I'm making" or "I'm building" — what you are making for them, its core action and the big control on its first screen that does it, then what else it does, its features named in their nouns. Make it vivid, like you can already see the app; it promises what the screens and the story carry.`;
-export const MERCURY_WHOLE_PREAMBLE_HINT = `plain sentences to the person, starting with "I'm making" or "I'm building": what it is for them, the core action and its first-screen control, then what else it does`;
-const ACCESS_SENTENCE = "The access part matches the archetype";
-function briefRulesText(demoRule, floors) {
-    return `You write the settled parts of a build brief for a small web app (React, a local-first database, access rules). The brief is read by a builder, who works out the records, screens and mechanics from the person's own words. Write plain, concrete prose in the app's own nouns, as unformatted text in each JSON string.
-
-The decisions already made are given in the user message; follow them (archetype, record names, capabilities). The access part matches the archetype: who owns the object, who else is let in, what visitors see. ${demoRule} Take from the field the SHAPE of a part (its length and how a cast, a look or a title is named); every noun comes from the person's words, and the app stays the one they asked for. ${MERCURY_ADDRESS.rule}
-
-${floors}`;
+const MERCURY_REAL_TIME_GAME_WORDS = /\b(arcade|runner|racer|racing game|shooter|shoot[- ]?'?em[- ]?up|platformer|snake game|asteroids|pinball|slingshot|catapult|flappy|endless run|dodge|joystick|swipe to)\b/i;
+export function mercuryRealTimeGameNamed(personWords) {
+    return MERCURY_REAL_TIME_GAME_WORDS.test(personWords);
 }
-function recordsBriefRulesText() {
-    return `You write the settled parts of a build brief for a small web app (React, a local-first database, access rules). The brief is read by a builder, who builds the records, rules and screens it names, from the person's own words. Write plain, concrete prose in the app's own nouns, as unformatted text in each JSON string.
-
-The decisions already made are given in the user message; follow them (archetype, record names, capabilities). The access part matches the archetype: who owns the object, who else is let in, what visitors see. ${MERCURY_RECORDS_RULE} ${MERCURY_RECORDS_SCREENS_RULE} ${MERCURY_RECORDS_DEMO_RULE} ${MERCURY_ASK_WORDS_RULE} Take from the field the SHAPE of a part (its length and how a cast, a look or a title is named); every noun comes from the person's words, and the app stays the one they asked for. ${MERCURY_ADDRESS.rule}
-
-${MERCURY_RECORDS_BRIEF_FLOORS}`;
-}
-export const MERCURY_BRIEF_RULES = briefRulesText(MERCURY_DEMO_RULE, MERCURY_BRIEF_FLOORS);
-const MERCURY_DECIDED_SENTENCE = "The decisions already made are given in the user message; follow them (archetype, record names, capabilities).";
-export const MERCURY_ONECALL_DECIDED = "The classification keys in your reply (archetype, core action, record names, capabilities) decide the brief; follow them.";
-const MERCURY_SHAPE_ARCHETYPE_TEXT = (MERCURY_SHAPE_SYSTEM.split("archetype, exactly one:\n")[1] ?? "")
-    .split("\n\ncoreAction:")[0]
-    .trim();
-const MERCURY_LEAN_ARCHETYPES = MERCURY_SHAPE_ARCHETYPE_TEXT.replace(/\nTie-breaks:[\s\S]*$/, "");
+const MERCURY_LEAN_ARCHETYPES = `- personal: one person's own tool ("for me", "my", "private", a tracker, a log, a list, a journal) with no other people named.
+- group: the person names other people who use it with them (we, our, friends, family, team, club, kids, housemates, partner, members, a foursome).
+- publish: the person writes and other people only read (a blog, menu, gallery, portfolio, schedule, zine, "everyone can read").
+- intake: strangers or customers submit something without signing up and the person sees the submissions (orders, bookings, requests, sign-ups, replies, reports from the public).
+- open: anyone with the link joins in and adds their own bit (a shared wall, canvas, feed, leaderboard game, community board, swap board, "anyone can post").
+- toy: a game, simulator, visual, sound or generator that keeps little or nothing (scores at most).`;
 const MERCURY_LEAN_CAPABILITIES = MERCURY_CAPABILITY_TRIGGERS.replace(/^A trigger is an example, not a password: [^\n]*?composer is set only together with ai\./, "composer goes with ai.");
-const MERCURY_LEAN_ADDRESS = MERCURY_ADDRESS.rule
-    .replace("as an array of three strings", "comma-separated")
-    .replace(" and they need not repeat the title", "");
-export const MERCURY_ONECALL_CLASSIFY = `Your reply also classifies the person's request, in its own keys, and every part of the brief follows that classification.
-
-archetype, exactly one:
-${MERCURY_SHAPE_ARCHETYPE_TEXT}
-
-coreAction: the one thing the person does most in this app, as a short verb phrase in their own words ("tap once per glass", "paste the group chat", "lasso cows"). It becomes the biggest control on the first screen.
-recordNames: 1-5 short singular record type names the app stores (toys may have just "score" or none).
-capabilities: an array naming each capability the request itself needs, from this list; empty when it needs none:
-${MERCURY_CAPABILITY_TRIGGERS}
-
-The brief follows the classification: the access part matches the archetype; the demo names the records; with no ai capability the app works from its own records and no part mentions AI or callAI; with composer, the records come in through a sentence composer (Add and Ask), named as the front door with its mechanics left to the builder; a toy with record names saves best scores or a save slot per signed-in player and nothing else, and a toy with none keeps its state in memory and its access part says it opens with no sign-in and no records.`;
-export function mercuryBriefRules(o = {}) {
-    const own = o.juice === "own-world";
-    const floors = own ? MERCURY_OWN_WORLD_BRIEF_FLOORS : MERCURY_BRIEF_FLOORS;
-    const rules = o.recordsRules === true
-        ? recordsBriefRulesText()
-        : briefRulesText(own ? MERCURY_OWN_WORLD_DEMO_RULE : MERCURY_DEMO_RULE, o.depth === "sub-feature" ? `${floors} ${MERCURY_DEPTH_RULE}` : floors);
-    if (o.reply !== "whole")
-        return rules;
-    const story = mercuryStoryRule(mercuryStoryExample(o.personWords ?? ""));
-    return rules.replace(ACCESS_SENTENCE, `${story} ${MERCURY_WHOLE_PREAMBLE_RULE} ${ACCESS_SENTENCE}`);
-}
-function withScreensKey(obj, value) {
-    const keys = Object.keys(obj);
-    const after = keys.includes("access") ? keys.indexOf("access") + 1 : keys.includes("opening") ? keys.indexOf("opening") + 1 : 0;
-    const out = {};
-    keys.slice(0, after).forEach((k) => (out[k] = obj[k]));
-    out.screens = value;
-    keys.slice(after).forEach((k) => (out[k] = obj[k]));
-    return out;
-}
-function withRecordsKeys(obj, records, rules) {
-    const keys = Object.keys(obj);
-    const before = keys.indexOf("screens");
-    const at = before >= 0
-        ? before
-        : keys.includes("access")
-            ? keys.indexOf("access") + 1
-            : keys.includes("opening")
-                ? keys.indexOf("opening") + 1
-                : 0;
-    const out = {};
-    keys.slice(0, at).forEach((k) => (out[k] = obj[k]));
-    out.records = records;
-    out.rules = rules;
-    keys.slice(at).forEach((k) => (out[k] = obj[k]));
-    return out;
-}
-function withWholeKeys(obj, extra) {
-    const settings = ["look", ...Object.keys(MERCURY_ADDRESS.properties), "icon"];
-    const keys = Object.keys(obj);
-    const found = keys.findIndex((k) => settings.includes(k));
-    const at = found < 0 ? keys.length : found;
-    const out = {};
-    keys.slice(0, at).forEach((k) => (out[k] = obj[k]));
-    Object.entries(extra).forEach(([k, v]) => (out[k] = v));
-    keys.slice(at).forEach((k) => (out[k] = obj[k]));
-    return out;
-}
-export const MERCURY_CHOPPED_BRIEF_RULES = `These parts are turned up, in the person's own nouns, at the field's own lengths:
-- opening: reads like you can already see the app — what it is, who it is for, and the one moment that makes it fun to open.
-- seed: a small world in words — a lively cast with quoted names and where each one stands (one leading, one close behind, one just joined), what happened just now and last week, and a couple of records in the interesting states the screens would show (one overdue, one sold out, one on a streak). Every seeded record is one the app's own Add could write.
-- look: a scene — a surface, a palette, a card shape and one gesture of mood — in under twenty words.
-The access part, the title and the slugs stay as plain and exact as the field shows them. A vivid phrase belongs to this app or it stays out; every part describes the app the person asked for, and each part grows by a few words, never by a feature their words did not imply.`;
-export const MERCURY_CHOPPED_SEED_LINE = `- seed: a small world in words — a lively cast with quoted names and where each one stands (one leading, one close behind, one just joined), what happened just now and last week, and a couple of records in the interesting states the screens would show (one overdue, one sold out, one on a streak). Every seeded record is one the app's own Add could write.`;
-export const MERCURY_CHOPPED_OWN_WORLD_SEED_LINE = `- seed: a small world in words — a lively cast with quoted names and where each one stands in the app's own world, what happened just now and last week, and a couple of records in the interesting states this app's own records hold. Every seeded record is one the app's own Add could write.`;
-export const MERCURY_CHOPPED_OWN_WORLD_BRIEF_RULES = MERCURY_CHOPPED_BRIEF_RULES.replace(MERCURY_CHOPPED_SEED_LINE, MERCURY_CHOPPED_OWN_WORLD_SEED_LINE);
-export const MERCURY_CHOPPED_RECORDS_BRIEF_RULES = MERCURY_CHOPPED_BRIEF_RULES.replace(MERCURY_CHOPPED_SEED_LINE, MERCURY_CHOPPED_RECORDS_SEED_LINE);
-export const MERCURY_ONECALL_CLASSIFY_RECORDS = MERCURY_ONECALL_CLASSIFY.replace(MERCURY_FIRST_PERSON_TRIGGER, `${MERCURY_FIRST_PERSON_TRIGGER}\n${MERCURY_BLOCK_WORLD_TRIGGER}`);
-export const MERCURY_CHOPPED_PREAMBLE = `Make it vivid, like you can already see the app: name the first screen's hero control and the one moment that makes it fun to open, in their nouns. The promise stays the brief's: the core action and that control.`;
-const FIELD_BOUNDS = {
-    opening: [15, 200],
-    access: [60, 600],
-    seed: [60, 650],
-    look: [15, 150],
-    icon: [8, 100],
-};
-const MERCURY_CLASSIFY_PROPERTIES = {
-    archetype: { type: "string", enum: [...MERCURY_ARCHETYPES] },
-    coreAction: { type: "string" },
-    recordNames: { type: "array", items: { type: "string" } },
-    capabilities: { type: "array", items: { type: "string", enum: [...MERCURY_FLAGS] } },
-};
-export function mercuryBriefKeys(fields) {
-    return fields.flatMap((f) => (f === "pairs" ? Object.keys(MERCURY_ADDRESS.properties) : [replyKey(f)]));
-}
-export function mercuryBriefSchema(fields, opts = {}) {
-    const rooms = opts.rooms === true;
-    const font = opts.font === true;
-    const fieldProps = Object.fromEntries(fields.flatMap((f) => (f === "pairs" ? Object.entries(MERCURY_ADDRESS.properties) : [[replyKey(f), { type: "string" }]])));
-    const screened = opts.screens === true ? withScreensKey(fieldProps, { type: "string" }) : fieldProps;
-    const outline = opts.recordsRules === true ? withRecordsKeys(screened, { type: "string" }, { type: "string" }) : screened;
-    const props = opts.story === true || opts.preamble === true
-        ? withWholeKeys(outline, {
-            ...(opts.story === true ? { story: { type: "string" } } : {}),
-            ...(opts.preamble === true ? { preamble: { type: "string" } } : {}),
-        })
-        : outline;
-    const lead = withClassifyFirst(props, opts.classify === true, (k) => MERCURY_CLASSIFY_PROPERTIES[k]);
-    return {
-        type: "object",
-        additionalProperties: false,
-        required: [...Object.keys(lead), ...(rooms ? ["rooms"] : []), ...(font ? ["font"] : [])],
-        properties: {
-            ...lead,
-            ...(rooms ? { rooms: { type: "array", items: { type: "string" } } } : {}),
-            ...(font ? { font: { type: "string" } } : {}),
-        },
-    };
-}
-function capabilityDecisions(shape) {
-    return [
-        `AI text features: ${shape.flags.ai ? "yes (callAI)" : "none; the app works from its own records"}`,
-        `generated pictures: ${shape.flags.imageGen ? "yes (ImgGen)" : "none"}`,
-        ...(shape.flags.composer
-            ? [
-                "the records come in through a sentence composer (Add and Ask); name it as the front door and leave its mechanics to the builder",
-            ]
-            : []),
-    ];
-}
-export function mercuryBriefMessages(o) {
-    return briefMessages(o, { shape: o.shape });
-}
-export function mercuryOneCallBriefMessages(o) {
-    return briefMessages(o, { draft: o.draft });
-}
-function briefMessages(o, by) {
-    const s = "shape" in by ? by.shape : undefined;
-    const classify = s === undefined;
-    const rooms = o.rooms === true;
-    const font = o.font === true;
-    const screens = o.screens ?? o.depth === "sub-feature";
-    const story = o.story ?? o.reply === "whole";
-    const preamble = o.preamble ?? o.reply === "whole";
-    const recordsRules = o.recordsRules === true;
-    const recordsOwed = recordsRules && (o.recordsOwed ?? true);
-    const keys = mercuryBriefKeys(o.fields);
-    const keyed = Object.fromEntries(keys.map((k) => [k, k]));
-    const screenedKeys = screens ? withScreensKey(keyed, "screens") : keyed;
-    const outlineKeys = recordsOwed ? withRecordsKeys(screenedKeys, "records", "rules") : screenedKeys;
-    const askedKeys = Object.keys(withClassifyFirst(story || preamble
-        ? withWholeKeys(outlineKeys, { ...(story ? { story: "story" } : {}), ...(preamble ? { preamble: "preamble" } : {}) })
-        : outlineKeys, classify, (k) => k));
-    const skeleton = [
-        "Answer in exactly this shape, each value replaced by the real text:",
-        mercuryAnswerSkeleton(o.fields, {
-            rooms,
-            font,
-            ...(screens ? { screens } : {}),
-            ...(o.juice === undefined ? {} : { juice: o.juice }),
-            ...(story ? { story } : {}),
-            ...(preamble ? { preamble } : {}),
-            ...(classify ? { classify } : {}),
-            ...(recordsOwed ? { recordsRules: true } : {}),
-        }),
-        ...(rooms ? ["", `Rooms: ${poufRoomCatalog()}`] : []),
-        ...(font ? ["", `Fonts: ${vibeFontCatalog()}`] : []),
-        "",
-        `Person's words: "${o.personWords}"`,
-        "",
-    ];
-    const also = (rooms ? ` ${MERCURY_ROOMS_ASK}` : "") + (font ? ` ${MERCURY_FONT_ASK}` : "");
-    const slugWords = o.fields.includes("pairs") && o.words.length > 0 ? [mercurySlugWordsSentence(o.words)] : [];
-    const chopped = recordsRules
-        ? MERCURY_CHOPPED_RECORDS_BRIEF_RULES
-        : o.juice === "own-world"
-            ? MERCURY_CHOPPED_OWN_WORLD_BRIEF_RULES
-            : MERCURY_CHOPPED_BRIEF_RULES;
-    if (s === undefined) {
-        const notes = [
-            ...(o.fields.includes("pairs") ? [MERCURY_ADDRESS.ask] : []),
-            `archetype: one of ${MERCURY_ARCHETYPES.join(", ")}`,
-            "recordNames: an array of record names",
-            "capabilities: an array from the capability list, empty when none",
-        ];
-        const user = [
-            ...skeleton,
-            `Classify the person's words, then derive this app the way the example with that archetype derives its own. Return JSON with these keys: ${askedKeys.join(", ")} (${notes.join("; ")}).${also}`,
-            ...slugWords,
-        ].join("\n");
-        const rules = mercuryBriefRules(o).replace(MERCURY_DECIDED_SENTENCE, MERCURY_ONECALL_DECIDED);
-        const field = mercuryOneCallField("draft" in by ? by.draft : 0, MERCURY_ADDRESS, recordsRules);
-        const classifyBlock = recordsRules ? MERCURY_ONECALL_CLASSIFY_RECORDS : MERCURY_ONECALL_CLASSIFY;
-        return [
-            {
-                role: "system",
-                content: [
-                    {
-                        type: "text",
-                        text: o.style === "chopped"
-                            ? `${rules}\n\n${classifyBlock}\n\n${chopped}\n\n${field}`
-                            : `${rules}\n\n${classifyBlock}\n\n${field}`,
-                    },
-                ],
-            },
-            { role: "user", content: [{ type: "text", text: user }] },
-        ];
-    }
-    const decisions = [
-        `archetype: ${s.archetype}`,
-        `core action: ${s.coreAction}`,
-        `kind: ${s.kind}`,
-        `for: ${s.who}`,
-        `records: ${s.recordNames.length === 0 ? "(you choose, at most three)" : s.recordNames.join(", ")}`,
-        ...capabilityDecisions(s),
-        ...(s.archetype === "toy"
-            ? [
-                `saved: ${s.recordNames.length > 0 ? "best scores or a save slot per signed-in player, and nothing else" : "the toy keeps its state in memory; the access part says it opens with no sign-in and no records"}`,
-            ]
-            : []),
-    ];
-    const user = [
-        ...skeleton,
-        "Decisions:",
-        ...decisions.map((d) => `- ${d}`),
-        "",
-        `Derive this app the way the example tagged [${s.archetype}] derives its own, from the person's words. Return JSON with these keys: ${askedKeys.join(", ")}` +
-            (o.fields.includes("pairs") ? ` (${MERCURY_ADDRESS.ask})` : "") +
-            "." +
-            also,
-        ...slugWords,
-    ].join("\n");
-    return [
-        {
-            role: "system",
-            content: [
-                {
-                    type: "text",
-                    text: o.style === "chopped"
-                        ? `${mercuryBriefRules(o)}\n\n${chopped}\n\n${mercuryExemplarField(s.archetype, MERCURY_ADDRESS, recordsRules)}`
-                        : `${mercuryBriefRules(o)}\n\n${mercuryExemplarField(s.archetype, MERCURY_ADDRESS, recordsRules)}`,
-                },
-            ],
-        },
-        { role: "user", content: [{ type: "text", text: user }] },
-    ];
-}
-const FIELD_LABEL = /^\s*(?:\*\*)?(opening|access|seed|look|icon|preamble)(?:\*\*)?\s*:\s*/i;
-const FENCED = /^```[a-zA-Z]*\n([\s\S]*?)\n?```$/;
-export function cleanMercuryText(text) {
-    const t = text.trim();
-    const fenced = FENCED.exec(t);
-    return (fenced === null ? t : fenced[1].trim()).replace(FIELD_LABEL, "").trim();
-}
-function stem(name) {
-    return name
-        .replace(/([a-z])([A-Z])/g, "$1 $2")
-        .toLowerCase()
-        .split(/[\s_-]+/)
-        .filter((w) => w.length > 2)
-        .map((w) => w.replace(/s$/, ""));
-}
-function mentions(name, text) {
-    const lower = text.toLowerCase();
-    return stem(name).every((w) => lower.includes(w));
-}
-const TAG_LEAK = /\[(personal|group|publish|intake|open|toy)\]|archetype/i;
-const MARKUP = /```|^\s*#/m;
-const AI_LEAK = /\bcallai\b|\bAI\b|language model/;
 function kebab(s) {
     return s
         .toLowerCase()
@@ -816,31 +166,9 @@ function kebab(s) {
         .replace(/^-+|-+$/g, "");
 }
 const LEADING_TAG = /^\s*\[(?:personal|group|publish|intake|open|toy)\]\s*/i;
-const DEMO_PREFIX = /^demo\s*:\s*/i;
 export function stripMercuryArchetypeTag(text) {
     return LEADING_TAG.test(text) ? { text: text.replace(LEADING_TAG, ""), repaired: true } : { text, repaired: false };
 }
-export function repairMercuryField(field, value) {
-    const repaired = new Set();
-    const lead = stripMercuryArchetypeTag(cleanMercuryText(value));
-    if (lead.repaired)
-        repaired.add("archetype-tag");
-    let t = lead.text.trim();
-    if (field === "seed" && t.length > 0) {
-        const prefix = DEMO_PREFIX.exec(t);
-        const rest = stripMercuryArchetypeTag(prefix === null ? t : t.slice(prefix[0].length));
-        if (rest.repaired)
-            repaired.add("archetype-tag");
-        if (prefix === null)
-            repaired.add("demo-prefix");
-        t = `demo: ${rest.text.trim()}`;
-    }
-    return { value: t, repaired: [...repaired] };
-}
-export function prepareMercuryField(field, value) {
-    const r = repairMercuryField(field, value);
-    return { gate: r.value, value: cleanMercuryText(value), misses: r.repaired };
-}
 export function gateMercuryAddress(o) {
     const raw = o.title.trim();
     const cut = stripMercuryArchetypeTag(raw);
@@ -866,71 +194,6 @@ export function mercurySlugsWithWord(pairs, words) {
     const ws = words.map((w) => kebab(w)).filter((w) => w.length > 0);
     return pairs.filter((p) => ws.some((w) => p.slug.includes(w))).length;
 }
-export function gateMercuryField(o) {
-    const t = cleanMercuryText(o.value);
-    const a = o.shape.archetype;
-    if (o.field === "seed" && a === "toy" && o.shape.recordNames.length === 0)
-        return [];
-    const [lo, hi] = FIELD_BOUNDS[o.field];
-    const fails = [];
-    if (t.length === 0)
-        fails.push("empty");
-    else if (t.length < lo)
-        fails.push("short");
-    else if (t.length > hi)
-        fails.push("long");
-    if (MARKUP.test(t))
-        fails.push("markup");
-    if (TAG_LEAK.test(t))
-        fails.push("tag-leak");
-    if (o.field !== "look" && o.field !== "icon" && o.shape.flags.ai === false && AI_LEAK.test(t))
-        fails.push("ai-leak");
-    if (o.field === "seed" && DEMO_PREFIX.test(t) === false)
-        fails.push("demo-prefix");
-    if (o.field === "seed" && o.shape.recordNames.length > 0 && o.shape.recordNames.some((r) => mentions(r, t)) === false)
-        fails.push("seed-no-record");
-    if (o.field === "access") {
-        if (a === "group" && /invite|member/i.test(t) === false)
-            fails.push("access-no-invite");
-        if (a === "personal" && /invite screen (is|ships)|members (read|can)/i.test(t))
-            fails.push("access-personal-invites");
-        if (a === "toy" && o.shape.recordNames.length > 0 && /nothing is saved|no records/i.test(t))
-            fails.push("toy-contradiction");
-        if ((a === "publish" || a === "intake") && /read|see|visitor|customer|client|anyone|everyone|public/i.test(t) === false)
-            fails.push("access-no-readers");
-    }
-    return fails;
-}
-export const MERCURY_ACCESS_TAIL = {
-    personal: "Rules key on the object's creator; records carry the object id so someone could be let in later. The invite screen waits for a later build.",
-    group: "Memberships are written by the platform's HandleInput invite screen, which is part of this first build; shared objects show who made them with ViewerTag.",
-    publish: "The owner writes; everything they publish is readable by anyone with the link, signed in or not. Shaped so a co-owner could be let in later.",
-    intake: "Every visitor writes their own submissions into the shared list, signed in or not, and edits only their own; the signed-in owner reads and manages all of them. Shaped so staff could be let in later.",
-    open: "Everyone with the link writes the shared records — posts, votes, entries — and edits only their own; the owner can remove anything.",
-    toy: "",
-};
-const TAIL_ALREADY_SAID = {
-    personal: /invite screen waits|later build|no invite screen/i,
-    group: /HandleInput/,
-    publish: /readable by anyone|anyone with the link/i,
-};
-export function mercuryAccessLine(shape, access) {
-    const said = TAIL_ALREADY_SAID[shape.archetype];
-    const tail = said !== undefined && said.test(access) ? "" : MERCURY_ACCESS_TAIL[shape.archetype];
-    return `${access} ${tail}`.trim();
-}
-const CAPABILITY_NAMES = [
-    ["ai", "AI text (callAI)"],
-    ["composer", "a sentence composer (Add and Ask) as the front door"],
-    ["imageGen", "generated pictures (ImgGen)"],
-    ["backend", "server work (backend.js)"],
-    ["calendar", "calendar dates"],
-    ["audio", "sound"],
-    ["threeD", "3D graphics"],
-    ["charts", "charts"],
-    ["boardGame", "a turn-based board or card game"],
-    ["sensitive", "private records"],
-];
 const FLAG_SKILLS = [
     ["ai", "callai"],
     ["imageGen", "image-gen"],
@@ -942,59 +205,11 @@ const FLAG_SKILLS = [
     ["boardGame", "board-games"],
 ];
 export function mercurySkills(shape, opts = {}) {
-    const skills = ["access", "fireproof", ...FLAG_SKILLS.filter(([f]) => shape.flags[f]).map(([, skill]) => skill)];
-    if (opts.recordsRules !== true || !mercuryBlockWorldNamed(opts.personWords ?? ""))
-        return skills;
-    return [...skills.filter((k) => k !== "three-js"), "voxel", "three-js"];
-}
-const POSTURE_PUBLIC = /\b(anyone with the link|everyone with the link|signed in or not|any visitor|readable by anyone|public(ly)?)\b/i;
-const POSTURE_ALONE = /\b(alone|no one else|nobody else|only (the owner|the creator|you|me) (can )?(read|see)s?)\b/i;
-const POSTURE_MEMBERS = /\b(members?|invit\w*|let in|HandleInput|friends?|households?|travel+ers?|guests?|players?|teammates?)\b/i;
-const POSTURE_WRITE_VERB = /\b(edit|edits|write|writes|add|adds|change|changes|update|updates|post|posts|submit|submits|book|books|log|logs|place|places|remove|removes)\b/i;
-const POSTURE_OTHERS = /\b(members?|everyone|anyone|friends?|guests?|visitors?|others|travel+ers?|households?|players?|teammates?|each (poster|player|member|guest|visitor))\b/i;
-const POSTURE_OWNER_ONLY = /\b(alone|only the (owner|creator)|the (owner|creator) (alone )?(writes|edits))\b/i;
-const POSTURE_OTHERS_READ = /\b(members?|everyone|anyone|friends?|guests?|visitors?|they|others)\b[^.;]*\b(read|reads|see|sees|view|views)\b/i;
-export function mercuryAccessPosture(access) {
-    const read = POSTURE_PUBLIC.test(access)
-        ? "public"
-        : POSTURE_ALONE.test(access)
-            ? "private"
-            : POSTURE_MEMBERS.test(access)
-                ? "members"
-                : undefined;
-    let othersWrite = false;
-    let ownerWrites = false;
-    for (const sentence of access.split(/(?<=[.;])\s+/)) {
-        if (!POSTURE_WRITE_VERB.test(sentence))
-            continue;
-        if (POSTURE_OWNER_ONLY.test(sentence) && !POSTURE_OTHERS.test(sentence))
-            ownerWrites = true;
-        else if (POSTURE_OTHERS.test(sentence))
-            othersWrite = true;
-        else if (/\b(owner|creator)\b/i.test(sentence))
-            ownerWrites = true;
-    }
-    const write = othersWrite
-        ? "members"
-        : ownerWrites || POSTURE_OTHERS_READ.test(access)
-            ? "owner"
-            : undefined;
-    return { ...(read === undefined ? {} : { read }), ...(write === undefined ? {} : { write }) };
-}
-export function mercuryDuoConflict(a, b, personWords) {
-    if (a.shape.archetype !== b.shape.archetype)
-        return `archetype: ${a.shape.archetype} vs ${b.shape.archetype}`;
-    const na = mercuryNature(a.shape, personWords);
-    const nb = mercuryNature(b.shape, personWords);
-    if (na !== nb)
-        return `nature: ${na} vs ${nb}`;
-    const pa = mercuryAccessPosture(a.access);
-    const pb = mercuryAccessPosture(b.access);
-    if (pa.read !== undefined && pb.read !== undefined && pa.read !== pb.read)
-        return `access-read: ${pa.read} vs ${pb.read}`;
-    if (pa.write !== undefined && pb.write !== undefined && pa.write !== pb.write)
-        return `access-write: ${pa.write} vs ${pb.write}`;
-    return undefined;
+    const words = opts.personWords ?? "";
+    const base = ["access", "fireproof", ...FLAG_SKILLS.filter(([f]) => shape.flags[f]).map(([, skill]) => skill)];
+    const skills = mercuryBlockWorldNamed(words) ? [...base.filter((k) => k !== "three-js"), "voxel", "three-js"] : base;
+    const realTime = mercuryBlockWorldNamed(words) || mercuryRealTimeGameNamed(words) || (shape.archetype === "toy" && shape.flags.threeD);
+    return realTime ? [...skills, "touch-games"] : skills;
 }
 export function mercuryNature(shape, personWords) {
     if (shape.keepsToThemselves === true)
@@ -1006,15 +221,6 @@ export function mercuryNature(shape, personWords) {
         return "open";
     return shape.flags.sensitive && (a === "personal" || a === "intake") ? "sensitive" : "collaborative";
 }
-export function mercuryWorkflowLine(shape) {
-    const caps = CAPABILITY_NAMES.filter(([f]) => shape.flags[f]).map(([, name]) => name);
-    return [
-        `Archetype: ${shape.archetype}.`,
-        `Core action: "${shape.coreAction}".`,
-        ...(shape.recordNames.length === 0 ? [] : [`Records: ${shape.recordNames.join(", ")}.`]),
-        ...(caps.length === 0 ? [] : [`Capabilities: ${caps.join(", ")}.`]),
-    ].join(" ");
-}
 const MERCURY_ROOMS_MAX = 3;
 export function gateMercuryRooms(raw) {
     if (!Array.isArray(raw))
@@ -1034,169 +240,6 @@ export function gateMercuryFont(raw) {
         return { dropped: 0 };
     return typeof raw === "string" && vibeFontSlugs().includes(raw) ? { font: raw, dropped: 0 } : { dropped: 1 };
 }
-export function gateMercuryScreens(raw) {
-    if (raw === undefined)
-        return { dropped: 0 };
-    return typeof raw === "string" && cleanMercuryText(raw).length > 0 ? { screens: raw, dropped: 0 } : { dropped: 1 };
-}
-function mercuryScreensLine(screens) {
-    const t = cleanMercuryText(screens ?? "");
-    if (t.length === 0)
-        return "";
-    return /^screen/i.test(t) ? t : `Screens: ${t}`;
-}
-function mercuryPartLine(label, text) {
-    const t = cleanMercuryText(text ?? "").replace(/^(records?|rules?)\s*:\s*/i, "");
-    return t.length === 0 ? "" : `${label}: ${t}`;
-}
-const WHOLE_MARKUP = /```|^\s*#/m;
-export function gateMercuryStory(raw) {
-    if (raw === undefined)
-        return { dropped: 0 };
-    if (typeof raw !== "string")
-        return { dropped: 1 };
-    const t = cleanMercuryText(raw);
-    if (t.length === 0)
-        return { dropped: 1 };
-    return WHOLE_MARKUP.test(t) ? { story: raw, dropped: 0, misses: ["markup"] } : { story: raw, dropped: 0 };
-}
-export function gateMercuryWholePreamble(text) {
-    const t = cleanMercuryText(text);
-    const fails = [];
-    if (t.length === 0)
-        fails.push("empty");
-    if (/```|^\s*#|\bbrief\b|\bdemo\s*:/im.test(t))
-        fails.push("markup");
-    return fails;
-}
-function mercuryEnrichedPrompt(o) {
-    if (o.reply === "whole")
-        return mercuryWholeEnrichedPrompt(o);
-    const s = o.shape;
-    const keepsNothing = s.archetype === "toy" && s.recordNames.length === 0;
-    const access = cleanMercuryText(o.fields.access);
-    const seed = keepsNothing ? "" : cleanMercuryText(o.fields.seed);
-    return [
-        cleanMercuryText(o.fields.opening),
-        keepsNothing && access.length === 0 ? "" : mercuryAccessLine(s, access),
-        s.keepsToThemselves === true ? ONE_TREE_PER_PERSON : "",
-        mercuryWorkflowLine(o.capabilityFlags === undefined ? s : { ...s, flags: o.capabilityFlags }),
-        mercuryScreensLine(o.screens),
-        seed.length === 0 ? "" : `${seed} ${KNOWN_VALUES_DIRECT_CONTROLS}`,
-        `The person asked: "${o.personWords}".`,
-    ]
-        .filter((p) => p.length > 0)
-        .join("\n\n");
-}
-function mercuryWholeEnrichedPrompt(o) {
-    const own = wholeSection(o.shape, {
-        opening: o.fields.opening,
-        access: o.fields.access,
-        seed: o.fields.seed,
-        look: o.fields.look,
-        ...(o.records === undefined ? {} : { records: o.records }),
-        ...(o.rules === undefined ? {} : { rules: o.rules }),
-        ...(o.screens === undefined ? {} : { screens: o.screens }),
-        ...(o.story === undefined ? {} : { story: o.story }),
-        ...(o.preamble === undefined ? {} : { preamble: o.preamble }),
-    });
-    const partner = o.partner === undefined ? undefined : o.recordsRules === true ? { ...o.partner, seed: "", story: undefined } : o.partner;
-    const takes = partner === undefined ? own : [...own, "---", ...wholeSection(o.shape, partner)];
-    return [...takes, `The person asked: "${o.personWords}".`].join("\n\n");
-}
-function wholeSection(s, t) {
-    const keepsNothing = s.archetype === "toy" && s.recordNames.length === 0;
-    const access = cleanMercuryText(t.access);
-    const seed = keepsNothing ? "" : cleanMercuryText(t.seed);
-    return [
-        cleanMercuryText(t.opening),
-        keepsNothing && access.length === 0 ? "" : mercuryAccessLine(s, access),
-        mercuryPartLine("Records", t.records),
-        mercuryPartLine("Rules", t.rules),
-        mercuryScreensLine(t.screens),
-        seed.length === 0 ? "" : `${seed} ${KNOWN_VALUES_DIRECT_CONTROLS}`,
-        cleanMercuryText(t.story ?? ""),
-        cleanMercuryText(t.preamble ?? ""),
-        cleanMercuryText(t.look),
-    ].filter((p) => p.length > 0);
-}
-export function mercuryPreambleBrief(o) {
-    return mercuryEnrichedPrompt(o);
-}
-export function assembleMercuryCreateVibe(o) {
-    const s = o.shape;
-    const look = cleanMercuryText(o.fields.look);
-    const icon = cleanMercuryText(o.fields.icon);
-    const nature = mercuryNature(s, o.personWords);
-    const rooms = sanitizeRoomShortlist("pouf", o.rooms);
-    return {
-        prompt: o.personWords,
-        enrichedPrompt: mercuryEnrichedPrompt(o),
-        skills: mercurySkills(o.capabilityFlags === undefined ? s : { ...s, flags: o.capabilityFlags }, {
-            personWords: o.personWords,
-            ...(o.recordsRules === true ? { recordsRules: true } : {}),
-        }),
-        pairs: o.fields.pairs.map((p) => ({ title: p.title, slug: p.slug })),
-        ...(icon.length === 0 ? {} : { iconDescription: icon }),
-        ...(look.length === 0 ? {} : { textureNote: look }),
-        nature,
-        ...(nature === "sensitive" ? { privacySensitive: true } : {}),
-        ...(rooms === undefined ? {} : { rooms: [...rooms] }),
-        ...(o.font === undefined ? {} : { font: o.font }),
-    };
-}
-export const MERCURY_PREAMBLE_SYSTEM = `You speak to the person who asked for an app, just before it is built. Write two or three plain sentences in their own words: what you are making for them, its core action, and the big control on its first screen that does it. That is the whole promise — the builder works out everything else after you speak. Start with "I'm making" or "I'm building", and write it as plain sentences to the person.`;
-export function mercuryPreambleMessages(o) {
-    const user = [
-        `Person's words: "${o.personWords}"`,
-        `Core action: ${o.shape.coreAction}`,
-        "",
-        "What is being built:",
-        o.enrichedPrompt,
-        "",
-        "Write the preamble.",
-    ].join("\n");
-    return [
-        {
-            role: "system",
-            content: [
-                {
-                    type: "text",
-                    text: o.style === "chopped" ? `${MERCURY_PREAMBLE_SYSTEM} ${MERCURY_CHOPPED_PREAMBLE}` : MERCURY_PREAMBLE_SYSTEM,
-                },
-            ],
-        },
-        { role: "user", content: [{ type: "text", text: user }] },
-    ];
-}
-const preambleParsed = lazyType(() => type({ preamble: "string" }));
-export function mercuryPreambleSchema() {
-    return {
-        type: "object",
-        additionalProperties: false,
-        required: ["preamble"],
-        properties: { preamble: { type: "string" } },
-    };
-}
-export function gateMercuryPreamble(o) {
-    const t = cleanMercuryText(o.text);
-    const fails = [];
-    if (t.length === 0)
-        fails.push("empty");
-    else if (t.length < 60)
-        fails.push("short");
-    else if (t.length > 480)
-        fails.push("long");
-    if (/```|^\s*#|\bbrief\b|\bdemo\s*:/im.test(t))
-        fails.push("markup");
-    if ((t.match(/[.!?](\s|$)/g) ?? []).length > 3)
-        fails.push("too-many-sentences");
-    const briefWords = new Set(o.enrichedPrompt.toLowerCase().match(/[a-z]{5,}/g) ?? []);
-    const shared = new Set((t.toLowerCase().match(/[a-z]{5,}/g) ?? []).filter((w) => briefWords.has(w)));
-    if (shared.size < 3)
-        fails.push("unanchored");
-    return fails;
-}
 const completionBody = lazyType(() => type({
     "model?": "string",
     choices: type({ message: { content: "string | null" }, "finish_reason?": "string | null" }).array(),
@@ -1240,9 +283,6 @@ async function requestMercury(vctx, o, signal) {
         stream: false,
         max_tokens: o.maxTokens,
         ...(model.reasoning === undefined ? {} : { reasoning: { ...model.reasoning } }),
-        ...(o.schema === undefined
-            ? {}
-            : { response_format: { type: "json_schema", json_schema: { name: o.name, strict: true, schema: o.schema } } }),
         messages: o.messages,
     };
     const rRes = await exception2Result(() => vctx.llmRequest({ ...req, headers: vctx.params.llm.headers }, { signal }));
@@ -1267,13 +307,9 @@ async function requestMercury(vctx, o, signal) {
     const ended = `(finish ${finish}, ${body.usage?.completion_tokens ?? "?"} of ${o.maxTokens} tokens)`;
     if (content === undefined || content === null || content.trim().length === 0)
         return Result.Err(`mercury ${o.name}: empty reply ${ended}`);
-    const rJson = o.schema === undefined ? Result.Ok(content) : exception2Result(() => JSON.parse(cleanMercuryText(content)));
-    if (rJson.isErr())
-        return Result.Err(`mercury ${o.name}: JSON ${ended}: ${rJson.Err().message.slice(0, 80)}`);
     const u = body.usage;
     const reasoningTokens = u?.completion_tokens_details?.reasoning_tokens;
     return Result.Ok({
-        json: rJson.Ok(),
         text: content,
         ...(typeof reasoningTokens === "number" ? { reasoningTokens } : {}),
         ...(body.model === undefined ? {} : { servedModel: body.model }),
@@ -1339,8 +375,6 @@ async function mercuryAttempt(vctx, o, log) {
         }
         return { kind: "cancelled", inFlight };
     }
-    const persistent = o.persistent === true;
-    const maxTransientRetries = persistent ? Number.POSITIVE_INFINITY : (o.transientRetries ?? MERCURY_TRANSIENT_RETRIES);
     let transientRetries = 0;
     async function persistentWait(retryAfterMs) {
         const wait = mercuryTesterRetryWaitMs(transientRetries + 1, retryAfterMs);
@@ -1360,7 +394,7 @@ async function mercuryAttempt(vctx, o, log) {
         if (remaining < MERCURY_MIN_ATTEMPT_MS) {
             const spent = `mercury ${o.call}: stage budget spent (${o.budget.elapsedMs()}ms of ${o.budget.totalMs}ms)`;
             log.lastError = log.sends === 0 && log.carried !== true ? spent : `${spent} after ${log.cause}: ${log.lastError}`;
-            log.cause = o.budget.rateLimitCapMs() === undefined ? "budget" : "rate-limited";
+            log.cause = "budget";
             return { kind: "budget" };
         }
         const deadline = Math.min(o.deadlineMs, remaining);
@@ -1370,7 +404,6 @@ async function mercuryAttempt(vctx, o, log) {
         log.inFlight = true;
         const r = await withDeadline((signal) => requestMercury(vctx, {
             name: o.call,
-            ...(ask.schema === undefined ? {} : { schema: ask.schema }),
             messages: ask.messages,
             maxTokens: o.maxTokens,
             ...(o.model === undefined ? {} : { model: o.model }),
@@ -1381,9 +414,9 @@ async function mercuryAttempt(vctx, o, log) {
         if (r.timedOut) {
             const clipped = deadline < o.deadlineMs;
             log.lastError = `mercury ${o.call}: timed out after ${deadline}ms${clipped ? " (stage budget)" : ""}`;
-            log.cause = clipped ? (o.budget.rateLimitCapMs() === undefined ? "budget" : "rate-limited") : "timeout";
+            log.cause = clipped ? "budget" : "timeout";
             noteSend(log, o.label);
-            if (persistent && !clipped && (await persistentWait(undefined)))
+            if (o.persistent && !clipped && (await persistentWait(undefined)))
                 continue;
             return { kind: "failed" };
         }
@@ -1392,33 +425,21 @@ async function mercuryAttempt(vctx, o, log) {
         const err = r.reply.Err();
         log.lastError = err.message;
         if (err instanceof MercuryTransientError === false) {
-            log.cause = persistent ? "network" : "error";
+            log.cause = o.persistent ? "network" : "error";
             noteSend(log, o.label);
-            if (persistent && (await persistentWait(undefined)))
+            if (o.persistent && (await persistentWait(undefined)))
                 continue;
             return { kind: "failed" };
         }
         log.cause = err.status === 429 ? "rate-limited" : "upstream-error";
-        if (err.status === 429 && !persistent)
-            o.budget.noteRateLimited();
         if (err.retryAfterMs !== undefined)
             log.retryAfterMs = Math.max(log.retryAfterMs ?? 0, err.retryAfterMs);
         noteSend(log, o.label);
-        if (persistent) {
-            if (await persistentWait(err.retryAfterMs))
-                continue;
-            return { kind: "stop" };
-        }
-        if (transientRetries >= maxTransientRetries)
+        if (!o.persistent)
             return { kind: "failed" };
-        const wait = mercuryRetryWaitMs(transientRetries + 1, err.retryAfterMs);
-        if (wait === undefined || wait > o.budget.remainingMs() - MERCURY_MIN_ATTEMPT_MS) {
-            log.lastError = `${err.message} (retry-after ${err.retryAfterMs ?? "none"}ms; falling back inside the stage budget)`;
-            return { kind: "stop" };
-        }
-        await waitOrCancel(wait, cancel);
-        transientRetries += 1;
-        log.retries += 1;
+        if (await persistentWait(err.retryAfterMs))
+            continue;
+        return { kind: "stop" };
     }
 }
 function absorbReply(into, reply) {
@@ -1429,34 +450,6 @@ function absorbReply(into, reply) {
     if (reply.reasoningTokens !== undefined)
         into.reasoningTokens = (into.reasoningTokens ?? 0) + reply.reasoningTokens;
 }
-async function mercuryCall(vctx, o) {
-    const startedAt = Date.now();
-    const totals = { usage: [] };
-    const log = mercurySendLog();
-    let attempts = 0;
-    while (attempts < MERCURY_CALL_ATTEMPTS) {
-        const a = await mercuryAttempt(vctx, o, log);
-        if (a.kind === "budget" || a.kind === "stop" || a.kind === "cancelled")
-            break;
-        attempts += 1;
-        if (a.kind === "failed")
-            continue;
-        absorbReply(totals, a.reply);
-        const accepted = o.accept(a.reply.json);
-        if (accepted.isOk()) {
-            o.onCounts?.(log.sends, log.retries);
-            await recordMercuryRow(vctx, {
-                ...o.row,
-                record: callRecord({ call: o.call, ok: true, attempts, startedAt, totals, log, extra: { text: a.reply.text } }),
-            });
-            return Result.Ok(accepted.Ok());
-        }
-        log.lastError = `mercury ${o.call}: ${accepted.Err().message}`;
-        log.cause = "gate";
-        noteSend(log);
-    }
-    return failCall(vctx, { call: o.call, row: o.row, attempts, startedAt, totals, log });
-}
 function callRecord(o) {
     const t = o.totals;
     return {
@@ -1528,9 +521,6 @@ async function recordMercuryRow(vctx, o) {
                 retries: o.record.retries,
                 ...(o.record.history === undefined || o.record.history.length === 0 ? {} : { history: [...o.record.history] }),
                 ...(o.record.reasoningTokens === undefined ? {} : { reasoningTokens: o.record.reasoningTokens }),
-                ...(o.record.passedThrough === undefined || o.record.passedThrough.length === 0
-                    ? {}
-                    : { passedThrough: [...o.record.passedThrough] }),
                 ...(o.record.addressRepair === undefined || o.record.addressRepair.length === 0
                     ? {}
                     : { addressRepair: [...o.record.addressRepair] }),
@@ -1538,44 +528,12 @@ async function recordMercuryRow(vctx, o) {
                 ...(o.record.roomsDropped === undefined ? {} : { roomsDropped: o.record.roomsDropped }),
                 ...(o.record.fontDropped === undefined ? {} : { fontDropped: o.record.fontDropped }),
                 ...(o.record.fanout === undefined ? {} : { fanout: o.record.fanout }),
-                ...(o.record.juice === undefined ? {} : { juice: o.record.juice }),
-                ...(o.record.depth === undefined ? {} : { depth: o.record.depth }),
-                ...(o.record.screensDropped === undefined ? {} : { screensDropped: o.record.screensDropped }),
-                ...(o.record.reply === undefined ? {} : { reply: o.record.reply }),
-                ...(o.record.preambleFrom === undefined ? {} : { preambleFrom: o.record.preambleFrom }),
-                ...(o.record.storyChars === undefined ? {} : { storyChars: o.record.storyChars }),
-                ...(o.record.storyDropped === undefined ? {} : { storyDropped: o.record.storyDropped }),
-                ...(o.record.preambleChars === undefined ? {} : { preambleChars: o.record.preambleChars }),
                 ...(o.record.softMisses === undefined ? {} : { softMisses: o.record.softMisses }),
-                ...(o.record.coerced === undefined ? {} : { coerced: [...o.record.coerced] }),
-                ...(o.record.fieldsDropped === undefined ? {} : { fieldsDropped: [...o.record.fieldsDropped] }),
-                ...(o.record.preambleFallback === undefined ? {} : { preambleFallback: o.record.preambleFallback }),
-                ...(o.record.duo === undefined ? {} : { duo: o.record.duo }),
-                ...(o.record.duoDrafts === undefined ? {} : { duoDrafts: [...o.record.duoDrafts] }),
-                ...(o.record.duoBreadth === undefined ? {} : { duoBreadth: [...o.record.duoBreadth] }),
-                ...(o.record.duoPool === undefined ? {} : { duoPool: o.record.duoPool }),
-                ...(o.record.duoArchetypes === undefined ? {} : { duoArchetypes: [...o.record.duoArchetypes] }),
-                ...(o.record.duoConflict === undefined
-                    ? {}
-                    : { duoConflict: o.record.duoConflict, duoConflictReason: o.record.duoConflictReason }),
-                ...(o.record.recordsRules === undefined ? {} : { recordsRules: o.record.recordsRules }),
-                ...(o.record.recordsDropped === undefined ? {} : { recordsDropped: o.record.recordsDropped }),
-                ...(o.record.rulesDropped === undefined ? {} : { rulesDropped: o.record.rulesDropped }),
-                ...(o.record.oneCall === undefined ? {} : { oneCall: o.record.oneCall }),
-                ...(o.record.shapeCall === undefined ? {} : { shapeCall: o.record.shapeCall }),
-                ...(o.record.draftArchetypes === undefined ? {} : { draftArchetypes: [...o.record.draftArchetypes] }),
-                ...(o.record.archetypeSplit === undefined ? {} : { archetypeSplit: o.record.archetypeSplit }),
                 ...(o.record.flagsWinner === undefined ? {} : { flagsWinner: [...o.record.flagsWinner] }),
-                ...(o.record.flagsUnion === undefined ? {} : { flagsUnion: [...o.record.flagsUnion] }),
-                ...(o.record.backendFilterCleared === undefined ? {} : { backendFilterCleared: [...o.record.backendFilterCleared] }),
-                ...(o.record.backendFilterKept === undefined ? {} : { backendFilterKept: o.record.backendFilterKept }),
                 ...(o.record.planner === undefined ? {} : { planner: o.record.planner }),
                 ...(o.record.format === undefined ? {} : { format: o.record.format }),
-                ...(o.record.thinkAloud === undefined ? {} : { thinkAloud: { ...o.record.thinkAloud } }),
                 ...(o.record.cards === undefined ? {} : { cards: { ...o.record.cards } }),
                 ...(o.keepText !== true || o.record.text === undefined ? {} : { text: o.record.text }),
-                ...(o.keepText !== true || o.record.partialText === undefined ? {} : { partialText: o.record.partialText }),
-                ...(o.keepText !== true || o.record.duoTexts === undefined ? {} : { duoTexts: [...o.record.duoTexts] }),
                 ...(rounds.length === 0 ? {} : { usage: rounds.map((r) => ({ ...r })) }),
             },
         },
@@ -1645,334 +603,61 @@ export async function recordMercuryFim(vctx, o) {
     if (r.isErr())
         vctx.logger.Warn().Err(r).Str("chatId", o.chatId).Msg("mercury-first-build-fim-row-failed");
 }
-export const MERCURY_PROSE_FORMAT_EXAMPLES = [
-    {
-        ask: "an appointments book for my dog grooming business, with a page of notes on each client's dog",
-        brief: 'An appointments book for a dog grooming business. The owner\'s business object (default, named for the app, renameable in settings) holds two record kinds: dogs (client dogs) and appointments.\n\nMain screen: appointments book — a day-by-day agenda grouped by date (today first, upcoming days below, past collapsible), with a week strip to jump between days. Each appointment shows time, dog name, owner name, service (e.g. full groom, bath & brush, nail trim), duration, and status (booked / done / no-show) as a one-tap toggle. "New appointment" button opens a plain form: pick an existing dog (or add a new dog inline), date (relative words like "tomorrow"/"Friday" resolve against today and show the resolved date), time, service, duration, price, short note. Edit and delete on each appointment.\n\nDogs page: list of client dogs (searchable), each opening its own dog page: name, breed, owner name, owner phone, and a free-form notes page (temperament, coat, allergies, preferred cut, behaviour tips) that saves as you type, plus that dog\'s appointment history and next appointment, and a "Book this dog" button. Tapping a dog name on an appointment opens its page.\n\nRecords: dog {type:\'dog\', name, breed, ownerName, ownerPhone, notes} and appointment {type:\'appointment\', dogId, date (YYYY-MM-DD), time, service, durationMin, price, status, note}, all keyed to the business object id so staff can be invited later. Access rules: creator of the business object can read/write everything in it; members could be admitted later. No invite screen on screen yet.\n\nseed.json demo: the owner\'s business object, 6 dogs with realistic notes (e.g. a nervous poodle, a doodle with matting, a husky that hates dryers), and ~10 appointments dated around 2026-10-06 (a few past done, several today and this week).',
-    },
-    {
-        ask: "a snake game with a high score",
-        brief: "A classic snake game. Main screen: a square grid board (drawn in SVG or canvas using theme tokens) where the snake moves steadily and eats food to grow; hitting a wall or itself ends the round. Controls: arrow keys / WASD on desktop, swipe plus an on-screen D-pad on phones. Start/Pause and Play again buttons. Current score shown above the board, and the person's high score beside it. When a round ends with a new best, save a score record (player handle, score, date) and celebrate \"New high score!\". Show a small high-score list (top 10 scores with ViewerTag for who set them) below the board. Speed rises gently as the snake grows. Records: each signed-in person's scores keyed on their own handle; access rules let the creator write their own score records and everyone with the link read the leaderboard. seed.json: a handful of demo scores (e.g. 8–6 entries from a small cast of players, scores 12–87, dated in the days around 2026-10-06), including one for the owner.",
-    },
-    {
-        ask: "Make a family reunion bingo app. Let me paste our inside jokes, memories, or a message thread and turn them into a batch of squares I can edit. Deal a different card to each person I invite. We can mark squares and call bingo on our phones, with cards and progress saved.",
-        brief: 'Family reunion bingo. The owner has a default game (named for the app, renamable in settings) keyed on their handle. Front door: one composer where the owner pastes inside jokes, memories or a whole message thread. Add sends the text to callAI, which extracts short bingo square phrases, saves each as a square record in the game immediately, and lists the saved squares with Edit (inline text edit) and Delete actions. Each saved square has Change by sentence: selecting it switches Add to Apply correction, which rewrites that same square id. Ask action answers a question about the squares/game read-only beside the composer (e.g. "which squares mention Grandma?"). One Undo restores the latest batch add or the previous version of an edited square. If extraction fails, keep the pasted text in the box. A plain "Add square" text input stays beside the composer.\nInvite: HandleInput in the game writes a membership for each invited family member. Deal: each member (owner included) gets their own card record — a 5x5 grid with a FREE center, drawn by a seeded shuffle from the square pool, so each person\'s card is different; owner can press Deal cards / Redeal. Players open the game on their phones, tap squares to mark them (marks saved on their own card record, only the card\'s player can mark), and a Bingo! button lights up when a row, column or diagonal is complete; calling bingo writes a bingo record that everyone in the game sees in a winners feed with ViewerTag. A progress view shows each player\'s marked count. Games list reads games by type, showing shared ones with who made them.\nAccess: game created by owner; members can read the game, squares, all cards and bingo calls; only owner edits squares/deals; each player writes only their own card\'s marks and their own bingo call.\nSeed.json demo: a "Miller Family Reunion 2025" game owned by the owner with ~30 squares of believable inside jokes ("Uncle Ray tells the fishing story", "Someone burns the burgers", "Grandma asks who\'s dating whom", "Kids find the creek", "Aunt Linda\'s potato salad debate"), owner\'s membership plus two cousins, dealt cards with a few marks, and one bingo call.',
-    },
-];
-export const MERCURY_PROSE_SYSTEM = `You write the build brief for a small web app from a person's one-message request. The brief is read by the builder that writes the app's code. Return only JSON.
-
-Your reply first classifies the request, then names the app, then writes the brief.
-
-archetype, exactly one:
-${MERCURY_SHAPE_ARCHETYPE_TEXT}
-
-coreAction: the one thing the person does most in this app, as a short verb phrase in their own words ("tap once per glass", "paste the group chat", "lasso cows").
-recordNames: 1-5 short singular record type names the app stores (toys may have just "score" or none).
-capabilities: an array naming each capability the request itself needs, from this list; empty when it needs none:
-${MERCURY_CAPABILITY_TRIGGERS}
-
-${MERCURY_ADDRESS.rule}
-
-brief: one free-prose brief to the builder, in exactly the shape of the example briefs below — the same sections in the same order, the same voice addressed to the builder, the same plain paragraphs. It opens with one line saying what the app is; names the object the records belong to and who owns it; walks the screens with the controls each one has and what each does; names each record with its fields, as the examples write them; states the access rules — who reads and who writes; and ends with the seed.json demo, specific: names, items and states. Everything in it follows the classification and the person's own words.`;
-export function mercuryProseBriefSchema(opts = {}) {
-    const props = {
-        ...MERCURY_CLASSIFY_PROPERTIES,
-        ...MERCURY_ADDRESS.properties,
-        ...(opts.rooms === true ? { rooms: { type: "array", items: { type: "string" } } } : {}),
-        ...(opts.font === true ? { font: { type: "string" } } : {}),
-        brief: { type: "string" },
-    };
-    return { type: "object", additionalProperties: false, required: Object.keys(props), properties: props };
-}
-export function mercuryProseBriefMessages(o) {
-    const rooms = o.rooms === true;
-    const font = o.font === true;
-    const examples = MERCURY_PROSE_FORMAT_EXAMPLES.map((e, i) => `Example ${i + 1}. The person asked: "${e.ask}"\nbrief:\n${e.brief}`).join("\n\n");
-    const skeleton = {
-        ...Object.fromEntries(Object.entries(MERCURY_CLASSIFY_HINTS).map(([k, h]) => [k, `<${h}>`])),
-        ...Object.fromEntries(Object.entries(MERCURY_ADDRESS.hints).map(([k, h]) => [k, `<${h}>`])),
-        ...(rooms ? { rooms: `<${MERCURY_ROOMS_HINT}>` } : {}),
-        ...(font ? { font: `<${MERCURY_FONT_HINT}>` } : {}),
-        brief: "<the brief to the builder, in the examples' shape>",
-    };
-    const user = [
-        "Answer in exactly this shape, each value replaced by the real text:",
-        JSON.stringify(skeleton, null, 1),
-        ...(rooms ? ["", `Rooms: ${poufRoomCatalog()}`] : []),
-        ...(font ? ["", `Fonts: ${vibeFontCatalog()}`] : []),
-        "",
-        `Person's words: "${o.personWords}"`,
-        "",
-        `Classify the person's words, name the app, then write its brief the way the examples write theirs. Return JSON with these keys: ${Object.keys(skeleton).join(", ")} (${MERCURY_ADDRESS.ask}).` +
-            (rooms ? ` ${MERCURY_ROOMS_ASK}` : "") +
-            (font ? ` ${MERCURY_FONT_ASK}` : ""),
-        ...(o.words.length > 0 ? [mercurySlugWordsSentence(o.words)] : []),
-    ].join("\n");
-    return [
-        { role: "system", content: [{ type: "text", text: `${MERCURY_PROSE_SYSTEM}\n\n${examples}` }] },
-        { role: "user", content: [{ type: "text", text: user }] },
-    ];
-}
-export function gateMercuryProseDraft(json, o) {
-    const parsed = replyObject(json);
-    if (Array.isArray(json) || parsed instanceof type.errors)
-        return Result.Err("reply:not-an-object");
-    const rShape = parseMercuryDraftShape(parsed, o.personWords);
-    if (rShape.isErr())
-        return Result.Err(`classification:${rShape.Err().message}`);
-    const brief = typeof parsed.brief === "string" ? cleanMercuryText(parsed.brief) : "";
-    if (brief.length === 0)
-        return Result.Err("brief:empty");
-    const decoded = MERCURY_ADDRESS.decode(parsed);
-    if (decoded.isErr())
-        return Result.Err(`pairs:${decoded.Err().message}`);
-    const d = decoded.Ok();
-    const strict = d.title === undefined ? undefined : gateMercuryAddress({ title: d.title, slugs: d.slugs });
-    const address = strict?.isOk() === true ? strict.Ok() : looseMercuryAddress(d.title, d.slugs);
-    if (address === undefined)
-        return Result.Err("pairs:empty");
-    return Result.Ok({
-        shape: rShape.Ok(),
-        brief,
-        address,
-        addressRepair: [...d.repairs, ...(address.fallback ? ["slug-fallback"] : [])],
-        ...(o.askRooms && "rooms" in parsed ? { rooms: gateMercuryRooms(parsed.rooms) } : {}),
-        ...(o.askRooms && "font" in parsed ? { font: gateMercuryFont(parsed.font) } : {}),
-    });
-}
-export function assembleMercuryProseCreateVibe(o) {
-    const s = o.draft.shape;
-    const nature = mercuryNature(s, o.personWords);
-    const rooms = sanitizeRoomShortlist("pouf", o.draft.rooms?.rooms);
-    return {
-        prompt: o.personWords,
-        enrichedPrompt: `${o.draft.brief}\n\nThe person asked: "${o.personWords}".`,
-        skills: mercurySkills(s, { personWords: o.personWords }),
-        pairs: o.draft.address.pairs.map((p) => ({ title: p.title, slug: p.slug })),
-        nature,
-        ...(nature === "sensitive" ? { privacySensitive: true } : {}),
-        ...(rooms === undefined ? {} : { rooms: [...rooms] }),
-        ...(o.draft.font?.font === undefined ? {} : { font: o.draft.font.font }),
-    };
-}
-export function mercuryProsePreamble(draft) {
-    return `I'm making ${draft.address.pairs[0]?.title ?? "your app"} for you: ${draft.shape.coreAction}.`;
-}
-export const MERCURY_THINKALOUD_MARKER = "--- SPEC ---";
-export const MERCURY_THINKALOUD_SPEC_HINTS = {
-    archetype: "one of personal, group, publish, intake, open, toy: the ownership shape that fits the person's words",
-    coreAction: "the one thing the person does most in this app, a short verb phrase in their own words",
-    recordNames: "1 to 5 short singular record type names the app stores, comma-separated",
-    capabilities: "the capabilities this request needs, from the capability list, comma-separated; none when it needs none",
-    opening: "one sentence to the builder: what the app is, for whom, and what it does, in the person's words",
-    access: "who owns the object, who else is let in and what they write, what a visitor sees",
-    records: 'each record type with its fields: "name (field, field); name (field, field)", plus the id rule where one matters',
-    screens: "1. the first screen: what it shows from the records, what the person does there, and what leads while it is empty; 2. ...; 3. ...",
-    seed: "seed.json: the demo records in words: who is in it, which state each record is in, how they relate; every state the mechanism and the clauses mention; the person's typed items verbatim; the builder picks amounts, counts and dates",
-    mechanism: "the one computation or invariant the app hinges on, with the unit of every number it computes",
-    clauses: 'one line per clause of the person\'s words: "their clause" → record field → control → twice: what the second identical write does',
-    look: "one scene: surface, palette, card shape, one gesture of mood",
-    title: "the app's name, two or three words in its own vocabulary",
-    slugs: "three short kebab-case addresses for the app, comma-separated",
-    icon: "one object from the app's world",
-};
-const THINKALOUD_BRIEF_KEYS = ["opening", "access", "records", "screens", "seed", "mechanism", "clauses", "look", "icon"];
-export function mercuryThinkAloudSystem(o = {}) {
-    const keys = {
-        ...MERCURY_THINKALOUD_SPEC_HINTS,
-        ...(o.rooms === true ? { rooms: `${MERCURY_ROOMS_HINT}, comma-separated` } : {}),
-        ...(o.font === true ? { font: MERCURY_FONT_HINT } : {}),
-    };
-    const specLines = Object.entries(keys)
-        .map(([k, h]) => `${k}: <${h}>`)
-        .join("\n");
-    return `You are a usability tester. Someone has just shown you this request for a small web app, and you are seeing it for the first time. Think out loud, in the first person, the way you would in a recorded session. These are hunches, not answers: label them as guesses ("I'd guess", "probably", "not sure", "wait").
-
-1. What you picture when you read it, and what you would tap first.
-2. Then keep asking "and then what happens to…": if I do this, what changes somewhere else? What does that number mean, and what is it made of? What did the person not say that the app has to decide anyway?
-3. What feels off or ambiguous in the person's exact words, quoting them.
-
-Then write one line that reads exactly "${MERCURY_THINKALOUD_MARKER}" and switch roles: write the settled parts of a brief for a builder, using only what you now believe after the think-aloud. One key per line, in this order, as "key: value"; the clauses and screens may take one line each under their key. Every line that rests on one of your guesses rather than on the person's words starts its value with "guess:"; a line the person's words settle carries no label.
-
-${specLines}
-
-archetype, exactly one:
-${MERCURY_LEAN_ARCHETYPES}
-
-capabilities: each capability the request itself needs, from this list; none when it needs none:
-${MERCURY_LEAN_CAPABILITIES}
-
-${MERCURY_LEAN_ADDRESS}`;
-}
-export function mercuryThinkAloudMessages(o) {
-    const rooms = o.rooms === true;
-    const font = o.font === true;
-    const user = [
-        `The app creator's initial prompt: "${o.personWords}"`,
-        ...(rooms ? ["", `Rooms: ${poufRoomCatalog()}`] : []),
-        ...(font ? ["", `Fonts: ${vibeFontCatalog()}`] : []),
-        ...(o.words.length > 0 ? ["", mercurySlugWordsSentence(o.words)] : []),
-    ].join("\n");
-    return [
-        { role: "system", content: [{ type: "text", text: mercuryThinkAloudSystem({ rooms, font }) }] },
-        { role: "user", content: [{ type: "text", text: user }] },
-    ];
-}
-const THINKALOUD_KEYS = new Set([...Object.keys(MERCURY_THINKALOUD_SPEC_HINTS), "rooms", "font"]);
-const THINKALOUD_MARKER_LINE = /^[ \t]*[*_#>-]*[ \t]*-{2,}[ \t]*SPEC[ \t]*-{2,}[ \t]*[*_]*[ \t]*$/im;
-const THINKALOUD_KEY_LINE = /^\s*(?:[-*]\s+)?(?:\*\*|__)?([A-Za-z]+)(?:\*\*|__)?\s*:(?:\*\*|__)?\s*(.*)$/;
-const GUESS_LABEL = /\bguess\s*:/i;
-export function parseMercuryThinkAloud(text) {
-    const m = THINKALOUD_MARKER_LINE.exec(text);
-    if (m === null)
-        return undefined;
-    const narration = text.slice(0, m.index).trim();
-    const spec = text
-        .slice(m.index + m[0].length)
-        .replace(/^\s*```[a-zA-Z]*\n?|\n?```\s*$/g, "")
-        .trim();
-    const keys = {};
-    let current;
-    for (const line of spec.split("\n")) {
-        const k = THINKALOUD_KEY_LINE.exec(line);
-        const name = k === null ? undefined : [...THINKALOUD_KEYS].find((x) => x.toLowerCase() === k[1].toLowerCase());
-        if (name !== undefined && k !== null && keys[name] === undefined) {
-            current = name;
-            keys[name] = k[2].trim();
-            continue;
-        }
-        if (current !== undefined && line.trim().length > 0)
-            keys[current] = `${keys[current]}\n${line.trim()}`.trim();
-    }
-    const guessLines = spec.split("\n").filter((l) => GUESS_LABEL.test(l)).length;
-    return { narration, spec, keys, guessLines };
-}
-function thinkAloudScalar(v) {
+const TAIL_KEY_LINE = /^\s*(?:[-*]\s+)?(?:\*\*|__)?([A-Za-z]+)(?:\*\*|__)?\s*:(?:\*\*|__)?\s*(.*)$/;
+function tailScalar(v) {
     return (v ?? "")
         .replace(/^\s*\(?\s*guess\s*:\s*/i, "")
         .replace(/\(\s*guess[^)]*\)/gi, "")
         .replace(/\bguess\s*:\s*/gi, "")
-        .trim()
-        .replace(/^["'`]+|["'`]+$/g, "")
-        .trim();
-}
-function thinkAloudList(v) {
-    const t = thinkAloudScalar(v).replace(/^\[|\]$/g, "");
-    return t
-        .split(/\s*[,;\n]\s*/)
-        .map((x) => x
-        .trim()
-        .replace(/^["'`]+|["'`]+$/g, "")
-        .trim())
-        .filter((x) => x.length > 0 && /^(none|n\/a|nothing|-)$/i.test(x) === false);
-}
-export const MERCURY_THINKALOUD_DEFAULT_ARCHETYPE = MERCURY_ARCHETYPES[0];
-export function gateMercuryThinkAloud(raw, o) {
-    if (typeof raw !== "string" || raw.trim().length === 0)
-        return Result.Err("parse:empty");
-    const soft = {};
-    const miss = (part, what) => {
-        soft[part] = [...(soft[part] ?? []), what];
-    };
-    const parsed = parseMercuryThinkAloud(raw);
-    if (parsed === undefined)
-        miss("marker", "missing");
-    else if (parsed.spec.length === 0)
-        miss("spec", "empty");
-    const p = parsed ?? {
-        narration: raw.trim(),
-        spec: "",
-        keys: {},
-        guessLines: raw.split("\n").filter((l) => GUESS_LABEL.test(l)).length,
-    };
-    const caps = [];
-    for (const c of thinkAloudList(p.keys.capabilities).map((x) => x.toLowerCase())) {
-        const flag = MERCURY_FLAGS.find((f) => f.toLowerCase() === c);
-        if (flag === undefined)
-            miss("capabilities", "unknown");
-        else if (!caps.includes(flag))
-            caps.push(flag);
-    }
-    const named = thinkAloudScalar(p.keys.archetype)
-        .toLowerCase()
-        .match(/[a-z]+/)?.[0] ?? "";
-    const known = MERCURY_ARCHETYPES.find((a) => a === named);
-    if (known === undefined)
-        miss("archetype", "default");
-    const said = thinkAloudScalar(p.keys.coreAction);
-    if (said.length === 0)
-        miss("coreAction", "default");
-    const rShape = parseMercuryDraftShape({
-        archetype: known ?? MERCURY_THINKALOUD_DEFAULT_ARCHETYPE,
-        coreAction: said.length > 0 ? said : o.personWords.trim(),
-        recordNames: thinkAloudList(p.keys.recordNames),
-        capabilities: caps,
-    }, o.personWords);
-    if (rShape.isErr())
-        return Result.Err(`classification:${rShape.Err().message}`);
-    const decoded = MERCURY_ADDRESS.decode({
-        ...(p.keys.title === undefined ? {} : { title: thinkAloudScalar(p.keys.title) }),
-        slugs: thinkAloudList(p.keys.slugs),
-    });
-    if (decoded.isErr())
-        miss("pairs", decoded.Err().message);
-    const d = decoded.isOk() ? decoded.Ok() : { slugs: [], repairs: [] };
-    const strict = d.title === undefined ? undefined : gateMercuryAddress({ title: d.title, slugs: d.slugs });
-    const loose = strict?.isOk() === true ? strict.Ok() : looseMercuryAddress(d.title, d.slugs);
-    if (strict?.isErr() === true && loose !== undefined)
-        miss("pairs", strict.Err().message);
-    if (loose === undefined)
-        miss("pairs", "default");
-    const address = loose ?? { pairs: [], fallback: true, tagged: false };
-    if (p.narration.length === 0)
-        miss("narration", "empty");
-    for (const k of THINKALOUD_BRIEF_KEYS)
-        if (p.keys[k] === undefined || p.keys[k].trim().length === 0)
-            miss(k, "missing");
-    if (o.askRooms && p.keys.rooms === undefined)
-        miss("rooms", "default");
-    if (o.askRooms && p.keys.font === undefined)
-        miss("font", "default");
-    return Result.Ok({
-        shape: rShape.Ok(),
-        reply: raw,
-        narration: p.narration,
-        spec: p.spec,
-        address,
-        addressRepair: [...d.repairs, ...(address.fallback && address.pairs.length > 0 ? ["slug-fallback"] : [])],
-        ...(o.askRooms && p.keys.rooms !== undefined ? { rooms: gateMercuryRooms(thinkAloudList(p.keys.rooms)) } : {}),
-        ...(o.askRooms && p.keys.font !== undefined ? { font: gateMercuryFont(thinkAloudScalar(p.keys.font)) } : {}),
-        softMisses: soft,
-        guessLines: p.guessLines,
-    });
+        .trim()
+        .replace(/^["'`]+|["'`]+$/g, "")
+        .trim();
+}
+function tailList(v) {
+    const t = tailScalar(v).replace(/^\[|\]$/g, "");
+    return t
+        .split(/\s*[,;\n]\s*/)
+        .map((x) => x
+        .trim()
+        .replace(/^["'`]+|["'`]+$/g, "")
+        .trim())
+        .filter((x) => x.length > 0 && /^(none|n\/a|nothing|-)$/i.test(x) === false);
 }
+export const MERCURY_CARDS_DEFAULT_ARCHETYPE = MERCURY_ARCHETYPES[0];
 export const MERCURY_TESTER_REPLY_INTRO = "A fast tester's first read:";
 export const MERCURY_TESTER_REPLY_RULE = "Guesses only; the creator's words win.";
-export function mercuryTesterReplyEnrichedPrompt(reply, personWords) {
+export const MERCURY_SHARING_LINE = {
+    personal: "Each person's records live in their own object, keyed on its creator, and carry the object id so a friend could be invited later; a one-tap publish shares a chosen record with everyone who can open the app.",
+    group: "Memberships are written by the platform's HandleInput invite screen, which is part of this first build; shared objects show who made them with ViewerTag.",
+    publish: "The owner writes; everything they publish is readable by anyone with the link, signed in or not. Shaped so a co-owner could be let in later.",
+    intake: "Every visitor adds submissions to the shared list, signed in or not; a signed-in visitor edits only their own (a signed-out submission is create-only — the rules have no identity to check it against), and the signed-in owner reads and manages all of them. Shaped so staff could be let in later.",
+    open: "Everyone with the link reads the shared records — posts, votes, entries — signed in or not; every signed-in visitor adds their own and edits only their own, and the owner can remove anything.",
+    toy: "Anything players save — beats, levels, scores, creations — lands on one always-on public channel, readable by anyone with the link, signed in or not; each signed-in player edits only their own, and the owner can remove anything.",
+};
+export const MERCURY_SHARING_KEEPS_TO_THEMSELVES = "Each person's records are theirs alone, and a one-tap publish shares a chosen one with everyone who can open the app.";
+export const MERCURY_SHARING_SENSITIVE = 'Each person\'s records are private to them from the first one, and sharing is theirs to turn on: a "Shared with followers" checkbox that starts unchecked, an add-buddies picker that grants one chosen handle, and a one-tap publish for a single finished item — never an always-on public channel for the records.';
+export const MERCURY_SHARING_PREFIX = "Who sees what:";
+export function mercurySharingLine(shape, personWords) {
+    const line = shape.keepsToThemselves === true
+        ? MERCURY_SHARING_KEEPS_TO_THEMSELVES
+        : mercuryNature(shape, personWords) === "sensitive"
+            ? MERCURY_SHARING_SENSITIVE
+            : MERCURY_SHARING_LINE[shape.archetype];
+    return `${MERCURY_SHARING_PREFIX} ${line}`;
+}
+export function mercuryTesterReplyEnrichedPrompt(reply, personWords, shape) {
     return [
         MERCURY_TESTER_REPLY_INTRO,
         `<tester-reply>\n${reply}\n</tester-reply>`,
         MERCURY_TESTER_REPLY_RULE,
+        mercurySharingLine(shape, personWords),
+        ...mercuryCardsBuilderLines(shape),
         `The app creator's initial prompt: "${personWords}"`,
     ].join("\n\n");
 }
-export function assembleMercuryThinkAloudCreateVibe(o) {
-    const s = o.draft.shape;
-    const nature = mercuryNature(s, o.personWords);
-    const rooms = sanitizeRoomShortlist("pouf", o.draft.rooms?.rooms);
-    return {
-        prompt: o.personWords,
-        enrichedPrompt: mercuryTesterReplyEnrichedPrompt(o.draft.reply, o.personWords),
-        skills: mercurySkills(s, { personWords: o.personWords }),
-        ...(o.draft.address.pairs.length === 0 ? {} : { pairs: o.draft.address.pairs.map((p) => ({ title: p.title, slug: p.slug })) }),
-        nature,
-        ...(nature === "sensitive" ? { privacySensitive: true } : {}),
-        ...(rooms === undefined ? {} : { rooms: [...rooms] }),
-        ...(o.draft.font?.font === undefined ? {} : { font: o.draft.font.font }),
-    };
-}
-export function mercuryThinkAloudPreamble(draft) {
-    return `I'm making ${draft.address.pairs[0]?.title ?? "your app"} for you: ${draft.shape.coreAction}.`;
+export const MERCURY_COMPOSER_LINE = "The records come in through a sentence composer (Add and Ask) as the front door.";
+export function mercuryCardsBuilderLines(shape) {
+    return [shape.flags.composer ? MERCURY_COMPOSER_LINE : "", KNOWN_VALUES_DIRECT_CONTROLS].filter((l) => l.length > 0);
 }
 export const MERCURY_CARDS_MARKER = "--- CARDS ---";
 export const MERCURY_CARDS_APP_MARKER = "--- APP ---";
@@ -1988,10 +673,15 @@ export const MERCURY_CARDS_SHAPE = `As a <role>, I <action on a named record>, s
   Accept: <another>
   Data: <Record>{<field>, <field>, ...}
   Rule: <a value this card depends on and how it comes about, said loosely in one plain English sentence a friend would understand>`;
+export const MERCURY_ASK_WORDS_RULE = `Keep the ask's genre and capability words exactly as the person wrote them — 3D, first-person, email, a named recipient, a schedule, a fixed number of people — in the preamble and the cards.`;
+export const MERCURY_TYPED_DATA_RULE = `When the person typed data — items, amounts, names, a list — the cards carry every piece of it verbatim, quantities included ("half a bag" stays "half a bag").`;
 export const MERCURY_CARDS_RULES = `Rules:
 - Use the person's own nouns for records, roles and actions.
 - Give what the person asked for plus what those parts need in order to work.
-- A line that rests on your assumption and not on the person's words ends with (guess). A line the person's words settle carries no label.`;
+- A line that rests on your assumption and not on the person's words ends with (guess). A line the person's words settle carries no label.
+- ${MERCURY_ASK_WORDS_RULE}
+- ${MERCURY_TYPED_DATA_RULE}`;
+const MERCURY_CARDS_CAPABILITIES = MERCURY_LEAN_CAPABILITIES.replace(MERCURY_FIRST_PERSON_TRIGGER, `${MERCURY_FIRST_PERSON_TRIGGER}\n${MERCURY_BLOCK_WORLD_TRIGGER}`);
 export function mercuryCardsSystem(o = {}) {
     const keys = {
         ...MERCURY_CARDS_TAIL_HINTS,
@@ -2016,9 +706,9 @@ archetype, exactly one:
 ${MERCURY_LEAN_ARCHETYPES}
 
 capabilities: each capability the request itself needs, from this list; none when it needs none:
-${MERCURY_LEAN_CAPABILITIES}
+${MERCURY_CARDS_CAPABILITIES}
 
-${MERCURY_LEAN_ADDRESS}`;
+${MERCURY_ADDRESS.rule}`;
 }
 export function mercuryCardsMessages(o) {
     const rooms = o.rooms === true;
@@ -2074,7 +764,7 @@ export function parseMercuryCards(text) {
     const keys = {};
     if (appMarkerAt >= 0) {
         for (const line of lines.slice(appMarkerAt + 1)) {
-            const k = THINKALOUD_KEY_LINE.exec(line);
+            const k = TAIL_KEY_LINE.exec(line);
             const name = k === null ? undefined : [...CARDS_TAIL_KEYS].find((x) => x.toLowerCase() === k[1].toLowerCase());
             if (name !== undefined && k !== null && keys[name] === undefined)
                 keys[name] = k[2].trim();
@@ -2110,21 +800,21 @@ export function gateMercuryCards(raw, o) {
     if (p.cardLines.length === 0)
         miss("cards", "none");
     const caps = [];
-    for (const c of thinkAloudList(p.keys.capabilities).map((x) => x.toLowerCase())) {
+    for (const c of tailList(p.keys.capabilities).map((x) => x.toLowerCase())) {
         const flag = MERCURY_FLAGS.find((f) => f.toLowerCase() === c);
         if (flag === undefined)
             miss("capabilities", "unknown");
         else if (!caps.includes(flag))
             caps.push(flag);
     }
-    const named = thinkAloudScalar(p.keys.archetype)
+    const named = tailScalar(p.keys.archetype)
         .toLowerCase()
         .match(/[a-z]+/)?.[0] ?? "";
     const known = MERCURY_ARCHETYPES.find((a) => a === named);
     if (known === undefined)
         miss("archetype", "default");
-    const rShape = parseMercuryDraftShape({
-        archetype: known ?? MERCURY_THINKALOUD_DEFAULT_ARCHETYPE,
+    const rShape = parseMercuryBriefShape({
+        archetype: known ?? MERCURY_CARDS_DEFAULT_ARCHETYPE,
         coreAction: o.personWords.trim(),
         recordNames: p.dataRecords.slice(0, 5),
         capabilities: caps,
@@ -2132,8 +822,8 @@ export function gateMercuryCards(raw, o) {
     if (rShape.isErr())
         return Result.Err(`classification:${rShape.Err().message}`);
     const decoded = MERCURY_ADDRESS.decode({
-        ...(p.keys.title === undefined ? {} : { title: thinkAloudScalar(p.keys.title) }),
-        slugs: thinkAloudList(p.keys.slugs),
+        ...(p.keys.title === undefined ? {} : { title: tailScalar(p.keys.title) }),
+        slugs: tailList(p.keys.slugs),
     });
     if (decoded.isErr())
         miss("pairs", decoded.Err().message);
@@ -2155,8 +845,8 @@ export function gateMercuryCards(raw, o) {
         parsed: p,
         address,
         addressRepair: [...d.repairs, ...(address.fallback && address.pairs.length > 0 ? ["slug-fallback"] : [])],
-        ...(o.askRooms && p.keys.rooms !== undefined ? { rooms: gateMercuryRooms(thinkAloudList(p.keys.rooms)) } : {}),
-        ...(o.askRooms && p.keys.font !== undefined ? { font: gateMercuryFont(thinkAloudScalar(p.keys.font)) } : {}),
+        ...(o.askRooms && p.keys.rooms !== undefined ? { rooms: gateMercuryRooms(tailList(p.keys.rooms)) } : {}),
+        ...(o.askRooms && p.keys.font !== undefined ? { font: gateMercuryFont(tailScalar(p.keys.font)) } : {}),
         softMisses: soft,
     });
 }
@@ -2286,7 +976,7 @@ async function mercuryFimCall(fetchImpl, o) {
     return { kind: "failed", error: last.length === 0 ? "aborted" : last };
 }
 export async function mercuryCardsFim(vctx, o) {
-    const p = o.draft.parsed;
+    const p = o.brief.parsed;
     const startedAt = Date.now();
     const bodyEnd = p.appMarkerAt ?? p.lines.length;
     const base = {
@@ -2300,9 +990,9 @@ export async function mercuryCardsFim(vctx, o) {
         completionTokens: 0,
     };
     if (o.apiKey === undefined || o.apiKey.length === 0)
-        return { reply: o.draft.reply, receipt: { status: "no-key", ...base, ms: Date.now() - startedAt } };
+        return { reply: o.brief.reply, receipt: { status: "no-key", ...base, ms: Date.now() - startedAt } };
     if (p.cardLines.length === 0)
-        return { reply: o.draft.reply, receipt: { status: "no-cards", ...base, ms: Date.now() - startedAt } };
+        return { reply: o.brief.reply, receipt: { status: "no-cards", ...base, ms: Date.now() - startedAt } };
     const apiKey = o.apiKey;
     const budgetMs = o.budgetMs ?? MERCURY_FIM_BUDGET_MS;
     const callMs = o.deadlineMs ?? MERCURY_FIM_CALL_DEADLINE_MS;
@@ -2367,67 +1057,25 @@ export async function mercuryCardsFim(vctx, o) {
     };
 }
 export function assembleMercuryCardsCreateVibe(o) {
-    const s = o.draft.shape;
+    const s = o.brief.shape;
     const nature = mercuryNature(s, o.personWords);
-    const rooms = sanitizeRoomShortlist("pouf", o.draft.rooms?.rooms);
+    const rooms = sanitizeRoomShortlist("pouf", o.brief.rooms?.rooms);
     return {
         prompt: o.personWords,
-        enrichedPrompt: mercuryTesterReplyEnrichedPrompt(o.reply, o.personWords),
+        enrichedPrompt: mercuryTesterReplyEnrichedPrompt(o.reply, o.personWords, s),
         skills: mercurySkills(s, { personWords: o.personWords }),
-        ...(o.draft.address.pairs.length === 0 ? {} : { pairs: o.draft.address.pairs.map((p) => ({ title: p.title, slug: p.slug })) }),
+        ...(o.brief.address.pairs.length === 0 ? {} : { pairs: o.brief.address.pairs.map((p) => ({ title: p.title, slug: p.slug })) }),
         nature,
         ...(nature === "sensitive" ? { privacySensitive: true } : {}),
         ...(rooms === undefined ? {} : { rooms: [...rooms] }),
-        ...(o.draft.font?.font === undefined ? {} : { font: o.draft.font.font }),
-    };
-}
-export function mercuryCardsPreamble(draft, personWords) {
-    if (draft.parsed.preamble.length > 0)
-        return draft.parsed.preamble;
-    return `I'm making ${draft.address.pairs[0]?.title ?? "your app"} for you: ${personWords}.`;
-}
-function takeOf(g) {
-    return {
-        opening: g.texts.get("opening") ?? "",
-        access: g.texts.get("access") ?? "",
-        seed: g.texts.get("seed") ?? "",
-        look: g.texts.get("look") ?? "",
-        ...(g.records?.screens === undefined ? {} : { records: g.records.screens }),
-        ...(g.rules?.screens === undefined ? {} : { rules: g.rules.screens }),
-        ...(g.screens?.screens === undefined ? {} : { screens: g.screens.screens }),
-        ...(g.story?.story === undefined ? {} : { story: g.story.story }),
-        ...(g.preamble === undefined ? {} : { preamble: g.preamble }),
+        ...(o.brief.font?.font === undefined ? {} : { font: o.brief.font.font }),
     };
 }
-function owedBriefFields(gated) {
-    return MERCURY_BRIEF_FIELDS.filter((f) => (f === "pairs" ? gated.pairs === undefined : gated.texts.has(f) === false));
-}
-const replyObject = lazyType(() => type("Record<string, unknown>"));
-export function coerceMercuryText(v) {
-    if (typeof v === "string")
-        return { text: v, coerced: false };
-    const leaves = (x) => {
-        if (typeof x === "string")
-            return x.trim().length === 0 ? undefined : x;
-        if (Array.isArray(x)) {
-            const parts = x.map(leaves).filter((t) => t !== undefined);
-            return parts.length === 0 ? undefined : parts.join("; ");
-        }
-        if (x !== null && typeof x === "object") {
-            const parts = Object.entries(x).flatMap(([k, val]) => {
-                const t = leaves(val);
-                return t === undefined ? [] : [`${k}: ${t}`];
-            });
-            return parts.length === 0 ? undefined : parts.join("; ");
-        }
-        return undefined;
-    };
-    if (v === null || typeof v !== "object")
-        return { coerced: false };
-    const text = leaves(v);
-    return text === undefined ? { coerced: false } : { text, coerced: true };
+export function mercuryCardsPreamble(brief, personWords) {
+    if (brief.parsed.preamble.length > 0)
+        return brief.parsed.preamble;
+    return `I'm making ${brief.address.pairs[0]?.title ?? "your app"} for you: ${personWords}.`;
 }
-export const MERCURY_DROP_OVER_BOUND = 3;
 function titleFromSlug(slug) {
     return slug
         .split("-")
@@ -2447,164 +1095,6 @@ function looseMercuryAddress(title, slugs) {
     const addresses = kept.length > 0 ? kept : [kebab(name)];
     return { pairs: addresses.map((slug) => ({ title: sent, slug })), fallback: kept.length === 0, tagged: cut.repaired };
 }
-function acceptBriefFields(json, o) {
-    const parsed = replyObject(json);
-    const notAnObject = Array.isArray(json) || parsed instanceof type.errors;
-    const salvaged = notAnObject ? MERCURY_ADDRESS.salvage(json) : undefined;
-    const body = notAnObject ? (salvaged ?? {}) : parsed;
-    const failed = [];
-    const keepsNothing = o.shape.archetype === "toy" && o.shape.recordNames.length === 0;
-    const soft = (field, misses) => {
-        if (misses.length === 0)
-            return;
-        o.into.softMisses.set(field, [...(o.into.softMisses.get(field) ?? []), ...misses]);
-    };
-    const text = (key) => {
-        const c = coerceMercuryText(body[key]);
-        if (c.coerced)
-            o.into.coerced.add(key);
-        return c.text;
-    };
-    if (o.roomsOwed === true && "rooms" in body)
-        o.into.rooms = gateMercuryRooms(body.rooms);
-    if (o.fontOwed === true && "font" in body)
-        o.into.font = gateMercuryFont(body.font);
-    if (o.screensOwed === true && "screens" in body) {
-        const t = text("screens");
-        o.into.screens = gateMercuryScreens(t ?? body.screens);
-    }
-    if (o.recordsOwed === true) {
-        for (const key of ["records", "rules"]) {
-            if (o.into[key] !== undefined)
-                continue;
-            if (!(key in body)) {
-                soft(key, ["not-a-string"]);
-                continue;
-            }
-            const t = text(key);
-            o.into[key] = gateMercuryScreens(t ?? body[key]);
-        }
-    }
-    if (o.storyOwed === true && "story" in body) {
-        const t = text("story");
-        const g = gateMercuryStory(t ?? body.story);
-        o.into.story = g;
-        soft("story", g.misses ?? []);
-    }
-    if (o.preambleOwed === true && "preamble" in body) {
-        const t = text("preamble");
-        if (t === undefined || cleanMercuryText(t).length === 0)
-            soft("preamble", ["empty"]);
-        else {
-            soft("preamble", gateMercuryWholePreamble(t));
-            o.into.preamble = cleanMercuryText(t);
-        }
-    }
-    for (const f of o.owed) {
-        if (f === "pairs") {
-            const decoded = MERCURY_ADDRESS.decode(body);
-            if (decoded.isErr()) {
-                failed.push(`pairs:${decoded.Err().message}`);
-                continue;
-            }
-            const d = decoded.Ok();
-            if (salvaged !== undefined)
-                o.into.addressRepair.add("salvage");
-            for (const r of d.repairs)
-                o.into.addressRepair.add(r);
-            const slugs = d.slugs.length > 0 ? d.slugs : (o.into.heldSlugs ?? []);
-            if (d.title === undefined && d.slugs.length > 0)
-                o.into.heldSlugs = d.slugs;
-            if (d.title === undefined && failed.length > 0) {
-                failed.push("pairs:title-missing");
-                continue;
-            }
-            const strict = d.title === undefined ? Result.Err("title-missing") : gateMercuryAddress({ title: d.title, slugs });
-            const address = strict.isOk() ? strict.Ok() : looseMercuryAddress(d.title, slugs);
-            if (address === undefined) {
-                failed.push(`pairs:${strict.isErr() ? strict.Err().message : "empty"}`);
-                continue;
-            }
-            if (strict.isErr()) {
-                soft("pairs", [strict.Err().message]);
-                if (d.title === undefined)
-                    o.into.addressRepair.add("title-from-slug");
-            }
-            if (address.tagged)
-                o.into.misses.add("archetype-tag");
-            if (address.fallback)
-                o.into.addressRepair.add("slug-fallback");
-            o.into.pairs = address.pairs;
-            continue;
-        }
-        const v = text(replyKey(f));
-        if (v === undefined) {
-            if (f === "opening")
-                failed.push("opening:not-a-string");
-            else
-                soft(f, ["not-a-string"]);
-            continue;
-        }
-        const prepared = prepareMercuryField(f, v);
-        const fails = gateMercuryField({ field: f, value: prepared.gate, shape: o.shape });
-        if (f === "opening" && cleanMercuryText(prepared.value).length === 0) {
-            failed.push("opening:empty");
-            continue;
-        }
-        const [, hi] = FIELD_BOUNDS[f];
-        if (cleanMercuryText(prepared.value).length > hi * MERCURY_DROP_OVER_BOUND) {
-            if (f === "opening") {
-                failed.push("opening:long");
-                continue;
-            }
-            o.into.fieldsDropped.add(f);
-            o.into.texts.set(f, "");
-            continue;
-        }
-        soft(f, fails);
-        o.into.texts.set(f, prepared.value);
-        if (f !== "seed" || keepsNothing === false)
-            for (const m of prepared.misses)
-                o.into.misses.add(m);
-    }
-    return failed;
-}
-function softMissCount(g) {
-    return [...g.softMisses.values()].reduce((n, m) => n + m.length, 0);
-}
-export const MERCURY_BRIEF_FANOUT = 4;
-export const MERCURY_SHAPE_MAX_TOKENS = 800;
-export const MERCURY_PICK_WAIT_MS = 1500;
-export const MERCURY_PICK_COUNT = 2;
-export const MERCURY_DUO_PICK_COUNT = 3;
-export const MERCURY_ONECALL_EXTRA_TOKENS = 400;
-const BREADTH_CTRL = /\b(button|tap|taps|toggle|picker|stepper|chip|chips|slider|drag|swipe|stars|ribbon|stamp|badge|bars?|search|filter|tabs?|headline|confetti|animation|counter|dial|segmented|checkbox|strip|gauge|sparkline|progress|swatch|card|cards|input|field|dropdown|menu|list)\b/gi;
-const BREADTH_STATE = /\b(overdue|sold out|resolved|streak|late|red|amber|green|dims|highlight\w*|pinned|large|big|biggest|newest|empty|disabled|colou?r|glow\w*|pulse\w*|flash\w*|turns|changes|pending|confirmed|done|active|fermenting|winning|leading|second|behind|waiting|missing|ahead|nearly|just|still|recently)\b/gi;
-const BREADTH_DEEP = /\b(undo|long[- ]press|press and hold|drag(s|ged|ging)? to reorder|reorder|inline edit|edit(s|ed)? inline|in place|filter chips?|swipe)\b/gi;
-function breadthNorm(w) {
-    const l = w.toLowerCase();
-    return l.length > 4 ? l.replace(/(es|s)$/, "") : l;
-}
-function distinctTerms(re, text) {
-    return new Set([...text.matchAll(re)].map((m) => breadthNorm(m[0]))).size;
-}
-export function mercuryBreadth(o) {
-    const t = o.screens ?? [o.opening, o.seed ?? "", o.access ?? ""].filter((p) => p.length > 0).join(" ");
-    return distinctTerms(BREADTH_CTRL, t) + distinctTerms(BREADTH_STATE, t) + 2 * distinctTerms(BREADTH_DEEP, t);
-}
-function freshGated() {
-    return {
-        texts: new Map(),
-        misses: new Set(),
-        addressRepair: new Set(),
-        softMisses: new Map(),
-        coerced: new Set(),
-        fieldsDropped: new Set(),
-    };
-}
-function gatedCount(g) {
-    return MERCURY_BRIEF_FIELDS.length - owedBriefFields(g).length;
-}
 function billedTotals(usage, aborted) {
     const sum = (f) => usage.reduce((n, u) => n + f(u), 0);
     const scale = usage.length === 0 ? 0 : (usage.length + aborted) / usage.length;
@@ -2617,437 +1107,28 @@ function billedTotals(usage, aborted) {
         estimated: usage.length === 0 ? 0 : aborted,
     };
 }
-async function mercuryBriefCall(vctx, o) {
-    const startedAt = Date.now();
-    const cancel = new AbortController();
-    const drafts = Array.from({ length: o.fanout }, (_, index) => ({
-        index,
-        words: index === 0 || o.words.length === 0 ? o.words : o.wordBag(o.words.length),
-        gated: freshGated(),
-        log: mercurySendLog(),
-        totals: { usage: [] },
-        valid: false,
-        aborted: false,
-    }));
-    const roomsOwed = (g) => o.askRooms && g.rooms === undefined;
-    const fontOwed = (g) => o.askRooms && g.font === undefined;
-    const screensOwed = (g) => o.depth === "sub-feature" && g.screens === undefined;
-    const storyOwed = (g) => o.reply === "whole" && g.story === undefined;
-    const preambleOwed = (g) => o.reply === "whole" && g.preamble === undefined;
-    const recordsOwed = (g) => o.recordsRules && (g.records === undefined || g.rules === undefined);
-    const request = (g, words, draft) => () => {
-        const owed = owedBriefFields(g);
-        const rooms = roomsOwed(g);
-        const font = fontOwed(g);
-        const screens = screensOwed(g);
-        const story = storyOwed(g);
-        const preamble = preambleOwed(g);
-        const records = recordsOwed(g);
-        const shape = g.shape ?? o.shape;
-        const opts = {
-            personWords: o.personWords,
-            fields: owed,
-            words,
-            style: o.style,
-            rooms,
-            font,
-            ...(o.juice === "examples" ? {} : { juice: o.juice }),
-            ...(o.depth === "none" ? {} : { depth: o.depth }),
-            screens,
-            ...(o.reply === "split" ? {} : { reply: o.reply, story, preamble }),
-            ...(o.recordsRules ? { recordsRules: true, recordsOwed: records } : {}),
-        };
-        return {
-            schema: mercuryBriefSchema(owed, {
-                rooms,
-                font,
-                ...(screens ? { screens } : {}),
-                ...(records ? { recordsRules: true } : {}),
-                ...(story ? { story } : {}),
-                ...(preamble ? { preamble } : {}),
-                ...(shape === undefined ? { classify: true } : {}),
-            }),
-            messages: shape === undefined ? mercuryOneCallBriefMessages({ ...opts, draft }) : mercuryBriefMessages({ ...opts, shape }),
-        };
-    };
-    const gate = (json, g) => {
-        if (g.shape === undefined && o.shape === undefined) {
-            const parsed = parseMercuryDraftShape(json, o.personWords);
-            if (parsed.isErr())
-                return [`classification:${parsed.Err().message}`];
-            g.shape = parsed.Ok();
-        }
-        const shape = g.shape ?? o.shape;
-        if (shape === undefined)
-            return ["classification:missing"];
-        return acceptBriefFields(json, {
-            owed: owedBriefFields(g),
-            shape,
-            into: g,
-            roomsOwed: roomsOwed(g),
-            fontOwed: fontOwed(g),
-            screensOwed: screensOwed(g),
-            storyOwed: storyOwed(g),
-            preambleOwed: preambleOwed(g),
-            recordsOwed: recordsOwed(g),
-        });
-    };
-    const maxTokens = o.planner === "opus"
-        ? MERCURY_OPUS_PLANNER_MAX_TOKENS
-        : (o.reply === "whole" ? 2400 : 1600) + (o.shape === undefined ? MERCURY_ONECALL_EXTRA_TOKENS : 0);
-    const attempt = {
-        call: "brief",
-        deadlineMs: o.deadlineMs,
-        budget: o.budget,
-        maxTokens,
-        ...(o.planner === "opus" ? { model: plannerModel("opus") } : {}),
-    };
-    let winner;
-    let winnerMs;
-    const candidates = [];
-    let pickTimer;
-    let pickWaitMs;
-    let partner;
-    let duoConflict;
-    const pickCount = o.duo ? o.duoPool : MERCURY_PICK_COUNT;
-    const pickReserveMs = o.reply === "whole" ? 0 : MERCURY_MIN_ATTEMPT_MS;
-    let won = () => undefined;
-    const firstValid = new Promise((resolve) => {
-        won = resolve;
-    });
-    const pick = () => {
-        if (winner !== undefined || candidates.length === 0)
-            return;
-        if (pickTimer !== undefined)
-            clearTimeout(pickTimer);
-        const ranked = [...candidates].sort((a, b) => a.softMisses - b.softMisses || b.breadth - a.breadth);
-        winner = ranked[0].draft;
-        if (o.duo && ranked.length > 1) {
-            const second = ranked[1].draft;
-            const shapeA = winner.gated.shape ?? o.shape;
-            const shapeB = second.gated.shape ?? o.shape;
-            duoConflict =
-                o.recordsRules && shapeA !== undefined && shapeB !== undefined
-                    ? mercuryDuoConflict({ shape: shapeA, access: winner.gated.texts.get("access") ?? "" }, { shape: shapeB, access: second.gated.texts.get("access") ?? "" }, o.personWords)
-                    : undefined;
-            if (duoConflict === undefined)
-                partner = { draft: second, breadth: ranked[1].breadth };
-        }
-        winnerMs = Date.now() - startedAt;
-        for (const s of drafts)
-            if (s.ended === undefined && s.log.inFlight === true)
-                s.aborted = true;
-        cancel.abort();
-        won();
-    };
-    const everyDraft = Promise.allSettled(drafts.map(async function runDraft(d) {
-        const label = `draft ${d.index}: `;
-        const a = await mercuryAttempt(vctx, { ...attempt, request: request(d.gated, d.words, d.index), cancel: cancel.signal, label, transientRetries: 0 }, d.log);
-        if (winner !== undefined)
-            return;
-        d.ended = a.kind;
-        if (a.kind === "cancelled" && a.inFlight)
-            d.aborted = true;
-        if (a.kind !== "reply")
-            return;
-        absorbReply(d.totals, a.reply);
-        d.text = a.reply.text;
-        const failed = gate(a.reply.json, d.gated);
-        if (failed.length === 0) {
-            d.valid = true;
-            const breadth = mercuryBreadth({
-                ...(d.gated.screens?.screens === undefined ? {} : { screens: d.gated.screens.screens }),
-                opening: d.gated.texts.get("opening") ?? "",
-                seed: d.gated.texts.get("seed") ?? "",
-                access: d.gated.texts.get("access") ?? "",
-            });
-            candidates.push({ draft: d, breadth, softMisses: softMissCount(d.gated), ms: Date.now() - startedAt });
-            if (candidates.length >= pickCount)
-                pick();
-            else if (candidates.length === 1) {
-                const blind = !o.duo && candidates[0].breadth === 0 && candidates[0].softMisses === 0;
-                pickWaitMs = blind ? 0 : Math.max(0, Math.min(MERCURY_PICK_WAIT_MS, o.budget.remainingMs() - pickReserveMs));
-                if (pickWaitMs === 0)
-                    pick();
-                else
-                    pickTimer = setTimeout(pick, pickWaitMs);
-            }
-            return;
-        }
-        d.log.lastError = `mercury brief: gate ${failed.join(", ")}`;
-        d.log.cause = "gate";
-        noteSend(d.log, label);
-    }));
-    await Promise.race([firstValid, everyDraft]);
-    pick();
-    const totals = { usage: drafts.flatMap((d) => d.totals.usage) };
-    for (const d of drafts) {
-        if (d.totals.servedModel !== undefined)
-            totals.servedModel = d.totals.servedModel;
-        if (d.totals.reasoningTokens !== undefined)
-            totals.reasoningTokens = (totals.reasoningTokens ?? 0) + d.totals.reasoningTokens;
-    }
-    const log = {
-        ...mercurySendLog(),
-        sends: drafts.reduce((n, d) => n + d.log.sends, 0),
-        retries: drafts.reduce((n, d) => n + d.log.retries, 0),
-        history: drafts.flatMap((d) => d.log.history),
-    };
-    const chosen = winner ?? drafts.reduce((best, d) => (gatedCount(d.gated) > gatedCount(best.gated) ? d : best), drafts[0]);
-    log.cause = chosen.log.cause;
-    log.lastError = chosen.log.lastError;
-    const draftUsage = totals.usage.length;
-    let attempts = drafts.some((d) => d.ended === "reply" || d.ended === "failed") ? 1 : 0;
-    let ok = winner !== undefined;
-    let text = winner?.text;
-    let partialText;
-    const throttled = drafts.filter((d) => d.ended === "failed" && (d.log.cause === "rate-limited" || d.log.cause === "upstream-error")).length;
-    let throttleStop = false;
-    if (ok === false && throttled === o.fanout) {
-        const retryAfters = drafts.flatMap((d) => (d.log.retryAfterMs === undefined ? [] : [d.log.retryAfterMs]));
-        const wait = retryAfters.length > 0 ? Math.max(...retryAfters) : (mercuryRetryWaitMs(1, undefined) ?? 0);
-        if (wait > o.budget.remainingMs() - MERCURY_MIN_ATTEMPT_MS) {
-            throttleStop = true;
-            log.lastError = `${chosen.log.lastError} (retry-after ${wait}ms; falling back inside the stage budget)`;
-        }
-        else {
-            await waitMs(wait);
-            log.retries += 1;
-        }
-    }
-    if (ok === false && attempts === 1 && throttleStop === false) {
-        const reask = mercurySendLog();
-        reask.cause = chosen.log.cause;
-        reask.lastError = chosen.log.lastError;
-        reask.carried = true;
-        const a = await mercuryAttempt(vctx, { ...attempt, request: request(chosen.gated, chosen.words, chosen.index) }, reask);
-        log.sends += reask.sends;
-        log.retries += reask.retries;
-        log.history.push(...reask.history);
-        log.cause = reask.cause;
-        log.lastError = reask.lastError;
-        if (a.kind === "reply" || a.kind === "failed")
-            attempts += 1;
-        if (a.kind === "reply") {
-            absorbReply(totals, a.reply);
-            const failed = gate(a.reply.json, chosen.gated);
-            if (failed.length === 0) {
-                ok = true;
-                text = a.reply.text;
-                partialText = chosen.text;
-            }
-            else {
-                log.lastError = `mercury brief: gate ${failed.join(", ")}`;
-                log.cause = "gate";
-                noteSend(log);
-            }
-        }
-    }
-    const aborted = drafts.filter((d) => d.aborted).length;
-    const pickCandidates = candidates.map((c) => ({
-        draft: c.draft.index,
-        breadth: c.breadth,
-        softMisses: c.softMisses,
-        ms: c.ms,
-        ...(c.draft.gated.shape === undefined ? {} : { archetype: c.draft.gated.shape.archetype }),
-    }));
-    const billedDrafts = billedTotals(totals.usage.slice(0, draftUsage), aborted);
-    const reaskUsage = totals.usage.slice(draftUsage);
-    const fanout = {
-        drafts: drafts.filter((d) => d.log.sends > 0).length,
-        valid: drafts.filter((d) => d.valid).length,
-        ...(winner === undefined ? {} : { winner: winner.index }),
-        ...(winnerMs === undefined ? {} : { winnerMs }),
-        ...(winner === undefined
-            ? {}
-            : {
-                picked: winner.index,
-                candidates: pickCandidates,
-                ...(pickWaitMs === undefined ? {} : { pickWaitMs }),
-            }),
-        aborted,
-        ...(throttled === 0 ? {} : { throttled }),
-        billed: reaskUsage.length === 0
-            ? billedDrafts
-            : {
-                ...billedDrafts,
-                prompt_tokens: billedDrafts.prompt_tokens + reaskUsage.reduce((n, u) => n + u.prompt_tokens, 0),
-                completion_tokens: billedDrafts.completion_tokens + reaskUsage.reduce((n, u) => n + u.completion_tokens, 0),
-                total_tokens: billedDrafts.total_tokens + reaskUsage.reduce((n, u) => n + u.total_tokens, 0),
-                ...(billedDrafts.cost === undefined && reaskUsage.every((u) => u.cost === undefined)
-                    ? {}
-                    : { cost: (billedDrafts.cost ?? 0) + reaskUsage.reduce((n, u) => n + (u.cost ?? 0), 0) }),
-            },
-    };
-    const g = chosen.gated;
-    const pickedBreadth = candidates.find((c) => c.draft === winner)?.breadth;
-    const pair = winner === undefined ? [] : [winner, ...(partner === undefined ? [] : [partner.draft])];
-    const pairArchetypes = pair.flatMap((d) => (d.gated.shape === undefined ? [] : [d.gated.shape.archetype]));
-    const duo = o.duo && winner !== undefined && pickedBreadth !== undefined
-        ? {
-            drafts: pair.map((d) => d.index),
-            breadth: [pickedBreadth, ...(partner === undefined ? [] : [partner.breadth])],
-            ...(o.shape === undefined
-                ? {
-                    pool: o.duoPool,
-                    candidates: pickCandidates,
-                    archetypes: pairArchetypes,
-                    archetypeSplit: new Set(pairArchetypes).size > 1,
-                }
-                : {}),
-            ...(duoConflict === undefined ? {} : { conflict: duoConflict }),
-        }
-        : undefined;
-    const backendWorded = mercuryBackendWordsNamed(o.personWords);
-    const backendCleared = backendWorded
-        ? []
-        : drafts.filter((d) => d !== chosen && d.gated.shape?.flags.backend === true).map((d) => d.index);
-    const oneCall = o.shape === undefined
-        ? {
-            draftArchetypes: drafts.map((d) => d.gated.shape?.archetype ?? null),
-            archetypeSplit: new Set(drafts.flatMap((d) => (d.gated.shape === undefined ? [] : [d.gated.shape.archetype]))).size > 1,
-            flagsWinner: g.shape === undefined ? [] : setFlags(g.shape.flags),
-            flagsUnion: MERCURY_FLAGS.filter((f) => drafts.some((d) => d.gated.shape?.flags[f] === true && (f !== "backend" || backendWorded || d === chosen))),
-            ...(backendCleared.length === 0 ? {} : { backendFilterCleared: backendCleared }),
-            ...(backendWorded || g.shape?.flags.backend !== true ? {} : { backendFilterKept: chosen.index }),
-        }
-        : undefined;
-    const extra = {
-        passedThrough: [...g.misses],
-        addressRepair: [...g.addressRepair],
-        ...(g.pairs === undefined ? {} : { slugsWithWord: mercurySlugsWithWord(g.pairs, chosen.words) }),
-        ...(g.rooms === undefined ? {} : { roomsDropped: g.rooms.dropped }),
-        ...(g.font === undefined ? {} : { fontDropped: g.font.dropped }),
-        ...(g.screens === undefined ? {} : { screensDropped: g.screens.dropped }),
-        fanout,
-        juice: o.juice,
-        depth: o.depth,
-        ...(o.reply === "split"
-            ? {}
-            : {
-                reply: o.reply,
-                preambleFrom: "brief",
-                storyChars: g.story?.story === undefined ? 0 : cleanMercuryText(g.story.story).length,
-                storyDropped: g.story?.dropped ?? 0,
-                ...(g.preamble === undefined ? {} : { preambleChars: g.preamble.length }),
-            }),
-        ...(duo === undefined ? {} : { duo: true, duoDrafts: duo.drafts, duoBreadth: duo.breadth }),
-        ...(duo?.pool === undefined ? {} : { duoPool: duo.pool }),
-        ...(duo?.archetypes === undefined ? {} : { duoArchetypes: duo.archetypes }),
-        ...(duo?.conflict === undefined ? {} : { duoConflict: true, duoConflictReason: duo.conflict }),
-        ...(o.recordsRules
-            ? {
-                recordsRules: true,
-                ...(g.records === undefined ? {} : { recordsDropped: g.records.dropped }),
-                ...(g.rules === undefined ? {} : { rulesDropped: g.rules.dropped }),
-            }
-            : {}),
-        ...(oneCall === undefined ? {} : { oneCall: true, shapeCall: false, ...oneCall }),
-        ...(g.softMisses.size === 0 ? {} : { softMisses: Object.fromEntries(g.softMisses) }),
-        ...(g.coerced.size === 0 ? {} : { coerced: [...g.coerced] }),
-        ...(g.fieldsDropped.size === 0 ? {} : { fieldsDropped: [...g.fieldsDropped] }),
-        ...(o.reply === "whole" && g.preamble === undefined ? { preambleFallback: 1 } : {}),
-        ...(o.planner === "opus" ? { planner: "opus" } : {}),
-        ...(text === undefined ? {} : { text }),
-        ...(partialText === undefined ? {} : { partialText }),
-        ...(duo === undefined ? {} : { duoTexts: pair.flatMap((d) => (d.text === undefined ? [] : [d.text])) }),
-    };
-    const call = { call: "brief", row: o.row, attempts, startedAt, totals, log, extra };
-    if (ok === false)
-        return failCall(vctx, call);
-    o.onCounts(log.sends, log.retries);
-    await recordMercuryRow(vctx, { ...o.row, record: callRecord({ ...call, ok: true }) });
-    return Result.Ok({
-        gated: g,
-        words: chosen.words,
-        ...(partner === undefined || winner === undefined ? {} : { partner: partner.draft.gated }),
-        ...(duo === undefined ? {} : { duo }),
-        ...(oneCall === undefined ? {} : { oneCall }),
-    });
-}
-export const MERCURY_PROSE_MAX_TOKENS = 3200;
-async function mercuryProseBriefCall(vctx, o) {
-    return mercuryFirstValidCall(vctx, {
-        ...o,
-        maxTokens: MERCURY_PROSE_MAX_TOKENS,
-        request: (words) => ({
-            schema: mercuryProseBriefSchema({ rooms: o.askRooms, font: o.askRooms }),
-            messages: mercuryProseBriefMessages({ personWords: o.personWords, words, rooms: o.askRooms, font: o.askRooms }),
-        }),
-        gate: (json) => gateMercuryProseDraft(json, { personWords: o.personWords, askRooms: o.askRooms }),
-        extra: () => ({ format: "prose" }),
-    });
-}
-export const MERCURY_THINKALOUD_MAX_TOKENS = 16_000;
-export const MERCURY_THINKALOUD_DEADLINE_MS = 20_000;
-export const MERCURY_THINKALOUD_BUDGET_MS = 25_000;
-async function mercuryThinkAloudBriefCall(vctx, o) {
-    return mercuryFirstValidCall(vctx, {
-        ...o,
-        persistent: true,
-        maxTokens: MERCURY_THINKALOUD_MAX_TOKENS,
-        request: (words) => ({
-            messages: mercuryThinkAloudMessages({ personWords: o.personWords, words, rooms: o.askRooms, font: o.askRooms }),
-        }),
-        gate: (raw) => gateMercuryThinkAloud(raw, { personWords: o.personWords, askRooms: o.askRooms }),
-        extra: (d) => ({
-            format: "thinkaloud",
-            ...(d === undefined
-                ? {}
-                : {
-                    ...(Object.keys(d.softMisses).length === 0 ? {} : { softMisses: d.softMisses }),
-                    thinkAloud: { narrationChars: d.narration.length, specChars: d.spec.length, guessLines: d.guessLines },
-                }),
-        }),
-    });
-}
+export const MERCURY_CARDS_MAX_TOKENS = 16_000;
 async function mercuryCardsBriefCall(vctx, o) {
-    return mercuryFirstValidCall(vctx, {
-        ...o,
-        persistent: true,
-        maxTokens: MERCURY_THINKALOUD_MAX_TOKENS,
-        request: (words) => ({
-            messages: mercuryCardsMessages({ personWords: o.personWords, words, rooms: o.askRooms, font: o.askRooms }),
-        }),
-        gate: (raw) => gateMercuryCards(raw, { personWords: o.personWords, askRooms: o.askRooms }),
-        extra: (d) => ({
-            format: o.format,
-            ...(o.planner === "mercury" ? {} : { planner: o.planner }),
-            ...(d === undefined
-                ? {}
-                : {
-                    ...(Object.keys(d.softMisses).length === 0 ? {} : { softMisses: d.softMisses }),
-                    cards: {
-                        preambleChars: d.parsed.preamble.length,
-                        cards: d.parsed.cardLines.length,
-                        acceptLines: d.parsed.acceptLines,
-                        ruleLines: d.parsed.ruleLines,
-                        guessLines: d.parsed.guessLines,
-                        dataRecords: d.parsed.dataRecords.length,
-                    },
-                }),
-        }),
-    });
-}
-async function mercuryFirstValidCall(vctx, o) {
     const startedAt = Date.now();
     const cancel = new AbortController();
-    const drafts = Array.from({ length: o.persistent === true ? MERCURY_TESTER_FANOUT : MERCURY_BRIEF_FANOUT }, (_, index) => ({
+    const briefs = Array.from({ length: MERCURY_TESTER_FANOUT }, (_, index) => ({
         index,
         words: index === 0 || o.words.length === 0 ? o.words : o.wordBag(o.words.length),
         log: mercurySendLog(),
         totals: { usage: [] },
         aborted: false,
     }));
-    const request = (words) => () => o.request(words);
-    const gate = o.gate;
+    const request = (words) => () => ({
+        messages: mercuryCardsMessages({ personWords: o.personWords, words, rooms: o.askRooms, font: o.askRooms }),
+    });
+    const gate = (raw) => gateMercuryCards(raw, { personWords: o.personWords, askRooms: o.askRooms });
     const attempt = {
         call: "brief",
         deadlineMs: o.deadlineMs,
         budget: o.budget,
-        maxTokens: o.maxTokens,
-        ...(o.planner === undefined || o.planner === "mercury" ? {} : { model: plannerModel(o.planner) }),
-        ...(o.persistent === true ? { persistent: true } : {}),
+        maxTokens: MERCURY_CARDS_MAX_TOKENS,
+        ...(o.planner === "mercury" ? {} : { model: plannerModel(o.planner) }),
+        persistent: true,
     };
     let winner;
     let valid = 0;
@@ -3055,15 +1136,9 @@ async function mercuryFirstValidCall(vctx, o) {
     const firstValid = new Promise((resolve) => {
         won = resolve;
     });
-    const everyDraft = Promise.allSettled(drafts.map(async function runDraft(d) {
-        const label = `draft ${d.index}: `;
-        const a = await mercuryAttempt(vctx, {
-            ...attempt,
-            request: request(d.words),
-            cancel: cancel.signal,
-            label,
-            ...(o.persistent === true ? {} : { transientRetries: 0 }),
-        }, d.log);
+    async function runBrief(d, once = false) {
+        const label = `brief ${d.index}: `;
+        const a = await mercuryAttempt(vctx, { ...attempt, request: request(d.words), cancel: cancel.signal, label, persistent: once === false }, d.log);
         if (winner !== undefined)
             return;
         d.ended = a.kind;
@@ -3072,11 +1147,11 @@ async function mercuryFirstValidCall(vctx, o) {
         if (a.kind !== "reply")
             return;
         absorbReply(d.totals, a.reply);
-        const g = gate(a.reply.json);
+        const g = gate(a.reply.text);
         if (g.isOk()) {
             valid += 1;
-            winner = { from: d, draft: g.Ok(), ms: Date.now() - startedAt, text: a.reply.text };
-            for (const s of drafts)
+            winner = { from: d, brief: g.Ok(), ms: Date.now() - startedAt, text: a.reply.text };
+            for (const s of briefs)
                 if (s.ended === undefined && s.log.inFlight === true)
                     s.aborted = true;
             cancel.abort();
@@ -3086,33 +1161,65 @@ async function mercuryFirstValidCall(vctx, o) {
         d.log.lastError = `mercury brief: gate ${g.Err().message}`;
         d.log.cause = "gate";
         noteSend(d.log, label);
-    }));
-    await Promise.race([firstValid, everyDraft]);
-    const totals = { usage: drafts.flatMap((d) => d.totals.usage) };
-    for (const d of drafts) {
+    }
+    let hedgedMs;
+    const firstEnded = new AbortController();
+    async function hedgeWhenHung() {
+        if (o.hedgeAfterMs === undefined)
+            return;
+        const first = briefs[0];
+        await waitOrCancel(o.hedgeAfterMs, eitherSignal(eitherSignal(cancel.signal, o.budget.cancel), firstEnded.signal));
+        if (winner !== undefined || isCancelled(cancel.signal) || o.budget.cancel?.aborted === true)
+            return;
+        if (first.ended !== undefined || first.log.inFlight !== true || first.log.sends !== 1)
+            return;
+        if (o.budget.remainingMs() < MERCURY_MIN_ATTEMPT_MS)
+            return;
+        const hedge = {
+            index: briefs.length,
+            words: o.words.length === 0 ? o.words : o.wordBag(o.words.length),
+            log: mercurySendLog(),
+            totals: { usage: [] },
+            aborted: false,
+        };
+        briefs.push(hedge);
+        hedgedMs = Date.now() - startedAt;
+        await runBrief(hedge, true);
+    }
+    const everyBrief = Promise.allSettled([
+        ...briefs.map(async (d) => {
+            await runBrief(d);
+            if (d.index === 0)
+                firstEnded.abort();
+        }),
+        hedgeWhenHung(),
+    ]);
+    await Promise.race([firstValid, everyBrief]);
+    const totals = { usage: briefs.flatMap((d) => d.totals.usage) };
+    for (const d of briefs) {
         if (d.totals.servedModel !== undefined)
             totals.servedModel = d.totals.servedModel;
         if (d.totals.reasoningTokens !== undefined)
             totals.reasoningTokens = (totals.reasoningTokens ?? 0) + d.totals.reasoningTokens;
     }
-    const last = drafts.find((d) => d.ended === "reply") ?? drafts[0];
+    const last = briefs.find((d) => d.ended === "reply") ?? briefs[0];
     const log = {
         ...mercurySendLog(),
-        sends: drafts.reduce((n, d) => n + d.log.sends, 0),
-        retries: drafts.reduce((n, d) => n + d.log.retries, 0),
-        history: drafts.flatMap((d) => d.log.history),
+        sends: briefs.reduce((n, d) => n + d.log.sends, 0),
+        retries: briefs.reduce((n, d) => n + d.log.retries, 0),
+        history: briefs.flatMap((d) => d.log.history),
         cause: last.log.cause,
         lastError: last.log.lastError,
     };
-    const draftUsage = totals.usage.length;
-    let attempts = drafts.some((d) => d.ended === "reply" || d.ended === "failed") ? 1 : 0;
+    const briefUsage = totals.usage.length;
+    let attempts = briefs.some((d) => d.ended === "reply" || d.ended === "failed") ? 1 : 0;
     let chosen = winner;
     if (chosen === undefined && attempts === 1) {
         const reask = mercurySendLog();
         reask.cause = log.cause;
         reask.lastError = log.lastError;
         reask.carried = true;
-        const a = await mercuryAttempt(vctx, { ...attempt, request: request(drafts[0].words) }, reask);
+        const a = await mercuryAttempt(vctx, { ...attempt, request: request(briefs[0].words) }, reask);
         log.sends += reask.sends;
         log.retries += reask.retries;
         log.history.push(...reask.history);
@@ -3122,10 +1229,10 @@ async function mercuryFirstValidCall(vctx, o) {
             attempts += 1;
         if (a.kind === "reply") {
             absorbReply(totals, a.reply);
-            const g = gate(a.reply.json);
+            const g = gate(a.reply.text);
             if (g.isOk()) {
                 valid += 1;
-                chosen = { from: drafts[0], draft: g.Ok(), ms: Date.now() - startedAt, text: a.reply.text };
+                chosen = { from: briefs[0], brief: g.Ok(), ms: Date.now() - startedAt, text: a.reply.text };
             }
             else {
                 log.lastError = `mercury brief: gate ${g.Err().message}`;
@@ -3134,37 +1241,44 @@ async function mercuryFirstValidCall(vctx, o) {
             }
         }
     }
-    const aborted = drafts.filter((d) => d.aborted).length;
-    const billedDrafts = billedTotals(totals.usage.slice(0, draftUsage), aborted);
-    const reaskUsage = totals.usage.slice(draftUsage);
+    const aborted = briefs.filter((d) => d.aborted).length;
+    const billedBriefs = billedTotals(totals.usage.slice(0, briefUsage), aborted);
+    const reaskUsage = totals.usage.slice(briefUsage);
     const fanout = {
-        drafts: drafts.filter((d) => d.log.sends > 0).length,
+        briefs: briefs.filter((d) => d.log.sends > 0).length,
         valid,
         ...(winner === undefined ? {} : { winner: winner.from.index, winnerMs: winner.ms, picked: winner.from.index }),
         aborted,
+        ...(hedgedMs === undefined ? {} : { hedgedMs }),
         billed: reaskUsage.length === 0
-            ? billedDrafts
+            ? billedBriefs
             : {
-                ...billedDrafts,
-                prompt_tokens: billedDrafts.prompt_tokens + reaskUsage.reduce((n, u) => n + u.prompt_tokens, 0),
-                completion_tokens: billedDrafts.completion_tokens + reaskUsage.reduce((n, u) => n + u.completion_tokens, 0),
-                total_tokens: billedDrafts.total_tokens + reaskUsage.reduce((n, u) => n + u.total_tokens, 0),
-                ...(billedDrafts.cost === undefined && reaskUsage.every((u) => u.cost === undefined)
+                ...billedBriefs,
+                prompt_tokens: billedBriefs.prompt_tokens + reaskUsage.reduce((n, u) => n + u.prompt_tokens, 0),
+                completion_tokens: billedBriefs.completion_tokens + reaskUsage.reduce((n, u) => n + u.completion_tokens, 0),
+                total_tokens: billedBriefs.total_tokens + reaskUsage.reduce((n, u) => n + u.total_tokens, 0),
+                ...(billedBriefs.cost === undefined && reaskUsage.every((u) => u.cost === undefined)
                     ? {}
-                    : { cost: (billedDrafts.cost ?? 0) + reaskUsage.reduce((n, u) => n + (u.cost ?? 0), 0) }),
+                    : { cost: (billedBriefs.cost ?? 0) + reaskUsage.reduce((n, u) => n + (u.cost ?? 0), 0) }),
             },
     };
-    const c = chosen?.draft;
+    const c = chosen?.brief;
     const extra = {
-        ...o.extra(c),
+        format: o.format,
+        ...(o.planner === "mercury" ? {} : { planner: o.planner }),
         fanout,
-        reply: "whole",
-        preambleFrom: "classification",
-        oneCall: true,
-        shapeCall: false,
         ...(c === undefined
             ? {}
             : {
+                ...(Object.keys(c.softMisses).length === 0 ? {} : { softMisses: c.softMisses }),
+                cards: {
+                    preambleChars: c.parsed.preamble.length,
+                    cards: c.parsed.cardLines.length,
+                    acceptLines: c.parsed.acceptLines,
+                    ruleLines: c.parsed.ruleLines,
+                    guessLines: c.parsed.guessLines,
+                    dataRecords: c.parsed.dataRecords.length,
+                },
                 addressRepair: [...c.addressRepair],
                 slugsWithWord: mercurySlugsWithWord(c.address.pairs, chosen?.from.words ?? []),
                 ...(c.rooms === undefined ? {} : { roomsDropped: c.rooms.dropped }),
@@ -3178,16 +1292,11 @@ async function mercuryFirstValidCall(vctx, o) {
         return failCall(vctx, call);
     o.onCounts(log.sends, log.retries);
     await recordMercuryRow(vctx, { ...o.row, record: callRecord({ ...call, ok: true }) });
-    return Result.Ok({ draft: chosen.draft, words: chosen.from.words });
+    return Result.Ok({ brief: chosen.brief, words: chosen.from.words });
 }
 export async function runMercuryFirstBuild(vctx, args) {
     const startedAt = Date.now();
-    const breaker = args.breaker ??
-        (args.planner === "opus"
-            ? MERCURY_OPUS_PLANNER_BREAKER
-            : args.planner === "haiku"
-                ? MERCURY_HAIKU_PLANNER_BREAKER
-                : MERCURY_BREAKER);
+    const breaker = args.breaker ?? (args.planner === "haiku" ? MERCURY_HAIKU_PLANNER_BREAKER : MERCURY_BREAKER);
     const stage = { sends: 0, retries: 0 };
     if (args.personWords.trim().length === 0)
         return stageErr("mercury: no words to brief from", "error", stage, startedAt);
@@ -3216,9 +1325,8 @@ export async function runMercuryFirstBuild(vctx, args) {
     }
     return out;
 }
-function stageErr(message, cause, stage, startedAt, call) {
+function stageErr(message, cause, stage, startedAt) {
     return Result.Err(new MercuryStageError(message, cause, {
-        ...(call === undefined ? {} : { call }),
         sends: stage.sends,
         retries: stage.retries,
         elapsedMs: Date.now() - startedAt,
@@ -3239,277 +1347,72 @@ async function pipeline(vctx, args, stage) {
         },
     };
     const named = () => (keepText && lastRow !== undefined ? { rowPromptId: lastRow } : {});
-    const opus = args.planner === "opus";
-    const haiku = args.planner === "haiku";
-    const thinkAloud = args.format === "thinkaloud";
-    const cards = args.format === "cards" || args.format === "cards-fim";
-    const freeText = thinkAloud || cards;
-    const deadlineMs = args.deadlineMs ??
-        (opus ? MERCURY_OPUS_PLANNER_DEADLINE_MS : haiku || freeText ? MERCURY_TESTER_REQUEST_DEADLINE_MS : MERCURY_CALL_DEADLINE_MS);
-    const budget = mercuryBudget(args.budgetMs ??
-        (opus ? MERCURY_OPUS_PLANNER_BUDGET_MS : haiku || freeText ? MERCURY_TESTER_STAGE_BUDGET_MS : MERCURY_STAGE_BUDGET_MS), Date.now, args.rateLimitedBudgetMs, args.signal);
-    const wordBag = args.wordBag ?? slugWordBag;
-    const style = args.style ?? "base";
-    const askRooms = args.rooms === true;
-    const reply = args.reply ?? "split";
-    const recordsRules = reply === "whole" && args.recordsRules === true;
-    function tally(r) {
-        if (r.isOk())
-            return r;
-        const e = r.Err();
+    const planner = args.planner ?? "mercury";
+    const format = args.format;
+    const budget = mercuryBudget(args.budgetMs ?? MERCURY_TESTER_STAGE_BUDGET_MS, Date.now, args.signal);
+    const rCards = await mercuryCardsBriefCall(vctx, {
+        row,
+        deadlineMs: args.deadlineMs ?? MERCURY_TESTER_REQUEST_DEADLINE_MS,
+        budget,
+        personWords: args.personWords,
+        askRooms: args.rooms === true,
+        words: args.words,
+        wordBag: args.wordBag ?? slugWordBag,
+        onCounts: (sends, retries) => {
+            stage.sends += sends;
+            stage.retries += retries;
+        },
+        ...(args.hedgeAfterMs === undefined ? {} : { hedgeAfterMs: args.hedgeAfterMs }),
+        format,
+        planner,
+    });
+    if (rCards.isErr()) {
+        const e = rCards.Err();
         stage.sends += e.detail.sends;
         stage.retries += e.detail.retries;
-        const rateLimitCapMs = budget.rateLimitCapMs();
         return Result.Err(new MercuryStageError(e.message, e.fallbackCause, {
             ...(e.detail.call === undefined ? {} : { call: e.detail.call }),
             sends: stage.sends,
             retries: stage.retries,
             elapsedMs: Date.now() - startedAt,
-            ...(rateLimitCapMs === undefined ? {} : { rateLimitCapMs }),
-        }));
-    }
-    const counted = (sends, retries) => {
-        stage.sends += sends;
-        stage.retries += retries;
-    };
-    if (args.format === "prose") {
-        const rProse = tally(await mercuryProseBriefCall(vctx, {
-            row,
-            deadlineMs,
-            budget,
-            personWords: args.personWords,
-            askRooms,
-            words: args.words,
-            wordBag,
-            onCounts: counted,
         }));
-        if (rProse.isErr())
-            return Result.Err(rProse.Err());
-        const { draft } = rProse.Ok();
-        return Result.Ok({
-            input: assembleMercuryProseCreateVibe({ personWords: args.personWords, draft }),
-            preamble: mercuryProsePreamble(draft),
-            preambleFrom: "classification",
-            format: "prose",
-            shape: draft.shape,
-            elapsedMs: Date.now() - startedAt,
-            sends: stage.sends,
-            retries: stage.retries,
-            ...named(),
-        });
     }
-    if (thinkAloud) {
-        const rThink = tally(await mercuryThinkAloudBriefCall(vctx, {
-            row,
-            deadlineMs,
-            budget,
+    const { brief } = rCards.Ok();
+    let reply = brief.reply;
+    let fim;
+    if (format === "cards-fim") {
+        const filled = await mercuryCardsFim(vctx, {
+            brief,
             personWords: args.personWords,
-            askRooms,
-            words: args.words,
-            wordBag,
-            onCounts: counted,
-        }));
-        if (rThink.isErr())
-            return Result.Err(rThink.Err());
-        const { draft } = rThink.Ok();
-        return Result.Ok({
-            input: assembleMercuryThinkAloudCreateVibe({ personWords: args.personWords, draft }),
-            preamble: mercuryThinkAloudPreamble(draft),
-            preambleFrom: "classification",
-            format: "thinkaloud",
-            shape: draft.shape,
-            elapsedMs: Date.now() - startedAt,
-            sends: stage.sends,
-            retries: stage.retries,
-            ...named(),
+            ...(args.fimApiKey !== undefined
+                ? { apiKey: args.fimApiKey }
+                : vctx.inceptionApiKey === undefined
+                    ? {}
+                    : { apiKey: vctx.inceptionApiKey }),
+            ...(args.fimUrl === undefined ? {} : { url: args.fimUrl }),
+            ...(args.signal === undefined ? {} : { cancel: args.signal }),
         });
-    }
-    if (cards && (args.format === "cards" || args.format === "cards-fim")) {
-        const format = args.format;
-        const rCards = tally(await mercuryCardsBriefCall(vctx, {
-            row,
-            deadlineMs,
-            budget,
-            personWords: args.personWords,
-            askRooms,
-            words: args.words,
-            wordBag,
-            onCounts: counted,
-            format,
-            planner: args.planner ?? "mercury",
-        }));
-        if (rCards.isErr())
-            return Result.Err(rCards.Err());
-        const { draft } = rCards.Ok();
-        let reply = draft.reply;
-        let fim;
-        if (format === "cards-fim") {
-            const filled = await mercuryCardsFim(vctx, {
-                draft,
-                personWords: args.personWords,
-                ...(args.fimApiKey !== undefined
-                    ? { apiKey: args.fimApiKey }
-                    : vctx.inceptionApiKey === undefined
-                        ? {}
-                        : { apiKey: vctx.inceptionApiKey }),
-                ...(args.fimUrl === undefined ? {} : { url: args.fimUrl }),
-                ...(args.signal === undefined ? {} : { cancel: args.signal }),
+        reply = filled.reply;
+        fim = filled.receipt;
+        const fimRound = mercuryFimUsageRound(fim);
+        if (fimRound !== undefined)
+            args.onUsage?.([fimRound]);
+        if (lastRow !== undefined)
+            await recordMercuryFim(vctx, {
+                chatId: args.chatId,
+                promptId: lastRow,
+                fim,
+                ...(keepText && fim.filled > 0 ? { filledText: reply } : {}),
             });
-            reply = filled.reply;
-            fim = filled.receipt;
-            const fimRound = mercuryFimUsageRound(fim);
-            if (fimRound !== undefined)
-                args.onUsage?.([fimRound]);
-            if (lastRow !== undefined)
-                await recordMercuryFim(vctx, {
-                    chatId: args.chatId,
-                    promptId: lastRow,
-                    fim,
-                    ...(keepText && fim.filled > 0 ? { filledText: reply } : {}),
-                });
-        }
-        return Result.Ok({
-            input: assembleMercuryCardsCreateVibe({ personWords: args.personWords, draft, reply }),
-            preamble: mercuryCardsPreamble(draft, args.personWords),
-            preambleFrom: draft.parsed.preamble.length > 0 ? "brief" : "classification",
-            format,
-            ...(args.planner === undefined || args.planner === "mercury" ? {} : { planner: args.planner }),
-            ...(fim === undefined ? {} : { fim }),
-            shape: draft.shape,
-            elapsedMs: Date.now() - startedAt,
-            sends: stage.sends,
-            retries: stage.retries,
-            ...named(),
-        });
-    }
-    const oneCall = args.oneCall === true;
-    const callShape = async () => tally(await mercuryCall(vctx, {
-        call: "shape",
-        row,
-        deadlineMs,
-        budget,
-        maxTokens: MERCURY_SHAPE_MAX_TOKENS,
-        onCounts: counted,
-        request: () => ({
-            schema: mercuryShapeSchema(),
-            messages: mercuryShapeMessages({ personWords: args.personWords }),
-        }),
-        accept: (json) => {
-            const parsed = parseMercuryShape(json);
-            return parsed.isErr() ? parsed : Result.Ok(fixMercuryShape(parsed.Ok(), args.personWords));
-        },
-    }));
-    let called;
-    if (!oneCall) {
-        const rShape = await callShape();
-        if (rShape.isErr())
-            return Result.Err(rShape.Err());
-        called = rShape.Ok();
-    }
-    const rBrief = tally(await mercuryBriefCall(vctx, {
-        row,
-        deadlineMs,
-        budget,
-        personWords: args.personWords,
-        ...(called === undefined ? {} : { shape: called }),
-        style,
-        juice: args.juice ?? "examples",
-        depth: args.depth ?? "none",
-        reply,
-        duo: reply === "whole" && args.duo === true,
-        duoPool: args.duoPool ?? MERCURY_DUO_PICK_COUNT,
-        recordsRules,
-        askRooms,
-        words: args.words,
-        wordBag,
-        onCounts: counted,
-        fanout: opus ? MERCURY_OPUS_PLANNER_FANOUT : MERCURY_BRIEF_FANOUT,
-        planner: opus ? "opus" : "mercury",
-    }));
-    if (rBrief.isErr())
-        return Result.Err(rBrief.Err());
-    const { gated, partner, duo, oneCall: oneCallReceipt } = rBrief.Ok();
-    const shape = called ?? gated.shape;
-    if (shape === undefined)
-        return stageErr("mercury: no classification parsed", "gate", stage, startedAt, "brief");
-    const union = oneCallReceipt === undefined
-        ? undefined
-        : Object.fromEntries(MERCURY_FLAGS.map((f) => [f, oneCallReceipt.flagsUnion.includes(f)]));
-    const assembly = {
-        personWords: args.personWords,
-        shape,
-        ...(union === undefined ? {} : { capabilityFlags: union }),
-        fields: {
-            opening: gated.texts.get("opening") ?? "",
-            access: gated.texts.get("access") ?? "",
-            seed: gated.texts.get("seed") ?? "",
-            look: gated.texts.get("look") ?? "",
-            icon: gated.texts.get("icon") ?? "",
-            pairs: gated.pairs ?? [],
-        },
-        ...(gated.rooms?.rooms === undefined ? {} : { rooms: gated.rooms.rooms }),
-        ...(gated.font?.font === undefined ? {} : { font: gated.font.font }),
-        ...(gated.screens?.screens === undefined ? {} : { screens: gated.screens.screens }),
-        ...(reply === "split"
-            ? {}
-            : {
-                reply,
-                ...(gated.story?.story === undefined ? {} : { story: gated.story.story }),
-                ...(gated.preamble === undefined ? {} : { preamble: gated.preamble }),
-                ...(partner === undefined ? {} : { partner: takeOf(partner) }),
-                ...(recordsRules
-                    ? {
-                        recordsRules: true,
-                        ...(gated.records?.screens === undefined ? {} : { records: gated.records.screens }),
-                        ...(gated.rules?.screens === undefined ? {} : { rules: gated.rules.screens }),
-                    }
-                    : {}),
-            }),
-    };
-    const input = assembleMercuryCreateVibe(assembly);
-    if (reply === "whole") {
-        return Result.Ok({
-            input,
-            preamble: gated.preamble ?? cleanMercuryText(gated.texts.get("opening") ?? ""),
-            preambleFrom: "brief",
-            storyChars: gated.story?.story === undefined ? 0 : cleanMercuryText(gated.story.story).length,
-            ...(duo === undefined ? {} : { duo }),
-            ...(oneCallReceipt === undefined ? {} : { oneCall: oneCallReceipt }),
-            ...(opus ? { planner: "opus" } : {}),
-            shape,
-            elapsedMs: Date.now() - startedAt,
-            sends: stage.sends,
-            retries: stage.retries,
-            ...named(),
-        });
     }
-    const enrichedPrompt = mercuryPreambleBrief(assembly);
-    const rPreamble = tally(await mercuryCall(vctx, {
-        call: "preamble",
-        row,
-        deadlineMs,
-        budget,
-        maxTokens: 300,
-        onCounts: counted,
-        request: () => ({
-            schema: mercuryPreambleSchema(),
-            messages: mercuryPreambleMessages({ personWords: args.personWords, shape, enrichedPrompt, style }),
-        }),
-        accept: (json) => {
-            const p = preambleParsed(json);
-            if (p instanceof type.errors)
-                return Result.Err(p.summary);
-            const fails = gateMercuryPreamble({ text: p.preamble, enrichedPrompt });
-            return fails.length === 0 ? Result.Ok(cleanMercuryText(p.preamble)) : Result.Err(`gate ${fails.join("+")}`);
-        },
-    }));
-    if (rPreamble.isErr())
-        return Result.Err(rPreamble.Err());
     return Result.Ok({
-        input,
-        preamble: rPreamble.Ok(),
-        ...(oneCallReceipt === undefined ? {} : { oneCall: oneCallReceipt }),
-        shape,
+        input: assembleMercuryCardsCreateVibe({ personWords: args.personWords, brief, reply }),
+        preamble: mercuryCardsPreamble(brief, args.personWords),
+        preambleFrom: brief.parsed.preamble.length > 0 ? "brief" : "classification",
+        format,
+        ...(planner === "mercury" ? {} : { planner }),
+        ...(fim === undefined ? {} : { fim }),
+        shape: brief.shape,
         elapsedMs: Date.now() - startedAt,
         sends: stage.sends,
         retries: stage.retries,