@vibes.diy/api-svc 14.3.85 → 14.3.87

package/intern/mercury-first-build.js

@@ -1,21 +1,48 @@
 import { Result, exception2Result } from "@adviser/cement";
+import { and, eq } from "drizzle-orm";
 import { type } from "arktype";
 import { lazyType } from "@vibes.diy/api-types/lazy-type";
-import { KNOWN_VALUES_DIRECT_CONTROLS } from "./agent-session-instruction.js";
-import { addressWordsSentence } from "./instruction-variant.js";
-import { capRetryDelayMs, parseRetryAfterMs, readFailureBody, waitMs } from "../public/provider-errors.js";
+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 { 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";
 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 };
+}
+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;
-export const MERCURY_TRANSIENT_BACKOFF_MS = 400;
-const MERCURY_TRANSIENT_MAX_WAIT_MS = 2_000;
 const MERCURY_TRANSIENT_STATUSES = new Set([429, 502, 503, 504]);
 class MercuryTransientError extends Error {
+    status;
     retryAfterMs;
-    constructor(message, retryAfterMs) {
+    constructor(message, status, retryAfterMs) {
         super(message);
+        this.status = status;
         this.retryAfterMs = retryAfterMs;
     }
 }
@@ -73,18 +100,10 @@ export function mercuryShapeSchema() {
         },
     };
 }
-export function mercuryNonce() {
-    return String(1000 + Math.floor(Math.random() * 9000));
-}
 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}"\n(variant #${o.nonce}: a seed for wording, never written)` },
-            ],
-        },
+        { role: "user", content: [{ type: "text", text: `Person's words: "${o.personWords}"` }] },
     ];
 }
 const shapeParsed = lazyType(() => type({
@@ -134,11 +153,14 @@ const COMPOSER_WORDS = /paste|photo|picture|own words|however they|repl(y|ies)|i
 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) {
+export function fixMercuryShape(shape, personWords, opts = {}) {
     const m = personWords.toLowerCase();
     const composer = shape.flags.ai && shape.flags.composer && COMPOSER_WORDS.test(m);
-    const backend = shape.flags.backend && BACKEND_WORDS.test(m);
-    const archetype = PRIVATE_WORDS.test(m) && (shape.archetype === "open" || shape.archetype === "publish")
+    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";
+    const archetype = keepsPersonal || (privateAsk && (shape.archetype === "open" || shape.archetype === "publish"))
         ? "personal"
         : shape.archetype === "toy" && MULTIPLAYER_WORDS.test(m)
             ? "open"
@@ -151,11 +173,280 @@ export function fixMercuryShape(shape, personWords) {
             .filter((r) => r.length > 0)
             .slice(0, 5),
         flags: { ...shape.flags, composer, backend },
+        ...(keepsToThemselves ? { keepsToThemselves: true } : {}),
+    };
+}
+const draftShapeParsed = 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);
+    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 }));
+}
+function setFlags(flags) {
+    return MERCURY_FLAGS.filter((f) => flags[f]);
+}
+const TITLE_LABEL = /^\s*titles?\s*:\s*/i;
+const SLUGS_LABEL = /^\s*slugs?\s*:\s*/i;
+function splitMercurySlugs(v) {
+    return v
+        .replace(SLUGS_LABEL, "")
+        .split(/\s*[/|,\n]\s*/)
+        .map((t) => t.trim())
+        .filter((t) => t.length > 0);
+}
+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)}`],
+        decode: (reply) => {
+            const repairs = new Set();
+            let title;
+            if (typeof reply.title === "string") {
+                if (TITLE_LABEL.test(reply.title))
+                    repairs.add("label");
+                title = reply.title.replace(TITLE_LABEL, "").trim();
+            }
+            else if (reply.title !== undefined && reply.title !== null)
+                return Result.Err("title-shape");
+            const v = reply.slugs;
+            let slugs;
+            if (v === undefined || v === null)
+                slugs = [];
+            else if (typeof v === "string") {
+                repairs.add("split");
+                if (SLUGS_LABEL.test(v))
+                    repairs.add("label");
+                slugs = splitMercurySlugs(v);
+            }
+            else if (strings(v)) {
+                if (v.some((t) => SLUGS_LABEL.test(t)))
+                    repairs.add("label");
+                slugs = v.map((t) => t.replace(SLUGS_LABEL, "").trim());
+            }
+            else
+                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_EXEMPLAR_FIELD = `## How to read this field
+export const MERCURY_ADDRESS = mercuryAddressEncoding();
+export function mercurySlugWordsSentence(words) {
+    return words.length === 0
+        ? ""
+        : `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
 
-Every brief has the same parts, in this order. Below, each part is shown as a SPREAD of alternatives, side by side. Each row is tagged with the ownership archetype it fits:
+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.
@@ -164,71 +455,170 @@ Every brief has the same parts, in this order. Below, each part is shown as a SP
 - [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.
 
-Pick the rows that match the archetype you were given. Take every noun from the person's own words.
-
-## 1. Opening — one sentence: what it is and who it is for
-
-- [personal] A glaze test notebook for a home potter.
-- [personal] A sourdough starter log for one baker's kitchen.
-- [group]    A tool library for one neighbourhood block, shared by the households on it.
-- [group]    A setlist planner for a four-piece cover band.
-- [publish]  A taco truck menu board the owner updates from their phone and customers read.
-- [publish]  A micro-poetry zine where one editor posts and everyone reads.
-- [intake]   An appointment book for a dog grooming salon: clients book without signing up, the groomer sees every slot.
-- [intake]   A repair drop-off form for a bike shop, with the owner's queue on the other side.
-- [open]     A lost-and-found board for a music festival that anyone with the link can post to.
-- [open]     A wedding photo wall where every guest drops pictures from their phone.
-- [toy]      A hex-grid pong game with a slow-motion ball and a local best score.
-- [toy]      A kaleidoscope you steer with the mouse, with nothing saved.
-
-## 2. Ownership and access — who owns what, who gets in, who sees what
-
-- [personal] 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.
-- [personal] The person's own starter log is ready on arrival. Feedings belong to that log; rules key on its creator, so the entries stay theirs, shaped so a housemate could be admitted later.
-- [group]    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.
-- [group]    The owner's band object holds memberships for the other three players, written by the HandleInput invite screen. Any member adds songs and reorders the set; the creator manages members and deletes songs.
-- [publish]  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.
-- [publish]  One editor owns the zine; poem records are creator-writable and world-readable. Readers see the issues.
-- [intake]   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.
-- [intake]   Drop-off requests are created by visitors without accounts; each request is readable by the shop owner (and staff let in later by membership). The public form page shows the visitor their own request.
-- [open]     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.
-- [open]     Anyone with the link uploads photos to the wall; everyone reads; a photo is deletable by whoever posted it or the couple who own the wall.
-- [toy]      Each signed-in player keeps a best score record keyed on their handle; a shared Top Scores list shows everyone's best with ViewerTag.
-- [toy]      The toy keeps its state in memory: it opens instantly, with no sign-in and no records.
-
-## 3. Seed cast — seed.json demo with a named cast, counts and dates near today
-
-- [personal] seed.json demo: the owner's notebook plus 5 glazes (Tenmoku, Shino, Celadon, Chun blue, Ash) and 9 tiles fired between 2026-09-20 and 2026-10-05, two rated 5.
-- [personal] seed.json demo: one starter "Gus" born 2026-03-02 with 10 feedings over the last two weeks, rise heights between 3 and 7 cm.
-- [group]    seed.json demo: the owner's library "Maple Street Tools" with the owner's own membership plus @priya and @tomas, 8 tools (a ladder, a tile saw, a pressure washer...), two loans out due this week and one returned.
-- [group]    seed.json demo: the band "Low Tide" with the owner's membership and three members (@dee, @marco, @sun), 14 songs with keys and bpm, one setlist for a gig dated 2026-10-18.
-- [publish]  seed.json demo: the owner's menu with 6 items across tacos, sides and drinks, one marked sold out, and a note of the day dated 2026-10-07.
-- [intake]   seed.json demo: the owner's salon with 7 bookings spread over 2026-10-07 to 2026-10-11 in mixed statuses, dog names like Biscuit and Juno.
-- [open]     seed.json demo: the festival board with 9 posts from five handles, five lost and four found, two already resolved, dated across the last three days.
-- [toy]      seed.json demo: 6 score records from a small cast including the owner so the Top Scores list opens filled.
-
-## 4. Look note — one short line: background, accent, card shape, mood
-
-- [personal] Earthy studio: oatmeal background, iron-red accents, chunky rounded tile cards.
-- [personal] Flour-dusted kitchen: warm white, rye brown, a tall rising bar as the hero number.
-- [group]    Workshop pegboard: plywood tones, safety-orange accents, square tool cards with big status chips.
-- [group]    Backstage: near-black, amber stage light accents, setlist rows like gaffer-tape strips.
-- [publish]  Street-food bright: chalkboard dark with chalk-white type and chili-red price tags.
-- [intake]   Clean salon: pale mint, charcoal type, generous slot buttons easy to tap one-handed.
-- [open]     Festival poster: cream paper, bold two-colour print, pinned-note cards with torn edges.
-- [toy]      Neon arcade: deep navy, electric cyan ball, glowing hex outlines.
-
-## 5. Titles, addresses and icon
-
-- pairs: Glaze Ledger / glaze-ledger, Tile Book / tile-book, Kiln Notes / kiln-notes — icon: a glazed test tile beside a small kiln
-- pairs: Block Tools / block-tools, Maple Street Shelf / maple-street-shelf, Borrow Board / borrow-board — icon: a hand drill inside a house outline
-- pairs: Truck Board / truck-board, Taco Today / taco-today, Menu Chalk / menu-chalk — icon: a chalkboard with a taco drawn on it
-- pairs: Groom Book / groom-book, Salon Slots / salon-slots, Paws Diary / paws-diary — icon: a dog brush beside a clock face
-- pairs: Festival Finds / festival-finds, Lost Tent / lost-tent, Found It / found-it — icon: a tent peg tied with a ribbon
-- pairs: Hex Pong / hex-pong, Slow Rally / slow-rally, Honey Paddle / honey-paddle — icon: a hexagonal paddle and a glowing ball`;
-export const MERCURY_BRIEF_RULES = `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. The seed part starts with "seed.json demo:" and gives a named cast, counts and dates near today, using the given record names. 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. Each pair is a Title Case title of two or three words and a kebab-case address made from it.`;
+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;
+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}`;
+}
+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_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],
@@ -236,25 +626,37 @@ const FIELD_BOUNDS = {
     look: [15, 150],
     icon: [8, 100],
 };
-export function mercuryBriefSchema(fields) {
+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: [...fields],
-        properties: Object.fromEntries(fields.map((f) => [
-            f,
-            f === "pairs"
-                ? {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        additionalProperties: false,
-                        required: ["title", "slug"],
-                        properties: { title: { type: "string" }, slug: { type: "string" } },
-                    },
-                }
-                : { type: "string" },
-        ])),
+        required: [...Object.keys(lead), ...(rooms ? ["rooms"] : []), ...(font ? ["font"] : [])],
+        properties: {
+            ...lead,
+            ...(rooms ? { rooms: { type: "array", items: { type: "string" } } } : {}),
+            ...(font ? { font: { type: "string" } } : {}),
+        },
     };
 }
 function capabilityDecisions(shape) {
@@ -269,7 +671,83 @@ function capabilityDecisions(shape) {
     ];
 }
 export function mercuryBriefMessages(o) {
-    const s = o.shape;
+    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}`,
@@ -284,20 +762,28 @@ export function mercuryBriefMessages(o) {
             : []),
     ];
     const user = [
-        `Person's words: "${o.personWords}"`,
-        `Today is ${o.today}.`,
-        "",
+        ...skeleton,
         "Decisions:",
         ...decisions.map((d) => `- ${d}`),
         "",
-        `Follow the rows tagged [${s.archetype}] in each part of the field. Return JSON with these keys: ${o.fields.join(", ")}` +
-            (o.fields.includes("pairs") ? " (pairs: an array of three {title, slug} candidates)" : "") +
-            ".",
-        ...(o.fields.includes("pairs") && o.words.length > 0 ? [addressWordsSentence(o.words).trim()] : []),
-        `(variant #${o.nonce}: a seed for wording, never written)`,
+        `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: `${MERCURY_BRIEF_RULES}\n\n${MERCURY_EXEMPLAR_FIELD}` }] },
+        {
+            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 }] },
     ];
 }
@@ -321,37 +807,64 @@ function mentions(name, text) {
     return stem(name).every((w) => lower.includes(w));
 }
 const TAG_LEAK = /\[(personal|group|publish|intake|open|toy)\]|archetype/i;
-const NONCE_LEAK = /variant|#\d{4}/i;
 const MARKUP = /```|^\s*#/m;
 const AI_LEAK = /\bcallai\b|\bAI\b|language model/;
-const pairShape = lazyType(() => type({ title: "string", slug: "string" }).array());
 function kebab(s) {
     return s
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-+|-+$/g, "");
 }
-export function gateMercuryPairs(raw) {
-    const parsed = pairShape(raw);
-    if (parsed instanceof type.errors)
-        return Result.Err("pairs-shape");
-    const pairs = parsed
-        .map((p) => {
-        const title = p.title.trim().replace(/^["*]+|["*]+$/g, "");
-        const slug = kebab(p.slug.trim().length > 0 ? p.slug : title);
-        return { title, slug };
-    })
-        .filter((p) => p.title.length > 0 && p.slug.length > 0);
-    const words = pairs.map((p) => p.title.split(/\s+/).length);
-    if (pairs.length !== 3)
-        return Result.Err("pairs-count");
-    if (new Set(pairs.map((p) => p.title.toLowerCase())).size !== 3)
-        return Result.Err("pairs-duplicate");
-    if (new Set(pairs.map((p) => p.slug)).size !== 3)
-        return Result.Err("pairs-duplicate");
-    if (words.some((n) => n < 1 || n > 4))
-        return Result.Err("pairs-length");
-    return Result.Ok(pairs);
+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);
+    const title = cut.text.trim().replace(/^["*]+|["*]+$/g, "");
+    const own = kebab(title);
+    if (title.length === 0 || own.length === 0)
+        return Result.Err("title-empty");
+    const words = title.split(/\s+/).length;
+    if (words < 1 || words > 4)
+        return Result.Err("title-length");
+    const sent = cut.repaired ? raw : title;
+    const slugs = o.slugs.map(kebab);
+    if (slugs.every((slug) => slug.length === 0))
+        return Result.Ok({ pairs: [{ title: sent, slug: own }], fallback: true, tagged: cut.repaired });
+    const filled = slugs.map((slug) => (slug.length > 0 ? slug : own));
+    if (filled.length !== 3)
+        return Result.Err("slugs-count");
+    if (new Set(filled).size !== 3)
+        return Result.Err("slugs-duplicate");
+    return Result.Ok({ pairs: filled.map((slug) => ({ title: sent, slug })), fallback: false, tagged: cut.repaired });
+}
+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);
@@ -366,16 +879,14 @@ export function gateMercuryField(o) {
         fails.push("short");
     else if (t.length > hi)
         fails.push("long");
-    if (NONCE_LEAK.test(t))
-        fails.push("nonce");
     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" && t.toLowerCase().includes("seed") === false)
-        fails.push("seed-word");
+    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") {
@@ -430,14 +941,70 @@ const FLAG_SKILLS = [
     ["charts", "d3"],
     ["boardGame", "board-games"],
 ];
-export function mercurySkills(shape) {
-    return ["access", "fireproof", ...FLAG_SKILLS.filter(([f]) => shape.flags[f]).map(([, skill]) => skill)];
+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;
 }
-export function mercuryNature(shape) {
+export function mercuryNature(shape, personWords) {
+    if (shape.keepsToThemselves === true)
+        return "sensitive";
+    if (PRIVATE_WORDS.test(personWords.toLowerCase()))
+        return "sensitive";
     const a = shape.archetype;
     if (a === "open" || a === "toy" || a === "publish")
         return "open";
-    return shape.flags.sensitive ? "sensitive" : "collaborative";
+    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);
@@ -448,30 +1015,134 @@ export function mercuryWorkflowLine(shape) {
         ...(caps.length === 0 ? [] : [`Capabilities: ${caps.join(", ")}.`]),
     ].join(" ");
 }
-export function assembleMercuryCreateVibe(o) {
+const MERCURY_ROOMS_MAX = 3;
+export function gateMercuryRooms(raw) {
+    if (!Array.isArray(raw))
+        return { dropped: raw === undefined ? 0 : 1 };
+    const valid = poufRoomSlugs();
+    const kept = [];
+    for (const r of raw) {
+        if (typeof r !== "string" || !valid.includes(r) || kept.includes(r) || kept.length === MERCURY_ROOMS_MAX)
+            continue;
+        kept.push(r);
+    }
+    const dropped = raw.length - kept.length;
+    return kept.length === 0 ? { dropped } : { rooms: kept, dropped };
+}
+export function gateMercuryFont(raw) {
+    if (raw === undefined)
+        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);
-    const parts = [
+    return [
         cleanMercuryText(o.fields.opening),
         keepsNothing && access.length === 0 ? "" : mercuryAccessLine(s, access),
-        mercuryWorkflowLine(s),
+        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);
+    const nature = mercuryNature(s, o.personWords);
+    const rooms = sanitizeRoomShortlist("pouf", o.rooms);
     return {
         prompt: o.personWords,
-        enrichedPrompt: parts.filter((p) => p.length > 0).join("\n\n"),
-        skills: mercurySkills(s),
+        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.`;
@@ -483,10 +1154,18 @@ export function mercuryPreambleMessages(o) {
         "What is being built:",
         o.enrichedPrompt,
         "",
-        `Write the preamble. (variant #${o.nonce}: a seed for wording, never written)`,
+        "Write the preamble.",
     ].join("\n");
     return [
-        { role: "system", content: [{ type: "text", text: MERCURY_PREAMBLE_SYSTEM }] },
+        {
+            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 }] },
     ];
 }
@@ -508,7 +1187,7 @@ export function gateMercuryPreamble(o) {
         fails.push("short");
     else if (t.length > 480)
         fails.push("long");
-    if (/variant|#\d{4}|```|^\s*#|\bbrief\b|seed\.json/im.test(t))
+    if (/```|^\s*#|\bbrief\b|\bdemo\s*:/im.test(t))
         fails.push("markup");
     if ((t.match(/[.!?](\s|$)/g) ?? []).length > 3)
         fails.push("too-many-sentences");
@@ -520,14 +1199,24 @@ export function gateMercuryPreamble(o) {
 }
 const completionBody = lazyType(() => type({
     "model?": "string",
-    choices: type({ message: { content: "string | null" } }).array(),
-    "usage?": { prompt_tokens: "number", completion_tokens: "number", "total_tokens?": "number", "cost?": "number" },
+    choices: type({ message: { content: "string | null" }, "finish_reason?": "string | null" }).array(),
+    "usage?": {
+        prompt_tokens: "number",
+        completion_tokens: "number",
+        "total_tokens?": "number",
+        "cost?": "number",
+        "completion_tokens_details?": type({ "reasoning_tokens?": "number | null" }).or("null"),
+    },
 }));
-async function withDeadline(call, timeoutMs) {
+async function withDeadline(call, timeoutMs, cancel) {
     const abort = new AbortController();
     const timer = setTimeout(function expire() {
         abort.abort();
     }, timeoutMs);
+    function cancelled() {
+        abort.abort();
+    }
+    cancel?.addEventListener("abort", cancelled, { once: true });
     return Promise.resolve()
         .then(function invoke() {
         return call(abort.signal);
@@ -541,15 +1230,19 @@ async function withDeadline(call, timeoutMs) {
     })
         .finally(function disarm() {
         clearTimeout(timer);
+        cancel?.removeEventListener("abort", cancelled);
     });
 }
 async function requestMercury(vctx, o, signal) {
+    const model = o.model ?? plannerModel("mercury");
     const req = {
-        model: MERCURY_FIRST_BUILD_MODEL,
+        model: model.id,
         stream: false,
         max_tokens: o.maxTokens,
-        reasoning: { ...MERCURY_FIRST_BUILD_REASONING },
-        response_format: { type: "json_schema", json_schema: { name: o.name, strict: true, schema: o.schema } },
+        ...(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 }));
@@ -560,7 +1253,7 @@ async function requestMercury(vctx, o, signal) {
         const { snippet } = await readFailureBody(res);
         const message = `mercury ${o.name}: status ${res.status}${snippet.length === 0 ? "" : ` ${snippet.slice(0, 200)}`}`;
         return MERCURY_TRANSIENT_STATUSES.has(res.status)
-            ? Result.Err(new MercuryTransientError(message, parseRetryAfterMs(res.headers)))
+            ? Result.Err(new MercuryTransientError(message, res.status, parseRetryAfterMs(res.headers)))
             : Result.Err(message);
     }
     const rBody = await exception2Result(() => res.json());
@@ -570,14 +1263,19 @@ async function requestMercury(vctx, o, signal) {
     if (body instanceof type.errors)
         return Result.Err(`mercury ${o.name}: reply: ${body.summary}`);
     const content = body.choices[0]?.message.content;
+    const finish = body.choices[0]?.finish_reason ?? "unknown";
+    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`);
-    const rJson = exception2Result(() => JSON.parse(cleanMercuryText(content)));
+        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: ${rJson.Err().message}`);
+        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 }),
         ...(u === undefined
             ? {}
@@ -591,85 +1289,232 @@ async function requestMercury(vctx, o, signal) {
             }),
     });
 }
-async function mercuryCall(vctx, o) {
-    const startedAt = Date.now();
-    const usage = [];
-    let servedModel;
-    let lastError = "no attempt";
+function mercurySendLog() {
+    return { sends: 0, retries: 0, history: [], cause: "budget", lastError: "no attempt", sentAt: Date.now() };
+}
+function noteSend(log, prefix = "") {
+    log.history.push(`${prefix}${log.cause} ${Date.now() - log.sentAt}ms: ${log.lastError}`.slice(0, 200));
+}
+function isCancelled(cancel) {
+    return cancel?.aborted === true;
+}
+function eitherSignal(a, b) {
+    if (a === undefined)
+        return b;
+    if (b === undefined)
+        return a;
+    const both = new AbortController();
+    function fire() {
+        both.abort();
+    }
+    if (a.aborted || b.aborted)
+        both.abort();
+    else {
+        a.addEventListener("abort", fire, { once: true });
+        b.addEventListener("abort", fire, { once: true });
+    }
+    return both.signal;
+}
+function waitOrCancel(ms, cancel) {
+    if (cancel === undefined)
+        return waitMs(ms);
+    if (cancel.aborted)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const timer = setTimeout(done, ms);
+        function done() {
+            clearTimeout(timer);
+            cancel?.removeEventListener("abort", done);
+            resolve();
+        }
+        cancel.addEventListener("abort", done, { once: true });
+    });
+}
+async function mercuryAttempt(vctx, o, log) {
+    const cancel = eitherSignal(o.cancel, o.budget.cancel);
+    function cancelledAttempt(inFlight) {
+        if (o.budget.cancel?.aborted === true) {
+            log.cause = "cancelled";
+            log.lastError = `mercury ${o.call}: cancelled, the first build went to the agent`;
+        }
+        return { kind: "cancelled", inFlight };
+    }
+    const persistent = o.persistent === true;
+    const maxTransientRetries = persistent ? Number.POSITIVE_INFINITY : (o.transientRetries ?? MERCURY_TRANSIENT_RETRIES);
     let transientRetries = 0;
-    for (let attempt = 0; attempt < MERCURY_CALL_ATTEMPTS; attempt++) {
+    async function persistentWait(retryAfterMs) {
+        const wait = mercuryTesterRetryWaitMs(transientRetries + 1, retryAfterMs);
+        if (wait > o.budget.remainingMs() - MERCURY_MIN_ATTEMPT_MS) {
+            log.lastError = `${log.lastError} (next wait ${wait}ms does not fit the stage bound)`;
+            return false;
+        }
+        await waitOrCancel(wait, cancel);
+        transientRetries += 1;
+        log.retries += 1;
+        return true;
+    }
+    for (;;) {
+        if (isCancelled(cancel))
+            return cancelledAttempt(false);
+        const remaining = o.budget.remainingMs();
+        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";
+            return { kind: "budget" };
+        }
+        const deadline = Math.min(o.deadlineMs, remaining);
         const ask = o.request();
-        const r = await withDeadline((signal) => requestMercury(vctx, { name: o.call, schema: ask.schema, messages: ask.messages, maxTokens: o.maxTokens }, signal), o.deadlineMs);
+        log.sends += 1;
+        log.sentAt = Date.now();
+        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 }),
+        }, signal), deadline, cancel);
+        log.inFlight = false;
+        if (r.timedOut && isCancelled(cancel))
+            return cancelledAttempt(true);
         if (r.timedOut) {
-            lastError = `mercury ${o.call}: timed out after ${o.deadlineMs}ms`;
-            transientRetries = 0;
-            continue;
+            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";
+            noteSend(log, o.label);
+            if (persistent && !clipped && (await persistentWait(undefined)))
+                continue;
+            return { kind: "failed" };
         }
-        if (r.reply.isErr()) {
-            const err = r.reply.Err();
-            lastError = err.message;
-            if (err instanceof MercuryTransientError && transientRetries < MERCURY_TRANSIENT_RETRIES) {
-                transientRetries += 1;
-                await waitMs(Math.min(capRetryDelayMs(err.retryAfterMs, MERCURY_TRANSIENT_BACKOFF_MS * transientRetries), MERCURY_TRANSIENT_MAX_WAIT_MS));
-                attempt -= 1;
+        if (r.reply.isOk())
+            return { kind: "reply", reply: r.reply.Ok() };
+        const err = r.reply.Err();
+        log.lastError = err.message;
+        if (err instanceof MercuryTransientError === false) {
+            log.cause = persistent ? "network" : "error";
+            noteSend(log, o.label);
+            if (persistent && (await persistentWait(undefined)))
                 continue;
-            }
-            transientRetries = 0;
-            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)
+            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" };
         }
-        const reply = r.reply.Ok();
-        if (reply.usage !== undefined)
-            usage.push(reply.usage);
-        if (reply.servedModel !== undefined)
-            servedModel = reply.servedModel;
-        const accepted = o.accept(reply.json);
+        await waitOrCancel(wait, cancel);
+        transientRetries += 1;
+        log.retries += 1;
+    }
+}
+function absorbReply(into, reply) {
+    if (reply.usage !== undefined)
+        into.usage.push(reply.usage);
+    if (reply.servedModel !== undefined)
+        into.servedModel = reply.servedModel;
+    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: {
-                    call: o.call,
-                    ok: true,
-                    attempts: attempt + 1,
-                    elapsedMs: Date.now() - startedAt,
-                    ...(servedModel === undefined ? {} : { servedModel }),
-                    usage,
-                },
+                record: callRecord({ call: o.call, ok: true, attempts, startedAt, totals, log, extra: { text: a.reply.text } }),
             });
-            return accepted;
-        }
-        lastError = `mercury ${o.call}: ${accepted.Err().message}`;
-        transientRetries = 0;
-    }
-    vctx.logger.Warn().Any("event", { chatId: o.row.chatId, call: o.call, error: lastError }).Msg("mercury-first-build-call-failed");
-    await recordMercuryRow(vctx, {
-        ...o.row,
-        record: {
-            call: o.call,
-            ok: false,
-            attempts: MERCURY_CALL_ATTEMPTS,
-            elapsedMs: Date.now() - startedAt,
-            ...(servedModel === undefined ? {} : { servedModel }),
-            usage,
-            error: lastError,
-        },
-    });
-    return Result.Err(lastError);
+            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 {
+        call: o.call,
+        ok: o.ok,
+        attempts: o.attempts,
+        elapsedMs: Date.now() - o.startedAt,
+        ...(t.servedModel === undefined ? {} : { servedModel: t.servedModel }),
+        usage: t.usage,
+        ...(o.ok ? {} : { error: o.log.lastError, cause: o.log.cause }),
+        sends: o.log.sends,
+        retries: o.log.retries,
+        ...(o.log.history.length === 0 && o.ok ? {} : { history: o.log.history }),
+        ...(t.reasoningTokens === undefined ? {} : { reasoningTokens: t.reasoningTokens }),
+        ...o.extra,
+    };
+}
+async function failCall(vctx, o) {
+    const { log } = o;
+    vctx.logger
+        .Warn()
+        .Any("event", {
+        chatId: o.row.chatId,
+        call: o.call,
+        cause: log.cause,
+        sends: log.sends,
+        retries: log.retries,
+        error: log.lastError,
+    })
+        .Msg("mercury-first-build-call-failed");
+    await recordMercuryRow(vctx, { ...o.row, record: callRecord({ ...o, ok: false }) });
+    return Result.Err(new MercuryStageError(log.lastError, log.cause, {
+        call: o.call,
+        sends: log.sends,
+        retries: log.retries,
+        elapsedMs: Date.now() - o.startedAt,
+    }));
 }
 async function recordMercuryRow(vctx, o) {
+    const asked = plannerAskedModel(o.record.planner);
+    const model = o.record.servedModel ?? asked;
+    const rounds = o.record.usage.map((u) => ({ ...u, model, role: "mercury" }));
+    if (rounds.length > 0)
+        o.onUsage?.(rounds);
     const zero = { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 };
-    const model = o.record.servedModel ?? MERCURY_FIRST_BUILD_MODEL;
+    const promptId = vctx.sthis.nextId(12).str;
     const rInsert = await exception2Result(() => vctx.sql.db.insert(vctx.sql.tables.promptContexts).values({
         userId: o.userId,
         chatId: o.chatId,
-        promptId: vctx.sthis.nextId(12).str,
+        promptId,
         nethash: vctx.netHash(),
         promptTokens: 0,
         completionTokens: 0,
         totalTokens: 0,
         ref: {
             type: "prompt.usage.sql",
-            usage: { given: o.record.usage.map((u) => ({ ...u, model })), calculated: zero },
-            model: MERCURY_FIRST_BUILD_MODEL,
+            usage: { given: [], calculated: zero },
+            model: asked,
             step: "first-mercury",
             mercury: {
                 call: o.record.call,
@@ -678,102 +1523,1922 @@ async function recordMercuryRow(vctx, o) {
                 elapsedMs: o.record.elapsedMs,
                 ...(o.record.servedModel === undefined ? {} : { servedModel: o.record.servedModel }),
                 ...(o.record.error === undefined ? {} : { error: o.record.error.slice(0, 300) }),
+                ...(o.record.cause === undefined ? {} : { cause: o.record.cause }),
+                sends: o.record.sends,
+                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] }),
+                ...(o.record.slugsWithWord === undefined ? {} : { slugsWithWord: o.record.slugsWithWord }),
+                ...(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 })) }),
             },
         },
         created: new Date().toISOString(),
     }));
     if (rInsert.isErr())
         vctx.logger.Warn().Err(rInsert).Str("chatId", o.chatId).Msg("mercury-first-build-row-failed");
+    else
+        o.onWritten?.(promptId);
 }
-function owedBriefFields(gated) {
-    return MERCURY_BRIEF_FIELDS.filter((f) => (f === "pairs" ? gated.pairs === undefined : gated.texts.has(f) === false));
+export async function recordMercuryDispatched(vctx, o) {
+    const t = vctx.sql.tables.promptContexts;
+    const where = and(eq(t.chatId, o.chatId), eq(t.promptId, o.promptId));
+    const r = await exception2Result(async () => {
+        const [row] = await vctx.sql.db.select({ ref: t.ref }).from(t).where(where).limit(1);
+        if (row === undefined)
+            return;
+        const ref = row.ref;
+        if (ref.mercury === undefined)
+            return;
+        await vctx.sql.db
+            .update(t)
+            .set({ ref: { ...ref, mercury: { ...ref.mercury, dispatched: { enrichedPrompt: o.enrichedPrompt } } } })
+            .where(where);
+    });
+    if (r.isErr())
+        vctx.logger.Warn().Err(r).Str("chatId", o.chatId).Msg("mercury-first-build-dispatched-row-failed");
 }
-const replyObject = lazyType(() => type("Record<string, unknown>"));
-function acceptBriefFields(json, o) {
+export async function recordMercuryRace(vctx, o) {
+    const t = vctx.sql.tables.promptContexts;
+    const where = and(eq(t.chatId, o.chatId), eq(t.promptId, o.promptId));
+    const r = await exception2Result(async () => {
+        const [row] = await vctx.sql.db.select({ ref: t.ref }).from(t).where(where).limit(1);
+        if (row === undefined)
+            return;
+        const ref = row.ref;
+        if (ref.mercury === undefined)
+            return;
+        await vctx.sql.db
+            .update(t)
+            .set({ ref: { ...ref, mercury: { ...ref.mercury, race: { ...o.race } } } })
+            .where(where);
+    });
+    if (r.isErr())
+        vctx.logger.Warn().Err(r).Str("chatId", o.chatId).Msg("mercury-first-build-race-row-failed");
+}
+export async function recordMercuryFim(vctx, o) {
+    const t = vctx.sql.tables.promptContexts;
+    const where = and(eq(t.chatId, o.chatId), eq(t.promptId, o.promptId));
+    const r = await exception2Result(async () => {
+        const [row] = await vctx.sql.db.select({ ref: t.ref }).from(t).where(where).limit(1);
+        if (row === undefined)
+            return;
+        const ref = row.ref;
+        if (ref.mercury === undefined)
+            return;
+        await vctx.sql.db
+            .update(t)
+            .set({
+            ref: {
+                ...ref,
+                mercury: { ...ref.mercury, fim: { ...o.fim }, ...(o.filledText === undefined ? {} : { filledText: o.filledText }) },
+            },
+        })
+            .where(where);
+    });
+    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);
-    const body = parsed instanceof type.errors ? {} : parsed;
-    const failed = [];
-    for (const f of o.owed) {
-        const v = body[f];
-        if (f === "pairs") {
-            const pairs = gateMercuryPairs(v);
-            if (pairs.isOk())
-                o.into.pairs = pairs.Ok();
-            else
-                failed.push(`pairs:${pairs.Err().message}`);
+    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;
         }
-        const fails = typeof v === "string" ? gateMercuryField({ field: f, value: v, shape: o.shape }) : ["not-a-string"];
-        if (fails.length === 0 && typeof v === "string")
-            o.into.texts.set(f, v);
-        else
-            failed.push(`${f}:${fails.join("+")}`);
+        if (current !== undefined && line.trim().length > 0)
+            keys[current] = `${keys[current]}\n${line.trim()}`.trim();
     }
-    return failed;
+    const guessLines = spec.split("\n").filter((l) => GUESS_LABEL.test(l)).length;
+    return { narration, spec, keys, guessLines };
 }
-export async function runMercuryFirstBuild(vctx, args) {
-    return exception2Result(() => pipeline(vctx, args));
+function thinkAloudScalar(v) {
+    return (v ?? "")
+        .replace(/^\s*\(?\s*guess\s*:\s*/i, "")
+        .replace(/\(\s*guess[^)]*\)/gi, "")
+        .replace(/\bguess\s*:\s*/gi, "")
+        .trim()
+        .replace(/^["'`]+|["'`]+$/g, "")
+        .trim();
 }
-async function pipeline(vctx, args) {
+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,
+    });
+}
+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) {
+    return [
+        MERCURY_TESTER_REPLY_INTRO,
+        `<tester-reply>\n${reply}\n</tester-reply>`,
+        MERCURY_TESTER_REPLY_RULE,
+        `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_CARDS_MARKER = "--- CARDS ---";
+export const MERCURY_CARDS_APP_MARKER = "--- APP ---";
+export const MERCURY_CARDS_TAIL_HINTS = {
+    title: "the app's name, two or three words in its own vocabulary",
+    slugs: "three short kebab-case addresses for the app, comma-separated",
+    archetype: "one of personal, group, publish, intake, open, toy: the ownership shape that fits the person's words",
+    capabilities: "the capabilities this request needs, from the capability list, comma-separated; none when it needs none",
+};
+export const MERCURY_CARDS_PREAMBLE_RULE = `Start with a short paragraph to the app creator, in plain warm words: what you're making for them and its most important workflow, walked through the way they'll do it. Say "probably" where you're guessing.`;
+export const MERCURY_CARDS_SHAPE = `As a <role>, I <action on a named record>, so that <outcome>.
+  Accept: <one testable line, in terms of records and fields>
+  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_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.`;
+export function mercuryCardsSystem(o = {}) {
+    const keys = {
+        ...MERCURY_CARDS_TAIL_HINTS,
+        ...(o.rooms === true ? { rooms: `${MERCURY_ROOMS_HINT}, comma-separated` } : {}),
+        ...(o.font === true ? { font: MERCURY_FONT_HINT } : {}),
+    };
+    const tailLines = Object.entries(keys)
+        .map(([k, h]) => `${k}: <${h}>`)
+        .join("\n");
+    return `You read a person's request for a small web app and write its first plan as plain text.
+
+${MERCURY_CARDS_PREAMBLE_RULE} Then a line reading exactly "${MERCURY_CARDS_MARKER}", then the requirements as user-story cards, one card per thing a role can do or see:
+${MERCURY_CARDS_SHAPE}
+Cover every role the person's words name, every action, every derived value, and who may do what without signing in.
+
+${MERCURY_CARDS_RULES}
+
+Then a line reading exactly "${MERCURY_CARDS_APP_MARKER}", then one line per key, as "key: value":
+${tailLines}
+
+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 mercuryCardsMessages(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: mercuryCardsSystem({ rooms, font }) }] },
+        { role: "user", content: [{ type: "text", text: user }] },
+    ];
+}
+const CARDS_TAIL_KEYS = new Set([...Object.keys(MERCURY_CARDS_TAIL_HINTS), "rooms", "font"]);
+const CARDS_MARKER_LINE = /^[ \t]*[*_#>-]*[ \t]*-{2,}[ \t]*CARDS[ \t]*-{2,}[ \t]*[*_]*[ \t]*$/i;
+const APP_MARKER_LINE = /^[ \t]*[*_#>-]*[ \t]*-{2,}[ \t]*APP[ \t]*-{2,}[ \t]*[*_]*[ \t]*$/i;
+const CARD_LINE = /^\s*(?:[-*•]|\d+[.)])?\s*(?:\*\*)?As an? \S/i;
+const DATA_LINE = /^\s*(?:[-*]\s*)?(?:\*\*)?Data(?:\*\*)?\s*:\s*(?:\*\*)?([A-Za-z][A-Za-z0-9 _-]*?)\s*\{/;
+const ACCEPT_LINE = /^\s*(?:[-*]\s*)?(?:\*\*)?Accept(?:\*\*)?\s*:/i;
+const RULE_LINE = /^\s*(?:[-*]\s*)?(?:\*\*)?Rule(?:\*\*)?\s*:/i;
+const CARD_GUESS = /\(\s*guess\s*\)|\bguess\s*:/i;
+export function parseMercuryCards(text) {
+    const lines = text.split("\n");
+    const cardsMarkerAt = lines.findIndex((l) => CARDS_MARKER_LINE.test(l));
+    const appMarkerAt = lines.findIndex((l, i) => APP_MARKER_LINE.test(l) && (cardsMarkerAt < 0 || i > cardsMarkerAt));
+    const bodyStart = cardsMarkerAt < 0 ? 0 : cardsMarkerAt + 1;
+    const bodyEnd = appMarkerAt < 0 ? lines.length : appMarkerAt;
+    const preamble = lines
+        .slice(0, cardsMarkerAt < 0 ? 0 : cardsMarkerAt)
+        .join("\n")
+        .trim();
+    const cardLines = [];
+    const dataRecords = [];
+    let acceptLines = 0;
+    let ruleLines = 0;
+    let guessLines = 0;
+    for (let i = bodyStart; i < bodyEnd; i += 1) {
+        const l = lines[i];
+        if (CARD_LINE.test(l))
+            cardLines.push(i);
+        const d = DATA_LINE.exec(l);
+        if (d !== null && dataRecords.includes(d[1].trim()) === false)
+            dataRecords.push(d[1].trim());
+        if (ACCEPT_LINE.test(l))
+            acceptLines += 1;
+        if (RULE_LINE.test(l))
+            ruleLines += 1;
+        if (CARD_GUESS.test(l))
+            guessLines += 1;
+    }
+    const keys = {};
+    if (appMarkerAt >= 0) {
+        for (const line of lines.slice(appMarkerAt + 1)) {
+            const k = THINKALOUD_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();
+        }
+    }
+    return {
+        lines,
+        preamble,
+        ...(cardsMarkerAt < 0 ? {} : { cardsMarkerAt }),
+        ...(appMarkerAt < 0 ? {} : { appMarkerAt }),
+        cardLines,
+        keys,
+        dataRecords,
+        acceptLines,
+        ruleLines,
+        guessLines,
+    };
+}
+export function gateMercuryCards(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 p = parseMercuryCards(raw);
+    if (p.cardsMarkerAt === undefined)
+        miss("cardsMarker", "missing");
+    if (p.appMarkerAt === undefined)
+        miss("appMarker", "missing");
+    if (p.preamble.length === 0)
+        miss("preamble", "empty");
+    if (p.cardLines.length === 0)
+        miss("cards", "none");
+    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 rShape = parseMercuryDraftShape({
+        archetype: known ?? MERCURY_THINKALOUD_DEFAULT_ARCHETYPE,
+        coreAction: o.personWords.trim(),
+        recordNames: p.dataRecords.slice(0, 5),
+        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 (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,
+        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)) } : {}),
+        softMisses: soft,
+    });
+}
+export const MERCURY_FIM_MODEL = "mercury-coder";
+export const MERCURY_FIM_URL = "https://api.inceptionlabs.ai/v1/fim/completions";
+export const MERCURY_FIM_MAX_TOKENS = 2000;
+export const MERCURY_FIM_STOP = ['"', "\n"];
+export const MERCURY_FIM_CALL_DEADLINE_MS = 20_000;
+export const MERCURY_FIM_BUDGET_MS = 40_000;
+export const MERCURY_FIM_CONCURRENCY = 8;
+export const MERCURY_FIM_PRICE = { inputUsdPerMTok: 0.25, outputUsdPerMTok: 1 };
+export function mercuryFimUsageRound(fim) {
+    if (fim.promptTokens === 0 && fim.completionTokens === 0)
+        return undefined;
+    return {
+        prompt_tokens: fim.promptTokens,
+        completion_tokens: fim.completionTokens,
+        total_tokens: fim.promptTokens + fim.completionTokens,
+        cost: (fim.promptTokens * MERCURY_FIM_PRICE.inputUsdPerMTok + fim.completionTokens * MERCURY_FIM_PRICE.outputUsdPerMTok) /
+            1_000_000,
+        model: MERCURY_FIM_MODEL,
+        role: "mercury",
+    };
+}
+export const MERCURY_FIM_WAVES = ["see", "expect"];
+export const MERCURY_FIM_SEEDS = {
+    see: 'See: "I open this and I see',
+    expect: 'Expect: "When I do this, I expect',
+};
+export function mercuryFimHeader(personWords) {
+    return `# Requirements as user-story cards. Under each card, a usability tester narrates in the first person what she sees when she opens it and what she expects to happen when she does it.\n# The app creator's initial prompt: "${personWords}"\n\n`;
+}
+export function renderMercuryCardsFills(o) {
+    const out = [];
+    for (let i = 0; i < o.bodyEnd; i += 1) {
+        out.push(o.lines[i]);
+        if (o.cardLines.includes(i) === false)
+            continue;
+        for (const kind of MERCURY_FIM_WAVES) {
+            const k = `${i}:${kind}`;
+            if (o.gap === k)
+                out.push(`  ${MERCURY_FIM_SEEDS[kind]}\u0000`);
+            else if (o.fills.has(k))
+                out.push(`  ${MERCURY_FIM_SEEDS[kind]}${o.fills.get(k)}"`);
+        }
+    }
+    return out.join("\n");
+}
+export function mercuryFimRequest(o) {
+    const t = renderMercuryCardsFills(o);
+    const at = t.indexOf("\u0000");
+    return {
+        model: MERCURY_FIM_MODEL,
+        prompt: mercuryFimHeader(o.personWords) + t.slice(0, at),
+        suffix: `"${t.slice(at + 1)}`,
+        max_tokens: MERCURY_FIM_MAX_TOKENS,
+        stop: [...MERCURY_FIM_STOP],
+    };
+}
+const fimBody = lazyType(() => type({
+    choices: type({ "text?": "string | null", "message?": { content: "string | null" } }).array(),
+    "usage?": { "prompt_tokens?": "number", "completion_tokens?": "number" },
+}));
+async function mercuryFimCall(fetchImpl, o) {
+    const abort = new AbortController();
+    const timer = setTimeout(function expire() {
+        abort.abort();
+    }, o.deadlineMs);
+    function cancelled() {
+        abort.abort();
+    }
+    if (o.cancel?.aborted === true)
+        abort.abort();
+    o.cancel?.addEventListener("abort", cancelled, { once: true });
+    const startedAt = Date.now();
+    let last = "";
+    try {
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            if (abort.signal.aborted)
+                break;
+            const rRes = await exception2Result(() => fetchImpl(o.url ?? MERCURY_FIM_URL, {
+                method: "POST",
+                headers: { authorization: `Bearer ${o.apiKey}`, "content-type": "application/json" },
+                body: JSON.stringify(o.body),
+                signal: abort.signal,
+            }));
+            if (rRes.isErr()) {
+                last = abort.signal.aborted ? `timeout after ${Date.now() - startedAt} ms` : `network: ${rRes.Err().message.slice(0, 120)}`;
+                if (abort.signal.aborted)
+                    break;
+            }
+            else {
+                const res = rRes.Ok();
+                if (res.ok) {
+                    const rJson = await exception2Result(() => res.json());
+                    if (rJson.isErr())
+                        return { kind: "failed", error: `body: ${rJson.Err().message.slice(0, 120)}` };
+                    const body = fimBody(rJson.Ok());
+                    if (body instanceof type.errors)
+                        return { kind: "failed", error: `reply: ${body.summary.slice(0, 120)}` };
+                    const c = body.choices[0];
+                    const text = c?.text ?? c?.message?.content ?? null;
+                    if (text === null || text === undefined)
+                        return { kind: "failed", error: "reply: no text" };
+                    return {
+                        kind: "fill",
+                        text,
+                        promptTokens: body.usage?.prompt_tokens ?? 0,
+                        completionTokens: body.usage?.completion_tokens ?? 0,
+                    };
+                }
+                const { snippet } = await readFailureBody(res);
+                last = `status ${res.status}${snippet.length === 0 ? "" : ` ${snippet.slice(0, 120)}`}`;
+                if (MERCURY_TRANSIENT_STATUSES.has(res.status) === false)
+                    break;
+            }
+            const wait = 1000 * 2 ** attempt;
+            if (Date.now() - startedAt + wait >= o.deadlineMs)
+                break;
+            await waitMs(wait);
+        }
+    }
+    finally {
+        clearTimeout(timer);
+        o.cancel?.removeEventListener("abort", cancelled);
+    }
+    return { kind: "failed", error: last.length === 0 ? "aborted" : last };
+}
+export async function mercuryCardsFim(vctx, o) {
+    const p = o.draft.parsed;
+    const startedAt = Date.now();
+    const bodyEnd = p.appMarkerAt ?? p.lines.length;
+    const base = {
+        model: MERCURY_FIM_MODEL,
+        cards: p.cardLines.length,
+        slots: p.cardLines.length * MERCURY_FIM_WAVES.length,
+        filled: 0,
+        empty: 0,
+        failed: 0,
+        promptTokens: 0,
+        completionTokens: 0,
+    };
+    if (o.apiKey === undefined || o.apiKey.length === 0)
+        return { reply: o.draft.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 } };
+    const apiKey = o.apiKey;
+    const budgetMs = o.budgetMs ?? MERCURY_FIM_BUDGET_MS;
+    const callMs = o.deadlineMs ?? MERCURY_FIM_CALL_DEADLINE_MS;
+    const fills = new Map();
+    const errors = [];
+    let promptTokens = 0;
+    let completionTokens = 0;
+    let empty = 0;
+    for (const kind of MERCURY_FIM_WAVES) {
+        const slots = p.cardLines.map((i) => `${i}:${kind}`);
+        const got = new Map();
+        let next = 0;
+        const worker = async () => {
+            while (next < slots.length) {
+                const gap = slots[next];
+                next += 1;
+                const remaining = budgetMs - (Date.now() - startedAt);
+                if (remaining <= 0 || o.cancel?.aborted === true) {
+                    errors.push(`${gap}: ${o.cancel?.aborted === true ? "cancelled" : "budget spent"}`);
+                    continue;
+                }
+                const body = mercuryFimRequest({ personWords: o.personWords, lines: p.lines, bodyEnd, cardLines: p.cardLines, fills, gap });
+                const r = await mercuryFimCall(vctx.inferenceFetch, {
+                    apiKey,
+                    body,
+                    deadlineMs: Math.min(callMs, remaining),
+                    ...(o.url === undefined ? {} : { url: o.url }),
+                    ...(o.cancel === undefined ? {} : { cancel: o.cancel }),
+                });
+                if (r.kind === "failed") {
+                    errors.push(`${gap}: ${r.error}`);
+                    continue;
+                }
+                got.set(gap, r.text);
+                promptTokens += r.promptTokens;
+                completionTokens += r.completionTokens;
+                if (r.text.length === 0)
+                    empty += 1;
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(MERCURY_FIM_CONCURRENCY, slots.length) }, worker));
+        for (const [k, v] of got)
+            fills.set(k, v);
+    }
+    const body = renderMercuryCardsFills({ lines: p.lines, bodyEnd, cardLines: p.cardLines, fills });
+    const tail = p.lines.slice(bodyEnd);
+    const reply = tail.length === 0 ? body : `${body}\n${tail.join("\n")}`;
+    const filled = fills.size;
+    return {
+        reply,
+        receipt: {
+            status: filled > 0 ? "ok" : "failed",
+            ...base,
+            filled,
+            empty,
+            failed: base.slots - filled,
+            ms: Date.now() - startedAt,
+            promptTokens,
+            completionTokens,
+            ...(errors.length === 0 ? {} : { errors: errors.slice(0, 20) }),
+        },
+    };
+}
+export function assembleMercuryCardsCreateVibe(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.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 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 }),
+    };
+}
+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 const MERCURY_DROP_OVER_BOUND = 3;
+function titleFromSlug(slug) {
+    return slug
+        .split("-")
+        .filter((w) => w.length > 0)
+        .slice(0, 4)
+        .map((w) => w[0].toUpperCase() + w.slice(1))
+        .join(" ");
+}
+function looseMercuryAddress(title, slugs) {
+    const cut = stripMercuryArchetypeTag((title ?? "").trim());
+    const own = cut.text.trim().replace(/^["*]+|["*]+$/g, "");
+    const kept = [...new Set(slugs.map(kebab).filter((x) => x.length > 0))].slice(0, 3);
+    const name = own.length > 0 && kebab(own).length > 0 ? own : kept.length > 0 ? titleFromSlug(kept[0]) : "";
+    if (name.length === 0)
+        return undefined;
+    const sent = own.length > 0 && cut.repaired ? (title ?? "").trim() : name;
+    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;
+    const costs = usage.filter((u) => u.cost !== undefined);
+    return {
+        prompt_tokens: Math.round(sum((u) => u.prompt_tokens) * scale),
+        completion_tokens: Math.round(sum((u) => u.completion_tokens) * scale),
+        total_tokens: Math.round(sum((u) => u.total_tokens) * scale),
+        ...(costs.length === 0 ? {} : { cost: sum((u) => u.cost ?? 0) * scale }),
+        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 },
+                }),
+        }),
+    });
+}
+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) => ({
+        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 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 } : {}),
+    };
+    let winner;
+    let valid = 0;
+    let won = () => undefined;
+    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);
+        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);
+        const g = gate(a.reply.json);
+        if (g.isOk()) {
+            valid += 1;
+            winner = { from: d, draft: g.Ok(), ms: Date.now() - startedAt, text: a.reply.text };
+            for (const s of drafts)
+                if (s.ended === undefined && s.log.inFlight === true)
+                    s.aborted = true;
+            cancel.abort();
+            won();
+            return;
+        }
+        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) {
+        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 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),
+        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;
+    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);
+        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 g = gate(a.reply.json);
+            if (g.isOk()) {
+                valid += 1;
+                chosen = { from: drafts[0], draft: g.Ok(), ms: Date.now() - startedAt, text: a.reply.text };
+            }
+            else {
+                log.lastError = `mercury brief: gate ${g.Err().message}`;
+                log.cause = "gate";
+                noteSend(log);
+            }
+        }
+    }
+    const aborted = drafts.filter((d) => d.aborted).length;
+    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,
+        ...(winner === undefined ? {} : { winner: winner.from.index, winnerMs: winner.ms, picked: winner.from.index }),
+        aborted,
+        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 c = chosen?.draft;
+    const extra = {
+        ...o.extra(c),
+        fanout,
+        reply: "whole",
+        preambleFrom: "classification",
+        oneCall: true,
+        shapeCall: false,
+        ...(c === undefined
+            ? {}
+            : {
+                addressRepair: [...c.addressRepair],
+                slugsWithWord: mercurySlugsWithWord(c.address.pairs, chosen?.from.words ?? []),
+                ...(c.rooms === undefined ? {} : { roomsDropped: c.rooms.dropped }),
+                ...(c.font === undefined ? {} : { fontDropped: c.font.dropped }),
+                flagsWinner: setFlags(c.shape.flags),
+            }),
+        ...(chosen === undefined ? {} : { text: chosen.text }),
+    };
+    const call = { call: "brief", row: o.row, attempts, startedAt, totals, log, extra };
+    if (chosen === undefined)
+        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 });
+}
+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 stage = { sends: 0, retries: 0 };
     if (args.personWords.trim().length === 0)
-        return Result.Err("mercury: no words to brief from");
+        return stageErr("mercury: no words to brief from", "error", stage, startedAt);
     if (vctx.billing.enforceEnabled) {
         const rCheck = await vctx.billing.checkCredits({ userId: args.userId });
         if (rCheck.isOk() && rCheck.Ok().allowed === false)
-            return Result.Err("mercury: no credits remaining");
+            return stageErr("mercury: no credits remaining", "no-credits", stage, startedAt);
+    }
+    const admission = breaker.admit();
+    if (admission === "open") {
+        vctx.logger.Warn().Any("event", { chatId: args.chatId }).Msg("mercury-first-build-circuit-open");
+        return stageErr("mercury: circuit open after repeated provider failures; skipping to the brief round", "circuit-open", stage, startedAt);
     }
+    const r = await exception2Result(() => pipeline(vctx, args, stage));
+    const failed = r.isErr() && r.Err() instanceof MercuryStageError === false
+        ? stageErr(`mercury: ${r.Err().message}`, "error", stage, startedAt)
+        : r;
+    const out = failed.isErr() && args.signal?.aborted === true
+        ? Result.Err(new MercuryStageError("mercury: cancelled, the first build went to the agent", "cancelled", failed.Err().detail))
+        : failed;
+    if (out.isOk())
+        breaker.record(admission, { ok: true });
+    else {
+        const e = out.Err();
+        breaker.record(admission, { ok: false, cause: e instanceof MercuryStageError ? e.fallbackCause : "error" });
+    }
+    return out;
+}
+function stageErr(message, cause, stage, startedAt, call) {
+    return Result.Err(new MercuryStageError(message, cause, {
+        ...(call === undefined ? {} : { call }),
+        sends: stage.sends,
+        retries: stage.retries,
+        elapsedMs: Date.now() - startedAt,
+    }));
+}
+async function pipeline(vctx, args, stage) {
     const startedAt = Date.now();
-    const row = { chatId: args.chatId, userId: args.userId };
-    const deadlineMs = args.deadlineMs ?? MERCURY_CALL_DEADLINE_MS;
-    const nonce = args.nonce ?? mercuryNonce;
-    const today = args.today ?? new Date().toISOString().slice(0, 10);
-    const rShape = await mercuryCall(vctx, {
+    let lastRow;
+    const keepText = args.keepText === true;
+    const row = {
+        chatId: args.chatId,
+        userId: args.userId,
+        ...(args.onUsage === undefined ? {} : { onUsage: args.onUsage }),
+        ...(keepText ? { keepText: true } : {}),
+        onWritten: (promptId) => {
+            lastRow = promptId;
+            args.onRowWritten?.(promptId);
+        },
+    };
+    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();
+        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,
+            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(),
+        });
+    }
+    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 } : {}),
+                });
+        }
+        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,
-        maxTokens: 400,
+        budget,
+        maxTokens: MERCURY_SHAPE_MAX_TOKENS,
+        onCounts: counted,
         request: () => ({
             schema: mercuryShapeSchema(),
-            messages: mercuryShapeMessages({ personWords: args.personWords, nonce: nonce() }),
+            messages: mercuryShapeMessages({ personWords: args.personWords }),
         }),
         accept: (json) => {
             const parsed = parseMercuryShape(json);
             return parsed.isErr() ? parsed : Result.Ok(fixMercuryShape(parsed.Ok(), args.personWords));
         },
-    });
-    if (rShape.isErr())
-        return Result.Err(rShape);
-    const shape = rShape.Ok();
-    const gated = { texts: new Map() };
-    const rBrief = await mercuryCall(vctx, {
-        call: "brief",
+    }));
+    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,
-        maxTokens: 1600,
-        request: () => {
-            const owed = owedBriefFields(gated);
-            return {
-                schema: mercuryBriefSchema(owed),
-                messages: mercuryBriefMessages({
-                    personWords: args.personWords,
-                    shape,
-                    fields: owed,
-                    words: args.words,
-                    today,
-                    nonce: nonce(),
-                }),
-            };
-        },
-        accept: (json) => {
-            const failed = acceptBriefFields(json, { owed: owedBriefFields(gated), shape, into: gated });
-            return failed.length === 0 ? Result.Ok(true) : Result.Err(`gate ${failed.join(", ")}`);
-        },
-    });
+        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);
-    const input = assembleMercuryCreateVibe({
+        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") ?? "",
@@ -782,16 +3447,53 @@ async function pipeline(vctx, args) {
             icon: gated.texts.get("icon") ?? "",
             pairs: gated.pairs ?? [],
         },
-    });
-    const enrichedPrompt = input.enrichedPrompt ?? "";
-    const rPreamble = await mercuryCall(vctx, {
+        ...(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, nonce: nonce() }),
+            messages: mercuryPreambleMessages({ personWords: args.personWords, shape, enrichedPrompt, style }),
         }),
         accept: (json) => {
             const p = preambleParsed(json);
@@ -800,9 +3502,18 @@ async function pipeline(vctx, args) {
             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);
-    return Result.Ok({ input, preamble: rPreamble.Ok(), shape, elapsedMs: Date.now() - startedAt });
+        return Result.Err(rPreamble.Err());
+    return Result.Ok({
+        input,
+        preamble: rPreamble.Ok(),
+        ...(oneCallReceipt === undefined ? {} : { oneCall: oneCallReceipt }),
+        shape,
+        elapsedMs: Date.now() - startedAt,
+        sends: stage.sends,
+        retries: stage.retries,
+        ...named(),
+    });
 }
 //# sourceMappingURL=mercury-first-build.js.map