@vibes.diy/api-svc 14.3.85 → 14.3.86

package/intern/mercury-first-build.d.ts

@@ -2,14 +2,25 @@ import { Result } from "@adviser/cement";
 import type { CreateVibeToolInput, AppNature } from "@vibes.diy/api-types";
 import type { LLMMessage } from "@vibes.diy/call-ai-v2";
 import type { VibesApiSQLCtx } from "../types.js";
+import { MercuryCircuitBreaker, type MercuryFallbackCause } from "./mercury-resilience.js";
 export declare const MERCURY_FIRST_BUILD_MODEL = "inception/mercury-2.5";
 export declare const MERCURY_FIRST_BUILD_REASONING: {
     readonly effort: "none";
 };
+export type MercuryPlanner = "mercury" | "opus" | "haiku";
+export declare const MERCURY_OPUS_PLANNER_MODEL = "~anthropic/claude-opus-latest";
+export declare const MERCURY_OPUS_PLANNER_DEADLINE_MS = 240000;
+export declare const MERCURY_OPUS_PLANNER_BUDGET_MS = 300000;
+export declare const MERCURY_OPUS_PLANNER_FANOUT = 1;
+export declare const MERCURY_OPUS_PLANNER_MAX_TOKENS = 8000;
+export declare const MERCURY_OPUS_PLANNER_BREAKER: MercuryCircuitBreaker;
+export declare const MERCURY_HAIKU_PLANNER_MODEL = "anthropic/claude-haiku-5.5";
+export declare const MERCURY_HAIKU_PLANNER_DEADLINE_MS = 40000;
+export declare const MERCURY_HAIKU_PLANNER_BUDGET_MS = 50000;
+export declare const MERCURY_HAIKU_PLANNER_BREAKER: MercuryCircuitBreaker;
 export declare const MERCURY_CALL_DEADLINE_MS = 8000;
 export declare const MERCURY_CALL_ATTEMPTS = 2;
 export declare const MERCURY_TRANSIENT_RETRIES = 3;
-export declare const MERCURY_TRANSIENT_BACKOFF_MS = 400;
 export declare const MERCURY_ARCHETYPES: readonly ["personal", "group", "publish", "intake", "open", "toy"];
 export type MercuryArchetype = (typeof MERCURY_ARCHETYPES)[number];
 export declare const MERCURY_FLAGS: readonly ["ai", "composer", "imageGen", "backend", "calendar", "audio", "threeD", "charts", "boardGame", "sensitive"];
@@ -21,6 +32,7 @@ export interface MercuryShape {
     readonly who: string;
     readonly recordNames: readonly string[];
     readonly flags: Readonly<Record<MercuryFlag, boolean>>;
+    readonly keepsToThemselves?: boolean;
 }
 export interface MercuryBriefFields {
     readonly opening: string;
@@ -37,29 +49,161 @@ export type MercuryBriefField = keyof MercuryBriefFields;
 export declare const MERCURY_BRIEF_FIELDS: readonly MercuryBriefField[];
 export declare const MERCURY_SHAPE_SYSTEM = "You classify a person's one-message request for a small web app before a build brief is written. Return only JSON.\n\narchetype, exactly one:\n- personal: one person's own tool (\"for me\", \"my\", \"private\", a tracker, a log, a list, a journal) with no other people named.\n- group: the person names other people who use it with them (we, our, friends, family, team, club, kids, housemates, partner, members, a foursome).\n- publish: the person writes and other people only read (a blog, menu, gallery, portfolio, schedule, zine, \"everyone can read\").\n- intake: strangers or customers submit something without signing up and the person sees the submissions (orders, bookings, requests, sign-ups, replies, reports from the public).\n- open: anyone with the link joins in and adds their own bit (a shared wall, canvas, feed, leaderboard game, community board, swap board, \"anyone can post\").\n- toy: a game, simulator, visual, sound or generator that keeps little or nothing (scores at most).\nTie-breaks: group means other people open the app on their own devices; a calculator, splitter or tool used on one phone \"with friends\" at the table is personal. toy is for games, simulators and visual or sound toys; a tool that analyzes, estimates, designs, counts, tracks or logs stores records and is personal. A \"feed of information\" pulled from the internet is personal with backend true. A test or nonsense phrase is still a request: make the most playful literal app of it (a \"squash bloom soothsayer\" is a fortune teller about squash) and classify that.\n\ncoreAction: 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.\nkind: 2-6 word noun phrase for the app in the person's own nouns. who: who it is for, 2-8 words.\nrecordNames: 1-5 short singular record type names the app stores (toys may have just \"score\" or none).\nflags, each true only when the request itself needs it:\n- ai: the app must read, write or judge free text or photos with a language model (extract facts from pasted words, answer questions, generate text, chat, analyze a picture, suggest recipes).\n- composer: ai is true AND the person types or pastes their own words or photos as the way records get in.\n- imageGen: the app generates pictures.\n- backend: server work the page cannot do: scheduled reminders or digests, a live feed pulled from outside, secret dealing, email.\n- calendar: dates on a calendar, bookings by slot, recurring events, paystub periods.\n- audio: sound or music playback or synthesis.\n- threeD: 3D graphics, a simulator, a world you move through.\n- charts: heatmaps, graphs, statistics views.\n- boardGame: a turn-based card or board game.\n- sensitive: health, money of real people, kids, or the word private.";
 export declare function mercuryShapeSchema(): Record<string, unknown>;
-export declare function mercuryNonce(): string;
 export declare function mercuryShapeMessages(o: {
     readonly personWords: string;
-    readonly nonce: string;
 }): LLMMessage[];
 export declare function parseMercuryShape(raw: unknown): Result<MercuryShape>;
-export declare function fixMercuryShape(shape: MercuryShape, personWords: string): MercuryShape;
-export declare const MERCURY_EXEMPLAR_FIELD = "## How to read this field\n\nEvery 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:\n\n- [personal]  one person's own tool: private, records keyed to their own object so a friend could be let in later.\n- [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.\n- [publish]   the owner writes, everyone reads: a blog, menu, gallery, zine, schedule.\n- [intake]    strangers submit without signing in (orders, bookings, requests, RSVPs); the owner sees and manages what came in.\n- [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.\n- [toy]       a game or visual that keeps little or nothing: scores or a save slot at most.\n\nPick the rows that match the archetype you were given. Take every noun from the person's own words.\n\n## 1. Opening \u2014 one sentence: what it is and who it is for\n\n- [personal] A glaze test notebook for a home potter.\n- [personal] A sourdough starter log for one baker's kitchen.\n- [group]    A tool library for one neighbourhood block, shared by the households on it.\n- [group]    A setlist planner for a four-piece cover band.\n- [publish]  A taco truck menu board the owner updates from their phone and customers read.\n- [publish]  A micro-poetry zine where one editor posts and everyone reads.\n- [intake]   An appointment book for a dog grooming salon: clients book without signing up, the groomer sees every slot.\n- [intake]   A repair drop-off form for a bike shop, with the owner's queue on the other side.\n- [open]     A lost-and-found board for a music festival that anyone with the link can post to.\n- [open]     A wedding photo wall where every guest drops pictures from their phone.\n- [toy]      A hex-grid pong game with a slow-motion ball and a local best score.\n- [toy]      A kaleidoscope you steer with the mouse, with nothing saved.\n\n## 2. Ownership and access \u2014 who owns what, who gets in, who sees what\n\n- [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.\n- [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.\n- [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.\n- [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.\n- [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.\n- [publish]  One editor owns the zine; poem records are creator-writable and world-readable. Readers see the issues.\n- [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.\n- [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.\n- [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.\n- [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.\n- [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.\n- [toy]      The toy keeps its state in memory: it opens instantly, with no sign-in and no records.\n\n## 3. Seed cast \u2014 seed.json demo with a named cast, counts and dates near today\n\n- [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.\n- [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.\n- [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.\n- [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.\n- [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.\n- [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.\n- [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.\n- [toy]      seed.json demo: 6 score records from a small cast including the owner so the Top Scores list opens filled.\n\n## 4. Look note \u2014 one short line: background, accent, card shape, mood\n\n- [personal] Earthy studio: oatmeal background, iron-red accents, chunky rounded tile cards.\n- [personal] Flour-dusted kitchen: warm white, rye brown, a tall rising bar as the hero number.\n- [group]    Workshop pegboard: plywood tones, safety-orange accents, square tool cards with big status chips.\n- [group]    Backstage: near-black, amber stage light accents, setlist rows like gaffer-tape strips.\n- [publish]  Street-food bright: chalkboard dark with chalk-white type and chili-red price tags.\n- [intake]   Clean salon: pale mint, charcoal type, generous slot buttons easy to tap one-handed.\n- [open]     Festival poster: cream paper, bold two-colour print, pinned-note cards with torn edges.\n- [toy]      Neon arcade: deep navy, electric cyan ball, glowing hex outlines.\n\n## 5. Titles, addresses and icon\n\n- pairs: Glaze Ledger / glaze-ledger, Tile Book / tile-book, Kiln Notes / kiln-notes \u2014 icon: a glazed test tile beside a small kiln\n- pairs: Block Tools / block-tools, Maple Street Shelf / maple-street-shelf, Borrow Board / borrow-board \u2014 icon: a hand drill inside a house outline\n- pairs: Truck Board / truck-board, Taco Today / taco-today, Menu Chalk / menu-chalk \u2014 icon: a chalkboard with a taco drawn on it\n- pairs: Groom Book / groom-book, Salon Slots / salon-slots, Paws Diary / paws-diary \u2014 icon: a dog brush beside a clock face\n- pairs: Festival Finds / festival-finds, Lost Tent / lost-tent, Found It / found-it \u2014 icon: a tent peg tied with a ribbon\n- pairs: Hex Pong / hex-pong, Slow Rally / slow-rally, Honey Paddle / honey-paddle \u2014 icon: a hexagonal paddle and a glowing ball";
-export declare 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.\n\nThe 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.";
-export declare function mercuryBriefSchema(fields: readonly MercuryBriefField[]): Record<string, unknown>;
-export declare function mercuryBriefMessages(o: {
+export declare function fixMercuryShape(shape: MercuryShape, personWords: string, opts?: {
+    readonly keepBackend?: boolean;
+}): MercuryShape;
+export declare function mercuryBackendWordsNamed(personWords: string): boolean;
+export declare function parseMercuryDraftShape(raw: unknown, personWords: string): Result<MercuryShape>;
+export interface MercuryOneCallReceipt {
+    readonly draftArchetypes: readonly (MercuryArchetype | null)[];
+    readonly archetypeSplit: boolean;
+    readonly flagsWinner: readonly MercuryFlag[];
+    readonly flagsUnion: readonly MercuryFlag[];
+    readonly backendFilterCleared?: readonly number[];
+    readonly backendFilterKept?: number;
+}
+export interface MercuryPair {
+    readonly title: string;
+    readonly slug: string;
+}
+export interface MercuryAddressEncoding {
+    readonly properties: Readonly<Record<string, Record<string, unknown>>>;
+    readonly rule: string;
+    readonly ask: string;
+    readonly hints: Readonly<Record<string, string>>;
+    readonly example: (title: string, slugs: readonly string[]) => readonly string[];
+    readonly decode: (reply: Readonly<Record<string, unknown>>) => Result<MercuryDecodedAddress>;
+    readonly salvage: (json: unknown) => Record<string, unknown> | undefined;
+}
+export type MercuryAddressRepair = "salvage" | "split" | "label" | "slug-fallback" | "title-from-slug";
+export interface MercuryDecodedAddress {
+    readonly title?: string;
+    readonly slugs: string[];
+    readonly repairs: readonly MercuryAddressRepair[];
+}
+export declare function mercuryAddressEncoding(): MercuryAddressEncoding;
+export declare const MERCURY_ADDRESS: MercuryAddressEncoding;
+export declare function mercurySlugWordsSentence(words: readonly string[]): string;
+export declare 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";
+export interface MercuryRoomsAsk {
+    readonly rooms?: boolean;
+    readonly font?: boolean;
+    readonly screens?: boolean;
+    readonly juice?: MercuryJuice;
+    readonly story?: boolean;
+    readonly preamble?: boolean;
+    readonly classify?: boolean;
+    readonly recordsRules?: boolean;
+}
+export declare const MERCURY_ROOMS_HINT = "an array of 2 or 3 room slugs from the room list";
+export declare const MERCURY_ROOMS_ASK = "Also rooms: an array of 2 or 3 room slugs from the room list.";
+export declare const MERCURY_FONT_HINT = "one font slug from the font list";
+export declare const MERCURY_FONT_ASK = "Also font: one font slug from the font list.";
+export declare const MERCURY_CLASSIFY_HINTS: Readonly<Record<string, string>>;
+export declare function mercuryAnswerSkeleton(fields: readonly MercuryBriefField[], opts?: MercuryRoomsAsk): string;
+export declare function mercuryFieldArchetypes(archetype: MercuryArchetype): MercuryArchetype[];
+export declare function mercuryExemplarField(archetype: MercuryArchetype, address?: MercuryAddressEncoding, recordsRules?: boolean): string;
+export declare const MERCURY_ONECALL_TRIPLES: readonly (readonly [MercuryArchetype, MercuryArchetype, MercuryArchetype])[];
+export declare function mercuryOneCallField(draft: number, address?: MercuryAddressEncoding, recordsRules?: boolean): string;
+export declare 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 declare 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 type MercuryJuice = "examples" | "own-world";
+export type MercuryDepth = "none" | "sub-feature";
+export declare 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 declare 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 declare 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 declare 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 declare 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 \u2014 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 declare 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 declare 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 \u2014 items, amounts, names, a list \u2014 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 declare const MERCURY_ASK_WORDS_RULE = "Keep the ask's genre and capability words exactly as the person wrote them \u2014 3D, first-person, email, a named recipient, a schedule, a fixed number of people \u2014 in the opening, the rules or the screens.";
+export declare 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 declare const MERCURY_RECORDS_HINT = "each record type the app stores, with its fields: \"name (field, field, field); name (field, field)\"";
+export declare const MERCURY_RULES_HINT = "the one to three computations or invariants the ask hinges on, in the person's terms";
+export declare 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 declare 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 declare const MERCURY_CHOPPED_RECORDS_SEED_LINE = "- seed: a small, lively world in the app's own words \u2014 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.";
+export declare const MERCURY_BLOCK_WORLD_TRIGGER = "  - a Minecraft-style block world to build and break blocks in";
+export declare function mercuryBlockWorldNamed(personWords: string): boolean;
+export type MercuryReplyShape = "split" | "whole";
+export declare 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\u2026 customers at the queue browse the menu and make selections by clicking the quantity buttons on their phones.";
+export declare 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\u2026 riders waiting at the counter browse the queue and pick their pickup time by turning the time picker on their phones.";
+export declare function mercuryStoryExample(personWords: string): string;
+export declare function mercuryStoryRule(example: string): string;
+export declare 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 declare 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\" \u2014 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 declare 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";
+export declare const MERCURY_BRIEF_RULES: string;
+export declare const MERCURY_ONECALL_DECIDED = "The classification keys in your reply (archetype, core action, record names, capabilities) decide the brief; follow them.";
+export declare const MERCURY_ONECALL_CLASSIFY: string;
+export declare function mercuryBriefRules(o?: {
+    readonly juice?: MercuryJuice;
+    readonly depth?: MercuryDepth;
+    readonly reply?: MercuryReplyShape;
+    readonly personWords?: string;
+    readonly recordsRules?: boolean;
+}): string;
+export type MercuryStyle = "base" | "chopped";
+export declare const MERCURY_CHOPPED_BRIEF_RULES = "These parts are turned up, in the person's own nouns, at the field's own lengths:\n- opening: reads like you can already see the app \u2014 what it is, who it is for, and the one moment that makes it fun to open.\n- seed: a small world in words \u2014 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.\n- look: a scene \u2014 a surface, a palette, a card shape and one gesture of mood \u2014 in under twenty words.\nThe 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 declare const MERCURY_CHOPPED_SEED_LINE = "- seed: a small world in words \u2014 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 declare const MERCURY_CHOPPED_OWN_WORLD_SEED_LINE = "- seed: a small world in words \u2014 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 declare const MERCURY_CHOPPED_OWN_WORLD_BRIEF_RULES: string;
+export declare const MERCURY_CHOPPED_RECORDS_BRIEF_RULES: string;
+export declare const MERCURY_ONECALL_CLASSIFY_RECORDS: string;
+export declare 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.";
+export declare function mercuryBriefKeys(fields: readonly MercuryBriefField[]): string[];
+export declare function mercuryBriefSchema(fields: readonly MercuryBriefField[], opts?: MercuryRoomsAsk): Record<string, unknown>;
+interface MercuryBriefMessageOpts {
     readonly personWords: string;
-    readonly shape: MercuryShape;
     readonly fields: readonly MercuryBriefField[];
     readonly words: readonly string[];
-    readonly today: string;
-    readonly nonce: string;
+    readonly style?: MercuryStyle;
+    readonly rooms?: boolean;
+    readonly font?: boolean;
+    readonly juice?: MercuryJuice;
+    readonly depth?: MercuryDepth;
+    readonly screens?: boolean;
+    readonly reply?: MercuryReplyShape;
+    readonly story?: boolean;
+    readonly preamble?: boolean;
+    readonly recordsRules?: boolean;
+    readonly recordsOwed?: boolean;
+}
+export declare function mercuryBriefMessages(o: MercuryBriefMessageOpts & {
+    readonly shape: MercuryShape;
+}): LLMMessage[];
+export declare function mercuryOneCallBriefMessages(o: MercuryBriefMessageOpts & {
+    readonly draft: number;
 }): LLMMessage[];
 export declare function cleanMercuryText(text: string): string;
-export declare function gateMercuryPairs(raw: unknown): Result<{
+export type MercuryRepair = "demo-prefix" | "archetype-tag";
+export declare function stripMercuryArchetypeTag(text: string): {
+    readonly text: string;
+    readonly repaired: boolean;
+};
+export declare function repairMercuryField(field: Exclude<MercuryBriefField, "pairs">, value: string): {
+    readonly value: string;
+    readonly repaired: readonly MercuryRepair[];
+};
+export declare function prepareMercuryField(field: Exclude<MercuryBriefField, "pairs">, value: string): {
+    readonly gate: string;
+    readonly value: string;
+    readonly misses: readonly MercuryRepair[];
+};
+export interface MercuryGatedAddress {
+    readonly pairs: MercuryPair[];
+    readonly fallback: boolean;
+    readonly tagged: boolean;
+}
+export declare function gateMercuryAddress(o: {
     readonly title: string;
-    readonly slug: string;
-}[]>;
+    readonly slugs: readonly string[];
+}): Result<MercuryGatedAddress>;
+export declare function mercurySlugsWithWord(pairs: readonly MercuryPair[], words: readonly string[]): number;
 export declare function gateMercuryField(o: {
     readonly field: Exclude<MercuryBriefField, "pairs">;
     readonly value: string;
@@ -67,20 +211,83 @@ export declare function gateMercuryField(o: {
 }): string[];
 export declare const MERCURY_ACCESS_TAIL: Readonly<Record<MercuryArchetype, string>>;
 export declare function mercuryAccessLine(shape: MercuryShape, access: string): string;
-export declare function mercurySkills(shape: MercuryShape): string[];
-export declare function mercuryNature(shape: MercuryShape): AppNature;
+export declare function mercurySkills(shape: MercuryShape, opts?: {
+    readonly personWords?: string;
+    readonly recordsRules?: boolean;
+}): string[];
+export type MercuryReadPosture = "private" | "members" | "public";
+export type MercuryWritePosture = "owner" | "members";
+export interface MercuryAccessPosture {
+    readonly read?: MercuryReadPosture;
+    readonly write?: MercuryWritePosture;
+}
+export declare function mercuryAccessPosture(access: string): MercuryAccessPosture;
+export declare function mercuryDuoConflict(a: {
+    readonly shape: MercuryShape;
+    readonly access: string;
+}, b: {
+    readonly shape: MercuryShape;
+    readonly access: string;
+}, personWords: string): string | undefined;
+export declare function mercuryNature(shape: MercuryShape, personWords: string): AppNature;
 export declare function mercuryWorkflowLine(shape: MercuryShape): string;
-export declare function assembleMercuryCreateVibe(o: {
+interface MercuryAssembly {
     readonly personWords: string;
     readonly shape: MercuryShape;
     readonly fields: MercuryBriefFields;
-}): CreateVibeToolInput;
+    readonly rooms?: readonly string[];
+    readonly font?: string;
+    readonly screens?: string;
+    readonly story?: string;
+    readonly preamble?: string;
+    readonly reply?: MercuryReplyShape;
+    readonly partner?: MercuryTake;
+    readonly capabilityFlags?: Readonly<Record<MercuryFlag, boolean>>;
+    readonly recordsRules?: boolean;
+    readonly records?: string;
+    readonly rules?: string;
+}
+export interface MercuryTake {
+    readonly opening: string;
+    readonly access: string;
+    readonly seed: string;
+    readonly look: string;
+    readonly records?: string;
+    readonly rules?: string;
+    readonly screens?: string;
+    readonly story?: string;
+    readonly preamble?: string;
+}
+export interface MercuryGatedRooms {
+    readonly rooms?: readonly string[];
+    readonly dropped: number;
+}
+export declare function gateMercuryRooms(raw: unknown): MercuryGatedRooms;
+export interface MercuryGatedFont {
+    readonly font?: string;
+    readonly dropped: number;
+}
+export declare function gateMercuryFont(raw: unknown): MercuryGatedFont;
+export interface MercuryGatedScreens {
+    readonly screens?: string;
+    readonly dropped: number;
+}
+export declare function gateMercuryScreens(raw: unknown): MercuryGatedScreens;
+export interface MercuryGatedStory {
+    readonly story?: string;
+    readonly dropped: number;
+    readonly misses?: readonly string[];
+}
+export declare function gateMercuryStory(raw: unknown): MercuryGatedStory;
+export declare function gateMercuryWholePreamble(text: string): string[];
+export declare function mercuryPreambleBrief(o: MercuryAssembly): string;
+export declare function assembleMercuryCreateVibe(o: MercuryAssembly): CreateVibeToolInput;
 export declare 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 \u2014 the builder works out everything else after you speak. Start with \"I'm making\" or \"I'm building\", and write it as plain sentences to the person.";
 export declare function mercuryPreambleMessages(o: {
     readonly personWords: string;
     readonly shape: MercuryShape;
     readonly enrichedPrompt: string;
-    readonly nonce: string;
+    readonly style?: MercuryStyle;
 }): LLMMessage[];
 export declare function mercuryPreambleSchema(): Record<string, unknown>;
 export declare function gateMercuryPreamble(o: {
@@ -102,20 +309,383 @@ export interface MercuryCallRecord {
     readonly servedModel?: string;
     readonly usage: readonly MercuryUsage[];
     readonly error?: string;
+    readonly cause?: MercuryFallbackCause;
+    readonly sends: number;
+    readonly retries: number;
+    readonly history?: readonly string[];
+    readonly reasoningTokens?: number;
+    readonly passedThrough?: readonly MercuryRepair[];
+    readonly addressRepair?: readonly MercuryAddressRepair[];
+    readonly slugsWithWord?: number;
+    readonly roomsDropped?: number;
+    readonly fontDropped?: number;
+    readonly fanout?: MercuryFanout;
+    readonly juice?: MercuryJuice;
+    readonly depth?: MercuryDepth;
+    readonly screensDropped?: number;
+    readonly reply?: MercuryReplyShape;
+    readonly preambleFrom?: "brief" | "classification";
+    readonly storyChars?: number;
+    readonly storyDropped?: number;
+    readonly preambleChars?: number;
+    readonly softMisses?: Readonly<Record<string, readonly string[]>>;
+    readonly coerced?: readonly string[];
+    readonly fieldsDropped?: readonly string[];
+    readonly preambleFallback?: 1;
+    readonly duo?: true;
+    readonly duoDrafts?: readonly number[];
+    readonly duoBreadth?: readonly number[];
+    readonly duoPool?: number;
+    readonly duoArchetypes?: readonly MercuryArchetype[];
+    readonly duoConflict?: true;
+    readonly duoConflictReason?: string;
+    readonly recordsRules?: true;
+    readonly recordsDropped?: number;
+    readonly rulesDropped?: number;
+    readonly oneCall?: true;
+    readonly shapeCall?: false;
+    readonly draftArchetypes?: readonly (MercuryArchetype | null)[];
+    readonly archetypeSplit?: boolean;
+    readonly flagsWinner?: readonly MercuryFlag[];
+    readonly flagsUnion?: readonly MercuryFlag[];
+    readonly backendFilterCleared?: readonly number[];
+    readonly backendFilterKept?: number;
+    readonly planner?: Exclude<MercuryPlanner, "mercury">;
+    readonly format?: MercuryFormat;
+    readonly thinkAloud?: {
+        readonly narrationChars: number;
+        readonly specChars: number;
+        readonly guessLines: number;
+    };
+    readonly cards?: {
+        readonly preambleChars: number;
+        readonly cards: number;
+        readonly acceptLines: number;
+        readonly ruleLines: number;
+        readonly guessLines: number;
+        readonly dataRecords: number;
+    };
+    readonly fim?: MercuryFimReceipt;
+    readonly text?: string;
+    readonly partialText?: string;
+    readonly duoTexts?: readonly string[];
+    readonly filledText?: string;
+}
+export type MercuryFormat = "prose" | "thinkaloud" | "cards" | "cards-fim";
+export interface MercuryBilled {
+    readonly prompt_tokens: number;
+    readonly completion_tokens: number;
+    readonly total_tokens: number;
+    readonly cost?: number;
+    readonly estimated: number;
+}
+export interface MercuryPickCandidate {
+    readonly draft: number;
+    readonly breadth: number;
+    readonly softMisses: number;
+    readonly ms: number;
+    readonly archetype?: MercuryArchetype;
+}
+export interface MercuryDuoReceipt {
+    readonly drafts: readonly number[];
+    readonly breadth: readonly number[];
+    readonly pool?: number;
+    readonly candidates?: readonly MercuryPickCandidate[];
+    readonly archetypes?: readonly MercuryArchetype[];
+    readonly archetypeSplit?: boolean;
+    readonly conflict?: string;
+}
+export interface MercuryFanout {
+    readonly drafts: number;
+    readonly valid: number;
+    readonly winner?: number;
+    readonly winnerMs?: number;
+    readonly picked?: number;
+    readonly candidates?: readonly MercuryPickCandidate[];
+    readonly pickWaitMs?: number;
+    readonly aborted: number;
+    readonly throttled?: number;
+    readonly billed: MercuryBilled;
 }
+export interface MercuryRowTarget {
+    readonly chatId: string;
+    readonly userId: string;
+    readonly onUsage?: (rounds: readonly MercuryUsageRound[]) => void;
+    readonly keepText?: boolean;
+    readonly onWritten?: (promptId: string) => void;
+}
+export type MercuryUsageRound = MercuryUsage & {
+    readonly model: string;
+    readonly role: "mercury";
+};
+export declare function recordMercuryDispatched(vctx: VibesApiSQLCtx, o: {
+    readonly chatId: string;
+    readonly promptId: string;
+    readonly enrichedPrompt: string;
+}): Promise<void>;
+export declare function recordMercuryRace(vctx: VibesApiSQLCtx, o: {
+    readonly chatId: string;
+    readonly promptId: string;
+    readonly race: object;
+}): Promise<void>;
+export declare function recordMercuryFim(vctx: VibesApiSQLCtx, o: {
+    readonly chatId: string;
+    readonly promptId: string;
+    readonly fim: MercuryFimReceipt;
+    readonly filledText?: string;
+}): Promise<void>;
+export interface MercuryProseExample {
+    readonly ask: string;
+    readonly brief: string;
+}
+export declare const MERCURY_PROSE_FORMAT_EXAMPLES: readonly MercuryProseExample[];
+export declare const MERCURY_PROSE_SYSTEM: string;
+export declare function mercuryProseBriefSchema(opts?: {
+    readonly rooms?: boolean;
+    readonly font?: boolean;
+}): Record<string, unknown>;
+export declare function mercuryProseBriefMessages(o: {
+    readonly personWords: string;
+    readonly words: readonly string[];
+    readonly rooms?: boolean;
+    readonly font?: boolean;
+}): LLMMessage[];
+interface MercuryProseDraft {
+    readonly shape: MercuryShape;
+    readonly brief: string;
+    readonly address: MercuryGatedAddress;
+    readonly addressRepair: readonly MercuryAddressRepair[];
+    readonly rooms?: MercuryGatedRooms;
+    readonly font?: MercuryGatedFont;
+}
+export declare function gateMercuryProseDraft(json: unknown, o: {
+    readonly personWords: string;
+    readonly askRooms: boolean;
+}): Result<MercuryProseDraft>;
+export declare function assembleMercuryProseCreateVibe(o: {
+    readonly personWords: string;
+    readonly draft: MercuryProseDraft;
+}): CreateVibeToolInput;
+export declare function mercuryProsePreamble(draft: MercuryProseDraft): string;
+export declare const MERCURY_THINKALOUD_MARKER = "--- SPEC ---";
+export declare const MERCURY_THINKALOUD_SPEC_HINTS: Readonly<Record<string, string>>;
+export declare function mercuryThinkAloudSystem(o?: {
+    readonly rooms?: boolean;
+    readonly font?: boolean;
+}): string;
+export declare function mercuryThinkAloudMessages(o: {
+    readonly personWords: string;
+    readonly words: readonly string[];
+    readonly rooms?: boolean;
+    readonly font?: boolean;
+}): LLMMessage[];
+export interface MercuryThinkAloudReply {
+    readonly narration: string;
+    readonly spec: string;
+    readonly keys: Readonly<Record<string, string>>;
+    readonly guessLines: number;
+}
+export declare function parseMercuryThinkAloud(text: string): MercuryThinkAloudReply | undefined;
+export interface MercuryThinkAloudDraft {
+    readonly shape: MercuryShape;
+    readonly reply: string;
+    readonly narration: string;
+    readonly spec: string;
+    readonly address: MercuryGatedAddress;
+    readonly addressRepair: readonly MercuryAddressRepair[];
+    readonly rooms?: MercuryGatedRooms;
+    readonly font?: MercuryGatedFont;
+    readonly softMisses: Readonly<Record<string, readonly string[]>>;
+    readonly guessLines: number;
+}
+export declare const MERCURY_THINKALOUD_DEFAULT_ARCHETYPE: MercuryArchetype;
+export declare function gateMercuryThinkAloud(raw: unknown, o: {
+    readonly personWords: string;
+    readonly askRooms: boolean;
+}): Result<MercuryThinkAloudDraft>;
+export declare const MERCURY_TESTER_REPLY_INTRO = "A fast tester's first read:";
+export declare const MERCURY_TESTER_REPLY_RULE = "Guesses only; the creator's words win.";
+export declare function mercuryTesterReplyEnrichedPrompt(reply: string, personWords: string): string;
+export declare function assembleMercuryThinkAloudCreateVibe(o: {
+    readonly personWords: string;
+    readonly draft: MercuryThinkAloudDraft;
+}): CreateVibeToolInput;
+export declare function mercuryThinkAloudPreamble(draft: MercuryThinkAloudDraft): string;
+export declare const MERCURY_CARDS_MARKER = "--- CARDS ---";
+export declare const MERCURY_CARDS_APP_MARKER = "--- APP ---";
+export declare const MERCURY_CARDS_TAIL_HINTS: Readonly<Record<string, string>>;
+export declare 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 declare const MERCURY_CARDS_SHAPE = "As a <role>, I <action on a named record>, so that <outcome>.\n  Accept: <one testable line, in terms of records and fields>\n  Accept: <another>\n  Data: <Record>{<field>, <field>, ...}\n  Rule: <a value this card depends on and how it comes about, said loosely in one plain English sentence a friend would understand>";
+export declare const MERCURY_CARDS_RULES = "Rules:\n- Use the person's own nouns for records, roles and actions.\n- Give what the person asked for plus what those parts need in order to work.\n- 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 declare function mercuryCardsSystem(o?: {
+    readonly rooms?: boolean;
+    readonly font?: boolean;
+}): string;
+export declare function mercuryCardsMessages(o: {
+    readonly personWords: string;
+    readonly words: readonly string[];
+    readonly rooms?: boolean;
+    readonly font?: boolean;
+}): LLMMessage[];
+export interface MercuryCardsReply {
+    readonly lines: readonly string[];
+    readonly preamble: string;
+    readonly cardsMarkerAt?: number;
+    readonly appMarkerAt?: number;
+    readonly cardLines: readonly number[];
+    readonly keys: Readonly<Record<string, string>>;
+    readonly dataRecords: readonly string[];
+    readonly acceptLines: number;
+    readonly ruleLines: number;
+    readonly guessLines: number;
+}
+export declare function parseMercuryCards(text: string): MercuryCardsReply;
+export interface MercuryCardsDraft {
+    readonly shape: MercuryShape;
+    readonly reply: string;
+    readonly parsed: MercuryCardsReply;
+    readonly address: MercuryGatedAddress;
+    readonly addressRepair: readonly MercuryAddressRepair[];
+    readonly rooms?: MercuryGatedRooms;
+    readonly font?: MercuryGatedFont;
+    readonly softMisses: Readonly<Record<string, readonly string[]>>;
+}
+export declare function gateMercuryCards(raw: unknown, o: {
+    readonly personWords: string;
+    readonly askRooms: boolean;
+}): Result<MercuryCardsDraft>;
+export declare const MERCURY_FIM_MODEL = "mercury-coder";
+export declare const MERCURY_FIM_URL = "https://api.inceptionlabs.ai/v1/fim/completions";
+export declare const MERCURY_FIM_MAX_TOKENS = 2000;
+export declare const MERCURY_FIM_STOP: readonly string[];
+export declare const MERCURY_FIM_CALL_DEADLINE_MS = 20000;
+export declare const MERCURY_FIM_BUDGET_MS = 40000;
+export declare const MERCURY_FIM_CONCURRENCY = 8;
+export declare const MERCURY_FIM_PRICE: {
+    readonly inputUsdPerMTok: 0.25;
+    readonly outputUsdPerMTok: 1;
+};
+export declare function mercuryFimUsageRound(fim: MercuryFimReceipt): MercuryUsageRound | undefined;
+export declare const MERCURY_FIM_WAVES: readonly ["see", "expect"];
+export type MercuryFimSlot = (typeof MERCURY_FIM_WAVES)[number];
+export declare const MERCURY_FIM_SEEDS: Readonly<Record<MercuryFimSlot, string>>;
+export declare function mercuryFimHeader(personWords: string): string;
+export interface MercuryFimReceipt {
+    readonly status: "ok" | "no-key" | "no-cards" | "failed";
+    readonly model: string;
+    readonly cards: number;
+    readonly slots: number;
+    readonly filled: number;
+    readonly empty: number;
+    readonly failed: number;
+    readonly ms: number;
+    readonly promptTokens: number;
+    readonly completionTokens: number;
+    readonly errors?: readonly string[];
+}
+export declare function renderMercuryCardsFills(o: {
+    readonly lines: readonly string[];
+    readonly bodyEnd: number;
+    readonly cardLines: readonly number[];
+    readonly fills: ReadonlyMap<string, string>;
+    readonly gap?: string;
+}): string;
+export declare function mercuryFimRequest(o: {
+    readonly personWords: string;
+    readonly lines: readonly string[];
+    readonly bodyEnd: number;
+    readonly cardLines: readonly number[];
+    readonly fills: ReadonlyMap<string, string>;
+    readonly gap: string;
+}): {
+    readonly model: string;
+    readonly prompt: string;
+    readonly suffix: string;
+    readonly max_tokens: number;
+    readonly stop: string[];
+};
+export declare function mercuryCardsFim(vctx: Pick<VibesApiSQLCtx, "inferenceFetch">, o: {
+    readonly draft: MercuryCardsDraft;
+    readonly personWords: string;
+    readonly apiKey?: string;
+    readonly deadlineMs?: number;
+    readonly budgetMs?: number;
+    readonly url?: string;
+    readonly cancel?: AbortSignal;
+}): Promise<{
+    readonly reply: string;
+    readonly receipt: MercuryFimReceipt;
+}>;
+export declare function assembleMercuryCardsCreateVibe(o: {
+    readonly personWords: string;
+    readonly draft: MercuryCardsDraft;
+    readonly reply: string;
+}): CreateVibeToolInput;
+export declare function mercuryCardsPreamble(draft: MercuryCardsDraft, personWords: string): string;
 export interface MercuryFirstBuild {
     readonly input: CreateVibeToolInput;
     readonly preamble: string;
+    readonly preambleFrom?: "call" | "brief" | "classification";
+    readonly storyChars?: number;
+    readonly duo?: MercuryDuoReceipt;
+    readonly oneCall?: MercuryOneCallReceipt;
+    readonly planner?: Exclude<MercuryPlanner, "mercury">;
+    readonly format?: MercuryFormat;
+    readonly fim?: MercuryFimReceipt;
     readonly shape: MercuryShape;
     readonly elapsedMs: number;
+    readonly sends?: number;
+    readonly retries?: number;
+    readonly rowPromptId?: string;
 }
 export interface RunMercuryFirstBuildArgs {
     readonly chatId: string;
     readonly userId: string;
     readonly personWords: string;
     readonly words: readonly string[];
+    readonly style?: MercuryStyle;
     readonly deadlineMs?: number;
-    readonly nonce?: () => string;
-    readonly today?: string;
+    readonly budgetMs?: number;
+    readonly rateLimitedBudgetMs?: number;
+    readonly breaker?: MercuryCircuitBreaker;
+    readonly onUsage?: (rounds: readonly MercuryUsageRound[]) => void;
+    readonly wordBag?: (count: number) => string[];
+    readonly rooms?: boolean;
+    readonly juice?: MercuryJuice;
+    readonly depth?: MercuryDepth;
+    readonly reply?: MercuryReplyShape;
+    readonly duo?: boolean;
+    readonly duoPool?: number;
+    readonly oneCall?: boolean;
+    readonly recordsRules?: boolean;
+    readonly planner?: MercuryPlanner;
+    readonly format?: "skeleton" | MercuryFormat;
+    readonly fimApiKey?: string;
+    readonly fimUrl?: string;
+    readonly keepText?: boolean;
+    readonly signal?: AbortSignal;
+    readonly onRowWritten?: (promptId: string) => void;
 }
+export declare function coerceMercuryText(v: unknown): {
+    readonly text?: string;
+    readonly coerced: boolean;
+};
+export declare const MERCURY_DROP_OVER_BOUND = 3;
+export declare const MERCURY_BRIEF_FANOUT = 4;
+export declare const MERCURY_SHAPE_MAX_TOKENS = 800;
+export declare const MERCURY_PICK_WAIT_MS = 1500;
+export declare const MERCURY_PICK_COUNT = 2;
+export declare const MERCURY_DUO_PICK_COUNT = 3;
+export declare const MERCURY_ONECALL_EXTRA_TOKENS = 400;
+export declare function mercuryBreadth(o: {
+    readonly screens?: string;
+    readonly opening: string;
+    readonly seed?: string;
+    readonly access?: string;
+}): number;
+export declare const MERCURY_PROSE_MAX_TOKENS = 3200;
+export declare const MERCURY_THINKALOUD_MAX_TOKENS = 16000;
+export declare const MERCURY_THINKALOUD_DEADLINE_MS = 20000;
+export declare const MERCURY_THINKALOUD_BUDGET_MS = 25000;
 export declare function runMercuryFirstBuild(vctx: VibesApiSQLCtx, args: RunMercuryFirstBuildArgs): Promise<Result<MercuryFirstBuild>>;
+export {};