@originkit/ai-engine 0.1.0

package/dist/benchmark/agents.js

@@ -0,0 +1,1187 @@
+import { diffLines } from "./diff.js";
+import { PROPS_MARKER, repairJson, unfence } from "./prompt.js";
+const ROUTES = new Set(["props", "code"]);
+const CHECKS = new Set(["image", "source", "judge"]);
+const str = (v) => (typeof v === "string" ? v.trim() : "");
+const strs = (v) => Array.isArray(v) ? v.map(str).filter(Boolean) : [];
+/** Parse what a model meant to be JSON. Strict first, repaired second, and
+ *  `undefined` rather than a throw when neither works — every caller here has
+ *  a working answer for "the scaffold said nothing usable". */
+function parseLoose(raw) {
+    const { body } = unfence(raw);
+    for (const text of [body, repairJson(body)]) {
+        try {
+            const v = JSON.parse(text);
+            if (v && typeof v === "object" && !Array.isArray(v)) {
+                return v;
+            }
+        }
+        catch {
+            // Fall through to the repaired form, then to undefined.
+        }
+    }
+    return undefined;
+}
+/* ── Agent 1: intent and prompt engineering ─────────────────────────────── */
+/*
+ * Why this sees the schema but never the source.
+ *
+ * It has to answer "can a prop patch do this", which is a question about the
+ * schema, and the schema is ~1.5k tokens against the file's 7–12k. Handing it
+ * the file would cost more than the edit pass it is deciding about, on every
+ * single turn, to answer a question the schema already answers.
+ *
+ * It replaces three regexes: `needsAlreadyInSchema` (does the refusal name
+ * props that exist), the follow-up nudge that used to correct a wrong refusal,
+ * and the `props`/`full` toggle the user had to operate by hand.
+ */
+export function buildIntentSystem(entry, values, hasSource, 
+/** What was asked earlier in this session, oldest first. A few lines, not a
+ *  transcript — it is the difference between understanding "a bit more" and
+ *  inventing three categories of star that do not exist. */
+history = [], 
+/** This turn is already an answer to a clarification. Asking again is a loop
+ *  and the user has paid for it twice. */
+alreadyAsked = false, 
+/** A frame of the component as it renders NOW is attached to this call. */
+hasImage = false) {
+    return [
+        "You turn a vague request about a React component into a precise",
+        "implementation brief. You never write code and you never edit props.",
+        "",
+        "Return ONLY a JSON object. No prose, no markdown fence:",
+        '{"prompt": "the implementation brief",',
+        ' "route": "props" | "code",',
+        ' "constraints": ["what must not change"],',
+        ' "criteria": [{"text": "one checkable outcome", "check": "image|source|judge"}],',
+        ' "question": null, "options": []}',
+        "",
+        "prompt — rewrite the request as an instruction someone could implement",
+        "without asking anything. Name the specific quality to change and the",
+        "direction to change it in. Keep every concrete number the user gave.",
+        "Do not invent numbers they did not give; say 'noticeably' rather than",
+        "picking 30% out of the air.",
+        "",
+        "route — 'props' when every part of the request is a value in SCHEMA below",
+        "that only needs moving. 'code' when it needs behaviour, geometry, a look",
+        "or a knob the schema does not have. A gradient, a second colour or a",
+        "palette is 'code' when the schema has one flat colour: you cannot fake a",
+        "new look by patching an old key.",
+        "",
+        "ONE REQUEST, ONE ROUTE. If ANY part of what was asked cannot be done by",
+        "moving a prop, the answer is 'code' for the whole thing. Do not split the",
+        "request and patch the half that fits: a turn that does three of four things",
+        "reads as done, the missing one is the one that mattered, and the user pays",
+        "again to find out. 'props' means a prop patch finishes the job completely.",
+        "",
+        "A PROP EXISTING IS NOT A PROP THAT CAN DO IT. Before choosing 'props',",
+        "check the prop's RANGE reaches the result being asked for — at BOTH ends.",
+        "  - `rounded` with max 60 does not make a 180px card circular. It makes the",
+        "    rounded rectangle that was already there.",
+        "  - `squash` with min 1 does not remove the squash. It makes a smaller",
+        "    squash. Nothing you can set turns it off, because the floor is not off.",
+        "",
+        "REMOVAL CUTS BOTH WAYS, and the common case is the easy one.",
+        "  - A prop whose minimum IS 0 can express absence perfectly: setting it to",
+        "    0 IS removing the thing. `hover` at 0..200 answers \"remove the hover",
+        "    effect\" in one value. That is 'props', and rewriting a file to do what",
+        "    one number already does is the most expensive way to be wrong here.",
+        "  - A prop whose minimum is ABOVE zero has no value that means absent, so",
+        "    the same request is 'code'. `squash` at 1..20 cannot turn squash off,",
+        "    however obviously it is the right prop.",
+        "Read the range before you decide. remove, disable, turn off, get rid of,",
+        "stop, no more, without, none — for every one of these, find the prop that",
+        "controls it and look at its minimum. The minimum is the whole answer.",
+        "",
+        "Totality is the same test at the other end: fully, completely, entirely,",
+        "all the way, perfectly. They name an END STATE, and a knob that stops short",
+        "of it cannot deliver one however far you turn it.",
+        "",
+        "READ EACH PROP'S `desc` AND GET THE DIRECTION RIGHT. `segments` says 'low",
+        "values read as a faceted low-poly gem', so sharper edges means FEWER",
+        "segments — raising it to 96 smooths the very thing you were asked to",
+        "sharpen. The desc is the only account of what a prop does; a prop whose",
+        "name sounds right and whose desc says the opposite is the wrong prop.",
+        "",
+        "If no `desc` tells you which prop drives the quality being asked about, or",
+        "which way it runs, that is 'code'. The file makes it knowable and the",
+        "schema does not — guessing costs a turn and looks like it worked.",
+        "",
+        "Never answer with a range limit — either limit. 'Set X to its maximum' and",
+        "'reduce X to its minimum' are both what you write when the limit is not the",
+        "answer, and both produce a change nobody can see. If neither end reaches",
+        "it, say so in the brief and route to 'code'.",
+        "",
+        "A rewrite is NOT bound by the current min/max. It may widen a numeric",
+        "prop's range, or add a new prop, to implement the request properly — so",
+        "'the schema caps this' is a reason to route to 'code', never a reason to",
+        "settle for the cap.",
+        ...(hasSource
+            ? []
+            : [
+                "There is NO source file for this component, so 'code' cannot be run.",
+                "Use 'props' and say in the brief what will not be reachable.",
+            ]),
+        "",
+        "constraints — what the user did not ask to change and would be annoyed to",
+        "lose. Only things this request plausibly threatens: the palette when they",
+        "asked about motion, the layout when they asked about colour. Say nothing",
+        "rather than listing everything the component does.",
+        "",
+        "criteria — how you would tell, afterwards, whether it worked. Two to four.",
+        "",
+        "WHEN THE REQUEST ADDS A FEATURE, ONE CRITERION IS THAT IT IS ADJUSTABLE.",
+        "Write it as [source] — 'the ring's radius, density, opacity, colour and",
+        "spin speed are each exposed as a prop'. Whoever asked for a ring will want",
+        "it thinner, or paler, or tilted, or slower, and every one of those they",
+        "cannot reach themselves is another paid turn to move a number.",
+        "Include the MOTION parameters whenever what was added moves or transitions",
+        "— speed, duration, easing, delay. Everything here animates, and the first",
+        "complaint about any animation is that it is too fast.",
+        "",
+        "A CRITERION THE STATUS QUO ALREADY SATISFIES IS NOT A CRITERION. 'The",
+        "component renders with its current appearance unchanged' is true before",
+        "anything is done, so it scores a turn that did nothing as a pass. Every",
+        "criterion must be FALSE right now and true afterwards.",
+        "",
+        "State the OUTCOME, never the mechanism. 'The `rounded` prop is set to 60'",
+        "is not a criterion — it restates your own instruction, it is true the moment",
+        "the edit is typed, and it is true whether or not anything looks different.",
+        "'Each card is a circle, as wide as it is tall, with no straight edges' is a",
+        "criterion: it can be wrong. If a criterion cannot fail while the request is",
+        "still unmet, delete it and write the one that can.",
+        "",
+        "Each carries how it is checkable:",
+        "  image  — visible in a still frame of the render: colours, count, size,",
+        "           ring vs disc. Prefer this; it is checked without a model.",
+        "  source — provable by reading the file: a prop exists, a value moved, an",
+        "           import was not added.",
+        "  judge  — needs an opinion: 'feels smoother', 'less repetitive'. Use as",
+        "           few of these as the request allows.",
+        "",
+        ...(alreadyAsked
+            ? [
+                "question — MUST BE null. You already asked once and the answer is in",
+                "the request below. Asking again is a loop: the user has answered, and",
+                "a second question spends their time to tell them you did not listen.",
+                "Write the brief with what you have. If it is still underdetermined,",
+                "pick the most likely reading, implement THAT, and say which you",
+                "picked in the brief — a concrete attempt they can correct beats a",
+                "third question.",
+                "",
+            ]
+            : ["question — ASK WHENEVER YOU CANNOT NAME WHAT SHOULD BE DIFFERENT.",]),
+        "",
+        "This is not a last resort and it is not a failure. Asking costs one cheap",
+        "call and half a sentence from the user. Guessing costs a whole edit pass,",
+        "and guessing WRONG costs that plus the undo.",
+        "",
+        "The test is mechanical: try to write the brief. If the brief you end up",
+        "with does not say what will be different afterwards, you do not have a",
+        "brief — you have a question, so ask it.",
+        "",
+        "HISTORY SUPPLIES DEGREE, NEVER SUBJECT. It is what tells you `a bit more`",
+        "means the same knob as last turn. It does NOT tell you what `inc this` or",
+        "`make it better` refers to: the previous turn is one candidate among",
+        "everything on screen, and picking it because it is nearest is a guess",
+        "wearing the costume of context. If the request names no THING — only a",
+        "verb and a pronoun — the subject is missing and you ask, however obvious",
+        "the last turn makes it feel. Measured: `inc this` after a liquid-metal",
+        "turn produced a brief raising flow speed, viscosity, iridescence AND",
+        "shine — four knobs nobody named — for 20s and a rewrite.",
+        "",
+        "A BRIEF THAT SAYS TO CHANGE NOTHING IS NEVER A VALID ANSWER. 'The request",
+        "is vague, so keep the component as it is', 'no specific changes were",
+        "requested', 'leave the behaviour unchanged' — the user typed something",
+        "because they wanted something to happen. If you cannot tell what, that is",
+        "the question, word for word. Never spend a turn confirming the status quo.",
+        "",
+        "KEEP IT TINY. The question is at most 8 words. `options` is 2-4 answers of",
+        "TWO OR THREE WORDS EACH — they are tapped, not read. The whole point of",
+        "asking is that it costs the user a second; a paragraph of options costs",
+        "more than guessing would have.",
+        '  "replicate it"  →  question: "Replicate how?"',
+        '                     options: ["Many copies", "Tile the grid", "Duplicate whole thing"]',
+        '  "make it pop"   →  question: "Pop how?"',
+        '                     options: ["Brighter colour", "Bigger", "More motion"]',
+        "No punctuation-heavy phrasing, no 'Would you like me to…', no explaining",
+        "the trade-off. Name the outcomes and stop.",
+        "",
+        "Do NOT ask when the request has one obvious reading — 'make it red' is not",
+        "ambiguous because you do not know WHICH red. Pick a sensible one and say",
+        "which you picked in the brief. Ambiguity is two different components, not",
+        "two shades of the same one.",
+        "",
+        ...(hasImage
+            ? [
+                "AN IMAGE OF THE COMPONENT AS IT RENDERS NOW IS ATTACHED. Look at it",
+                "first. It is the only accurate description of what this thing",
+                "currently is — SCHEMA below is the CATALOG's, and after a rewrite it",
+                "describes what the component used to be. A schema saying `Roundness`",
+                "and `Mesh subdivisions` on a screen full of stars means the file was",
+                "rewritten and the schema was not. Believe the picture.",
+            ]
+            : [
+                "You are shown the schema, not the file and not the render, so you do",
+                "not know what the component currently contains.",
+            ]),
+        "",
+        "THE PROP NAMES ARE STALE, THE PROPS ARE NOT. After a rewrite the schema is",
+        "still the working interface — `size` still drives the size — but its names",
+        "and descriptions describe what the component USED to be. A component that",
+        "is now stars may still expose `size` described as the cube's size, and",
+        "setting it is exactly how you make the stars smaller. Map the user's words",
+        "onto props by ROLE — size, colour, count, speed, spacing — not by whether",
+        "the label mentions the right noun.",
+        "",
+        "NEVER TELL THE USER THAT SOMETHING THEY NAMED DOES NOT EXIST. They are",
+        "looking at it. 'There are no stars in this component' on a screen full of",
+        "stars is the single most annoying thing you can say, and the schema is not",
+        "evidence: this session may have rewritten the file ten times and the",
+        "catalog's prop names and descriptions do not follow it.",
+        "",
+        "If the user names a thing — 'the stars', 'the cards', 'the glow' — assume",
+        "it is there and that they mean the obvious one. Never offer options you",
+        "invented to cover your own uncertainty: asking 'background stars, particle",
+        "stars or loading stars?' about a component with one kind of star wastes a",
+        "turn and reads as not paying attention. If you truly cannot place what",
+        "they mean, route to \'code\' so the editor can read the file. That is the",
+        "answer to not knowing — never a question.",
+        "",
+        "'A BIT MORE', 'AGAIN', 'INSTEAD', 'ALSO' REFER TO THE LAST TURN. Read",
+        "EARLIER IN THIS SESSION below. A follow-up is not ambiguous just because",
+        "it is short — it is the least ambiguous kind of request there is.",
+        "",
+        `COMPONENT: ${entry.name}`,
+        "SCHEMA:",
+        JSON.stringify(entry.props, null, 2),
+        "",
+        "CURRENT VALUES:",
+        JSON.stringify(values, null, 2),
+        ...(history.length
+            ? [
+                "",
+                "EARLIER IN THIS SESSION, oldest first — this is what 'it', 'them' and",
+                "'a bit more' refer to:",
+                ...history.map((h) => `  - ${h}`),
+            ]
+            : []),
+    ].join("\n");
+}
+/** The brief, with its constraints attached, as the editing model sees it.
+ *  Constraints ride here rather than in the system prompt for the same reason
+ *  recipes do — they vary per turn, and a varying line invalidates the cached
+ *  prefix for the whole file. */
+export function intentToInstruction(intent) {
+    if (!intent.constraints.length)
+        return intent.prompt;
+    return [
+        intent.prompt,
+        "",
+        "Do not change any of these:",
+        ...intent.constraints.map((c) => `  - ${c}`),
+    ].join("\n");
+}
+/* A brief that promises to change nothing.
+ *
+ * Observed on "replicate it": agent 1 wrote "The user provided a vague request
+ * with no specific changes requested; keep the component exactly as it is
+ * without modifying any visual properties or behavior." It had SEEN the
+ * ambiguity, said so in as many words, and then wrote a brief guaranteeing a
+ * wasted turn instead of asking the question it had already formed.
+ *
+ * The prompt now tells it to ask. This is the backstop for when it does not,
+ * and it reads agent-authored text rather than the user's — the same rule as
+ * `hardFail`. A user may perfectly well ask to keep something unchanged as part
+ * of a larger request; a BRIEF whose whole content is "change nothing" is never
+ * a brief.
+ */
+const NO_CHANGE_BRIEF = /\bno (?:specific|actual|clear|particular|explicit) (?:change|request|instruction|modification)/i;
+const KEEP_AS_IS = /\b(?:keep|leave|retain)(?:ing)?\s+(?:the\s+\w+\s+)?(?:exactly\s+)?as[- ]is\b|\b(?:keep|leave)(?:ing)?\s+(?:it|the\s+component|the\s+file|everything)\s+(?:exactly\s+)?(?:as it is|unchanged|the same)\b|\bwithout (?:modifying|changing|altering) any\b|\bvague request\b/i;
+/* A question asserting that what the user named is not there.
+ *
+ * Observed on a screen full of gold stars: "There are no stars in this
+ * component. What would you like to change instead?" — offered with the options
+ * "Size of the cube", "Spin speed", "Background colour". The agent was not
+ * hallucinating; it was reading the CATALOG schema, which still said SquishCube
+ * with a `Roundness` prop, nine rewrites after the file stopped being a cube.
+ *
+ * The user is looking at the thing. There is no state in which telling them it
+ * does not exist is useful, so this is never asked — the turn routes to code
+ * instead and lets the editor read the file, which is the only artefact that
+ * actually knows.
+ */
+const DENIES_EXISTENCE = /\b(?:there (?:are|is|were|was) no|no such|does(?:n't| not) (?:exist|have|contain)|cannot find|could not find|there(?:'s| is) nothing)\b/i;
+export const deniesExistence = (question) => DENIES_EXISTENCE.test(question);
+export const promisesNothing = (brief) => NO_CHANGE_BRIEF.test(brief) || KEEP_AS_IS.test(brief);
+/* Words that can express a CHANGE but never its SUBJECT.
+ *
+ * "inc this" is built entirely from these: a verb, a determiner, a pronoun with
+ * no antecedent in the sentence. Strip them and nothing is left to point at. */
+const SUBJECTLESS = new Set([
+    "a", "again", "an", "and", "any", "be", "better", "big", "bigger", "bit",
+    "change", "dec", "decrease", "do", "down", "faster", "fix", "improve", "inc",
+    "increase", "it", "less", "little", "lower", "make", "more", "much", "nicer",
+    "of", "please", "raise", "reduce", "small", "smaller", "slower", "some",
+    "that", "the", "them", "these", "this", "those", "to", "up", "worse",
+]);
+/**
+ * The request names no thing to act on.
+ *
+ * History cannot rescue this and is what makes it dangerous: after a
+ * liquid-metal turn, "inc this" reads as obvious, and the agent duly raised
+ * flow speed, viscosity, iridescence AND shine — four knobs nobody named — for
+ * 20s and a rewrite. The previous turn is one candidate among everything on
+ * screen, so treating it as the antecedent is a guess dressed as context.
+ *
+ * A prompt rule for this was written first and did NOT hold: told plainly that
+ * history supplies degree and never subject, the agent guessed anyway. Hence a
+ * check, like every other guard here that survived contact.
+ *
+ * Deliberately narrow. It fires only when EVERY word is one of a small closed
+ * set, so "make it red" (red), "reduce the star size" (star, size) and
+ * "increase the number of bubbles" (number, bubbles) all pass untouched.
+ * Interrogating a clear request is the worse failure of the two.
+ */
+export function noSubject(ask) {
+    const words = ask
+        .toLowerCase()
+        .replace(/[^a-z\s]/g, " ")
+        .split(/\s+/)
+        .filter(Boolean);
+    if (!words.length || words.length > 5)
+        return false;
+    return words.every((w) => SUBJECTLESS.has(w));
+}
+/** Never throws, never returns null. A scaffold that cannot be read hands the
+ *  user's own sentence straight through, which is exactly what the page did
+ *  before this agent existed. */
+export function parseIntent(raw, ask, hasSource) {
+    const fallback = {
+        prompt: ask,
+        route: hasSource ? "code" : "props",
+        constraints: [],
+        criteria: [],
+        question: null,
+        options: [],
+    };
+    const obj = parseLoose(raw);
+    if (!obj)
+        return fallback;
+    const route = str(obj.route).toLowerCase();
+    const criteria = Array.isArray(obj.criteria)
+        ? obj.criteria
+            .map((c) => {
+            if (typeof c === "string")
+                return { text: c.trim(), check: "judge" };
+            if (!c || typeof c !== "object")
+                return null;
+            const text = str(c.text);
+            if (!text)
+                return null;
+            const check = str(c.check).toLowerCase();
+            return {
+                text,
+                check: CHECKS.has(check) ? check : "judge",
+            };
+        })
+            .filter((c) => c !== null)
+        : [];
+    const prompt = str(obj.prompt) || ask;
+    const asked = str(obj.question) || null;
+    // Trimmed hard rather than trusted: a model told "two or three words" writes
+    // a sentence often enough, and a wrapped chip is worse than a clipped one.
+    const options = strs(obj.options)
+        .map((o) => o.replace(/[.]+$/, "").trim())
+        .filter((o) => o.length <= 28)
+        .slice(0, 4);
+    return {
+        // An empty brief is worse than no agent at all — fall back to the ask.
+        prompt,
+        // "code" is only honoured when there is a file to change. Without one the
+        // edit pass has nothing to send and the turn would die on a route the user
+        // never chose.
+        route: ROUTES.has(route) && hasSource ? route : fallback.route,
+        constraints: strs(obj.constraints),
+        criteria,
+        /* A brief that commits to changing nothing becomes the question it should
+         * have been. Generic, because the specific one is exactly what the agent
+         * failed to produce — but a plain question beats a paid turn that confirms
+         * the status quo. */
+        question: asked ??
+            (noSubject(ask)
+                ? "Increase what?"
+                : promisesNothing(prompt)
+                    ? "What should change?"
+                    : null),
+        options,
+    };
+}
+/** The user answered a clarification. Fold it into the ask rather than starting
+ *  a message thread — the turn stays single-shot, which is the whole design of
+ *  this page. */
+export function withAnswer(ask, question, answer) {
+    return `${ask}\n\n(Asked: ${question}\nAnswered: ${answer})`;
+}
+/* ── Agent 2a: the prop editor ──────────────────────────────────────────── */
+/*
+ * Why this exists rather than reusing `buildSystem` from prompt.ts.
+ *
+ * That prompt is the BENCHMARK's, and it is a measurement instrument: every
+ * saved run was scored against those exact words, so tuning it retroactively
+ * changes what old numbers mean. This one is free to know things that prompt
+ * cannot — that the route was already decided by an agent that read the schema,
+ * that a brief exists, and what the constraints are.
+ *
+ * The difference that matters is the LAST rule. A model handed "make the cards
+ * circular" and a `rounded` prop capped at 60 will set it to 60 and report
+ * success, because 60 is the closest it can get and nothing told it that close
+ * enough is not the job. Pinning to the limit is a refusal wearing a patch's
+ * clothes: it costs a turn, it looks like it worked, and the render does not
+ * move. Saying so instead escalates to the file, which is where the answer is.
+ */
+export function buildPropSystem(entry, values, intent) {
+    return [
+        "You edit React component props. You never write code.",
+        "",
+        "Return ONLY a JSON object mapping prop names to new values. No prose, no",
+        "markdown fence. Include only the props you are changing. Every key must",
+        "exist in the schema and every value must satisfy its type, range or enum.",
+        "",
+        "A brief has already been written for you by someone who read this schema",
+        "and decided a prop patch can do it. Usually they are right. When they are",
+        "not, say so rather than getting as close as the schema allows:",
+        '{"error": "requires code change",',
+        ' "needs": ["propName - one line on what it would control"]}',
+        "",
+        "REFUSE RATHER THAN PIN TO A LIMIT — either limit. If the value the request",
+        "needs sits outside a prop's range, the answer is not the nearest end of it.",
+        "  - `rounded` capped at 60 does not make a 180px card circular. It makes",
+        "    the rounded rectangle that was already there.",
+        "  - `squash` floored at 1 does not remove the squash. It makes a smaller",
+        "    squash, and the request said remove.",
+        "Setting a prop to its min or its max and reporting success is worse than",
+        "declining, because nobody can see that nothing happened. Decline, and name",
+        "what the file would need.",
+        "",
+        "If the request asks for something to be GONE — remove, disable, turn off,",
+        "no more, without — and the prop that controls it has a minimum above zero,",
+        "there is no patch. Refuse. The right prop with the wrong floor is still the",
+        "wrong answer.",
+        "",
+        "Same for a look the schema has no knob for: a gradient, a second colour, a",
+        "palette. You cannot fake one by patching a flat colour.",
+        "",
+        "Do not guess. A prop that is not in the schema below does not exist, and",
+        "inventing one is worse than declining.",
+        ...(intent.constraints.length
+            ? [
+                "",
+                "Leave these exactly as they are:",
+                ...intent.constraints.map((c) => `  - ${c}`),
+            ]
+            : []),
+        "",
+        `COMPONENT: ${entry.name}`,
+        "SCHEMA:",
+        JSON.stringify(entry.props, null, 2),
+        "",
+        "CURRENT VALUES:",
+        JSON.stringify(values, null, 2),
+    ].join("\n");
+}
+/* Asking for an ABSENCE. No amount of a knob turns it off unless its floor is
+ * off, so `squash` with `min: 1` cannot answer any of these. */
+const REMOVAL = /\b(remove[ds]?|removing|disable[ds]?|turn(?:ing)? off|switch(?:ing)? off|get rid of|eliminate[ds]?|no more|without|none|zero|stop(?:ped|ping)?|kill)\b/i;
+/* Asking for a COMPLETED state. The top of a range is only the answer if the
+ * range happens to reach that far, which is the thing worth checking. */
+const TOTALITY = /\b(fully|completely|entirely|totally|perfectly|all the way|to the max|max(?:ed)? out)\b/i;
+/* The brief naming a limit AS the answer.
+ *
+ * Agent 1 is told never to do this and wrote "reducing squash to its minimum
+ * value" anyway. It is the clearest possible admission that the range did not
+ * reach the request — you only reach for the end of a scale when nothing on the
+ * scale is what you wanted — and it needs no removal or totality vocabulary in
+ * the user's own words to be worth acting on. */
+const LIMIT_ANSWER = /\b(?:towards?|to|at|near)\s+(?:its|their|the)\s+(?:min|max|minimum|maximum|lowest|highest|smallest|largest)\b|\b(?:minimum|maximum)\s+(?:value|setting|density|amount)\b/i;
+/*
+ * A patch that landed on a range limit when the request asked for an end state.
+ *
+ * Three turns in a row failed the same way and none of them looked like a
+ * failure. "Make the cards circular" set `rounded` to its max of 60 on a 180px
+ * card. "Remove the squish" set `squash` to its min of 1 — and the component
+ * does `clamp(squash, 1, 20) * 0.021`, so 1 is a smaller squash, never no
+ * squash. Both reported "patched", both showed a green diff, and neither did
+ * what was asked.
+ *
+ * Deterministic on purpose. Agent 1 and the prop editor are both TOLD to refuse
+ * rather than pin to a limit, and both did it anyway — a prompt rule is a
+ * request and this is a check. It also survives `REVIEW = false`, which is when
+ * nothing else is watching.
+ *
+ * The removal rule is exact: a floor above zero cannot express "none", so there
+ * is no value the model could have picked instead. The totality rule is a
+ * judgement — the top of a range sometimes IS the end state — and it is kept
+ * because the alternative is silently shipping the half-measure, and the cost
+ * of being wrong is one rewrite that lands in the same place.
+ */
+export function pinnedAtLimit(ask, intent, applied, props) {
+    const said = `${ask}\n${intent.prompt}`;
+    const removal = REMOVAL.test(said);
+    const totality = TOTALITY.test(said);
+    // Only the brief: the user saying "turn it down to the minimum" is a request
+    // for the minimum and is answered by giving them the minimum.
+    const limitAnswer = LIMIT_ANSWER.test(intent.prompt);
+    if (!removal && !totality && !limitAnswer)
+        return null;
+    for (const [k, val] of Object.entries(applied)) {
+        const spec = props[k];
+        if (spec?.type !== "number" || typeof val !== "number")
+            continue;
+        if (limitAnswer && (val === spec.min || val === spec.max)) {
+            return `${k} - the brief answered with a range limit and ${k} is now at ${val}, the end of its ${spec.min}..${spec.max} range. A limit is what you reach for when nothing on the scale was the answer, so change the file rather than settling for the end of it.`;
+        }
+        if (removal && val === spec.min && spec.min !== 0) {
+            return `${k} - the request asks for this to be gone, and ${k} bottoms out at ${spec.min}, which is still some of it. There is no value of ${k} that means none, so the file has to change.`;
+        }
+        if (totality && val === spec.max) {
+            return `${k} - the request asks for a completed state and ${k} was set to its ceiling of ${spec.max}. If the ceiling is not that state, raising it or changing what it drives is the answer.`;
+        }
+    }
+    return null;
+}
+/*
+ * Declared props the source never reads.
+ *
+ * A rewrite declares its new knobs after `///NEW-PROPS`, and that block is
+ * stripped from the file before it is stored — so a name that does not appear
+ * in the source at all is a prop the code cannot possibly be honouring. It
+ * renders a control that does nothing, which is worse than no control: the user
+ * toggles `ringEnabled` off, the ring stays, and every part of the machinery
+ * looks correct because it IS correct right up to the component.
+ *
+ * A word-boundary match, deliberately loose. The question is "does this file
+ * mention this name anywhere" — a mention in a comment is a false negative here
+ * and that is the right direction to be wrong in: flagging a prop that is
+ * actually wired would send someone chasing a bug that is not there.
+ *
+ * Dot-path props are checked on their last segment: the registry flattens
+ * `icon.size` for the model, but the source destructures `icon` and reads
+ * `.size` off it.
+ */
+export function unwiredProps(source, names) {
+    if (!source.trim())
+        return [];
+    return names.filter((name) => {
+        const leaf = name.slice(name.lastIndexOf(".") + 1);
+        if (!/^[A-Za-z_$][\w$]*$/.test(leaf))
+            return false;
+        return !new RegExp(`\\b${leaf}\\b`).test(source);
+    });
+}
+/*
+ * Dot-path props that cover only part of the object they nest into.
+ *
+ * `expand()` REPLACES the object: declaring `leaves.width`, `leaves.spin` and
+ * `leaves.sway` means the component is handed `leaves={{width, spin, sway}}`
+ * and nothing else. Any other field it reads — `leaves.colors`, `leaves.shape`
+ * — arrives undefined and its own fallback takes over.
+ *
+ * Measured, and it is the nastiest failure yet because it looks like a revert
+ * rather than a bug: "make these cherry blossom leaves" rewrote the file, the
+ * render check photographed the new pink palette (#AE989C, #D5B3BA), the critic
+ * passed 4/4 — and then the three new dot-path props were adopted, the
+ * incomplete `leaves` object went in, and the leaves turned autumn again. Every
+ * step reported success and the screen went back to how it started.
+ *
+ * Two ways a key gets used, and both are checked: `leaves.colors` written out,
+ * and `const { colors } = leaves` destructured. A key that is read and not
+ * declared is a key that will be undefined.
+ */
+export function partialNesting(source, declared) {
+    const byPrefix = new Map();
+    for (const name of declared) {
+        const dot = name.indexOf(".");
+        if (dot === -1)
+            continue;
+        const prefix = name.slice(0, dot);
+        if (!/^[A-Za-z_$][\w$]*$/.test(prefix))
+            continue;
+        const leaf = name.slice(dot + 1);
+        if (leaf.includes("."))
+            continue; // one level is all `expand` nests here
+        (byPrefix.get(prefix) ?? byPrefix.set(prefix, new Set()).get(prefix)).add(leaf);
+    }
+    if (!byPrefix.size)
+        return [];
+    const out = [];
+    for (const [prefix, leaves] of byPrefix) {
+        const used = new Set();
+        // `prefix.key`
+        for (const m of source.matchAll(new RegExp(`\\b${prefix}\\.([A-Za-z_$][\\w$]*)`, "g"))) {
+            used.add(m[1]);
+        }
+        // `const { key, other = 1, renamed: r } = prefix`
+        for (const m of source.matchAll(new RegExp(`\\{([^{}]*)\\}\\s*=\\s*${prefix}\\b`, "g"))) {
+            for (const part of m[1].split(",")) {
+                const key = part.trim().split(/[:=]/)[0].trim().replace(/^\.\.\./, "");
+                if (/^[A-Za-z_$][\w$]*$/.test(key))
+                    used.add(key);
+            }
+        }
+        const missing = [...used].filter((k) => !leaves.has(k));
+        if (missing.length)
+            out.push(prefix);
+    }
+    return out;
+}
+/** The correction for a partial nested override. Names the exact keys that
+ *  would go undefined, because "declare them all" without the list invites the
+ *  same three props back. */
+export function completeNestingCorrection(source, prefixes, declared) {
+    const lines = prefixes.map((prefix) => {
+        const have = new Set(declared
+            .filter((n) => n.startsWith(`${prefix}.`))
+            .map((n) => n.slice(prefix.length + 1)));
+        const missing = partialKeys(source, prefix).filter((k) => !have.has(k));
+        return `  ${prefix}: you declared ${[...have].join(", ")} but the code also reads ${missing.join(", ")}`;
+    });
+    return [
+        "Your dot-path props cover only part of the object they nest into, so the",
+        "object handed to the component REPLACES its own and the fields you left",
+        "out arrive undefined:",
+        ...lines,
+        "",
+        "Simplest fix, and the one to take: use FLAT prop names instead — one prop",
+        "per value with no dots, reading each straight into the code. Nothing is",
+        "nested, so nothing can be partly overwritten.",
+        "",
+        "If you keep the nested shape, every field the component reads off that",
+        "object must be declared as its own dot-path prop. Half of them is worse",
+        "than none: the change you made will appear and then silently revert.",
+    ].join("\n");
+}
+/** Keys a source reads off `prefix`, by either access or destructuring. */
+function partialKeys(source, prefix) {
+    const used = new Set();
+    for (const m of source.matchAll(new RegExp(`\\b${prefix}\\.([A-Za-z_$][\\w$]*)`, "g"))) {
+        used.add(m[1]);
+    }
+    for (const m of source.matchAll(new RegExp(`\\{([^{}]*)\\}\\s*=\\s*${prefix}\\b`, "g"))) {
+        for (const part of m[1].split(",")) {
+            const key = part.trim().split(/[:=]/)[0].trim().replace(/^\.\.\./, "");
+            if (/^[A-Za-z_$][\w$]*$/.test(key))
+                used.add(key);
+        }
+    }
+    return [...used];
+}
+/*
+ * A `json` prop that is really a bag of settings.
+ *
+ * Told to expose every knob, a model bundled all nine — enabled, innerRadius,
+ * outerRadius, colorInner, colorOuter, opacity, inclination, particleCount,
+ * spinSpeed — into ONE json prop called `ring`. That is nine knobs the user
+ * cannot touch: the panel renders a json prop as a box of raw JSON to hand-edit,
+ * so it is worse than the single boolean it replaced. It also passes every
+ * check we have, because the props ARE declared and the code DOES read them.
+ *
+ * Three keys is the line. An object of two — an {x, y} offset — is one idea
+ * with two components and a reasonable thing to pass whole. Nine is a control
+ * panel someone hid in a text field. Arrays are never bags: a list of colours
+ * is exactly what `json` is for.
+ */
+export function settingsBags(props) {
+    return Object.entries(props)
+        .filter(([, spec]) => {
+        if (spec.type !== "json")
+            return false;
+        const d = spec.default;
+        if (!d || typeof d !== "object" || Array.isArray(d))
+            return false;
+        return Object.keys(d).length >= 3;
+    })
+        .map(([name]) => name);
+}
+/** The correction for a bundled prop. Names the dot-path form, because "split
+ *  it up" leaves the model to invent a shape and it will invent this one
+ *  again. */
+export function unbundleCorrection(names, props) {
+    const example = names[0];
+    const spec = props[example];
+    const keys = spec?.type === "json" && spec.default && typeof spec.default === "object"
+        ? Object.keys(spec.default)
+        : [];
+    return [
+        `${names.join(", ")} bundle several settings into one json prop. That gives`,
+        "the user a box of raw JSON to hand-edit instead of a control per value, so",
+        "it is the same as not exposing them at all.",
+        "",
+        "Declare one prop per value, using dot-path names so they still arrive as",
+        "one object in the code:",
+        ...keys.slice(0, 4).map((k) => `  "${example}.${k}": { … its own type, range and default … }`),
+        keys.length > 4 ? "  …and the rest, one each." : "",
+        "",
+        `The component still destructures ${example} as an object — the dot paths are`,
+        "re-nested before it is rendered. Nothing about the code has to change",
+        "except reading each value from a prop instead of a literal.",
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+export function faultIn(c) {
+    if (c.threw.length) {
+        return {
+            correction: runtimeErrorCorrection(c.threw),
+            label: "the component threw while running",
+            failed: c.threw,
+        };
+    }
+    if (c.dead.length) {
+        return {
+            correction: wireUpCorrection(c.dead),
+            label: `${c.dead.length} declared prop${c.dead.length === 1 ? "" : "s"} not wired up`,
+            failed: [`${c.dead.join(", ")} declared but never read`],
+        };
+    }
+    if (c.partial.length) {
+        return {
+            correction: completeNestingCorrection(c.code, c.partial, Object.keys(c.declared)),
+            label: `${c.partial.join(", ")} would be half-overwritten — the change would revert`,
+            failed: [`${c.partial.join(", ")} would be partly overwritten`],
+        };
+    }
+    if (c.bagged.length) {
+        return {
+            correction: unbundleCorrection(c.bagged, c.declared),
+            label: `${c.bagged.join(", ")} bundles its settings into one control`,
+            failed: [`${c.bagged.join(", ")} is one control for several settings`],
+        };
+    }
+    return null;
+}
+/** The correction for a file that compiled and then threw once it ran. Says
+ *  where the gap is, because "fix the error" invites the model to re-read the
+ *  code it already believes is correct. */
+export function runtimeErrorCorrection(errors) {
+    return [
+        "That file compiled and then threw while running:",
+        ...errors.map((e) => `  ${e}`),
+        "",
+        "Compiling only proves the module evaluates. An identifier used inside a",
+        "function body is not checked until that function runs, so a name you",
+        "referenced but never declared, imported or hoisted gets you exactly this:",
+        "a clean compile and a blank canvas.",
+        "",
+        "Find every name in the error above and either declare it or stop using it.",
+        "",
+        "\"Cannot access X before initialization\" is the other shape and it is not a",
+        "missing name — X exists, but something reads it before the line that",
+        "declares it. `const` and `let` are not hoisted, so a helper defined above",
+        "its dependency, or an effect closing over a ref declared further down, hits",
+        "this. Move the declaration above every use, or move the use inside the",
+        "callback that runs later.",
+        "",
+        "Then read your draw loop and event handlers specifically — they run after",
+        "mount, which is why nothing caught this earlier.",
+    ].join("\n");
+}
+/** The correction for a rewrite that declared knobs it did not connect. Given
+ *  to the editor verbatim, so it names the props and says what "wired" means —
+ *  "use them" is the instruction it already thought it had followed. */
+export function wireUpCorrection(names) {
+    return [
+        `You declared ${names.join(", ")} after ${PROPS_MARKER}, but the file never`,
+        "reads them. They render as controls that do nothing.",
+        "",
+        "Thread each one through: accept it as a prop with the default you declared,",
+        "and replace the hard-coded value it describes with the prop itself. A",
+        "number you wrote as a literal and then declared as a prop is exactly the",
+        "value that prop is supposed to control — the ring's radius must come from",
+        "ringInnerRadius, not from 1.4 sitting next to a declaration that says 1.4.",
+        "",
+        "Every declared prop must appear in the code by name and change what the",
+        "component draws when it changes.",
+    ].join("\n");
+}
+/*
+ * The keys a patch would actually move.
+ *
+ * Observed: "make the corners more sharp" came back as `round: 0 -> 0` on a
+ * session where `round` was already 0, and the turn reported "patched" with a
+ * green pill and a diff line. Nothing had happened. A patch whose every value
+ * is the value already in place is not a small change or a conservative one —
+ * it is the model declining without saying so, and it is the easiest failure in
+ * this whole pipeline to catch, because the answer is sitting next to the
+ * state.
+ *
+ * JSON compare rather than `!==`: a `json` prop is an array or an object, and
+ * two equal arrays are never the same reference.
+ */
+export function movedOnly(applied, current) {
+    return Object.fromEntries(Object.entries(applied).filter(([k, v]) => JSON.stringify(v) !== JSON.stringify(current[k])));
+}
+/*
+ * A rewrite re-declaring a prop it did not invent.
+ *
+ * Redefining an existing prop was refused outright, because moving a range out
+ * from under a session invalidates every earlier turn taken against it. But
+ * that also made "the schema caps this" unanswerable: `rounded` maxed at 60
+ * cannot make a card circular, and a model with no way to widen it either pins
+ * to 60 and calls it done or invents a second prop for the same thing.
+ *
+ * WIDENING is the safe half of that. A value that satisfied the old range still
+ * satisfies a wider one, so nothing already applied becomes invalid — which is
+ * exactly what narrowing would do, and why narrowing is still refused. Type
+ * changes are refused too: `number` becoming `enum` is not a wider range, it is
+ * a different prop wearing the same name.
+ *
+ * Returns what is safe to take — a wider range, a corrected description, or
+ * both — and null when there is nothing safe to take. Null means "leave the
+ * catalog's version alone", never "fail the turn".
+ */
+export function adoptRedeclared(existing, proposed) {
+    // A different type is a different prop wearing the same name.
+    if (existing.type !== proposed.type)
+        return null;
+    /* A corrected description.
+     *
+     * This is the half that stops the schema drifting. Ten rewrites turned a cube
+     * into stars and `size` was still described as the cube's size, so the intent
+     * agent — which sees the schema and nothing else — told the user "there are
+     * no stars in this component" while they were looking at seven of them. A
+     * rewrite that repurposes a prop can now say so, and every later turn reads
+     * the truth. Adopting a desc cannot invalidate anything: no value becomes
+     * illegal because the sentence next to it changed.
+     */
+    const desc = proposed.desc && proposed.desc !== existing.desc ? proposed.desc : null;
+    if (existing.type !== "number" || proposed.type !== "number") {
+        return desc ? { ...existing, desc } : null;
+    }
+    // Narrower on either end is refused; identical is not a widening.
+    const wider = proposed.min <= existing.min &&
+        proposed.max >= existing.max &&
+        (proposed.min !== existing.min || proposed.max !== existing.max);
+    if (!wider)
+        return desc ? { ...existing, desc } : null;
+    const inRange = (n) => n >= proposed.min && n <= proposed.max;
+    return {
+        ...existing,
+        ...(desc ? { desc } : {}),
+        min: proposed.min,
+        max: proposed.max,
+        /* The rewrite's default only survives if it fits the range it just asked
+         * for. It usually does — validateSchema checked that before this ran — but
+         * this is the value the preview renders on, so it is worth not trusting. */
+        default: inRange(proposed.default) ? proposed.default : existing.default,
+    };
+}
+export const NO_EVIDENCE = {
+    ok: false,
+    paletteChanged: false,
+    before: [],
+    after: [],
+};
+function hexToRgb(h) {
+    const n = parseInt(h.slice(1), 16);
+    return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+}
+function near(a, b, tol) {
+    const [r1, g1, b1] = hexToRgb(a);
+    const [r2, g2, b2] = hexToRgb(b);
+    return Math.hypot(r1 - r2, g1 - g2, b1 - b2) <= tol;
+}
+/*
+ * What two captured frames can honestly be compared on.
+ *
+ * ONLY the palette. The two frames are seconds apart and everything in this
+ * catalog animates, so the render has moved for reasons that have nothing to
+ * do with the turn: a rotating burst is at a different angle, a spring has
+ * settled. Radius, count and ring all wobble with it.
+ *
+ * The palette does not. Median-cut over a whole frame is rotation-invariant in
+ * practice, which is the same property that lets `applyExtract` read colours
+ * off a reference photo. So this answers two questions and refuses the rest:
+ * did the colours change, and did they change when they were told not to.
+ *
+ * Tolerance is deliberately loose (48 in RGB). A tighter one reports antialias
+ * noise as a palette change, and a false "you changed the colours" would fail
+ * good turns — the one thing this layer must never do.
+ */
+export function compareFrames(before, after) {
+    if (!before || !after)
+        return NO_EVIDENCE;
+    // A blank capture analyses to no palette and no blob. Treating that as "the
+    // colours are gone" would fail every WebGL component whose buffer we could
+    // not read — see captureFrame.
+    if (!before.colors.length || !after.colors.length)
+        return NO_EVIDENCE;
+    const kept = before.colors.filter((c) => after.colors.some((d) => near(c, d, 48))).length;
+    return {
+        ok: true,
+        // Half the palette surviving is "the same look with something added".
+        // Fewer than that is a different look.
+        paletteChanged: kept < Math.ceil(before.colors.length / 2),
+        before: before.colors,
+        after: after.colors,
+    };
+}
+/* Colour words in AGENT-AUTHORED text — a criterion or a constraint, never the
+ * user's raw sentence.
+ *
+ * The distinction is the whole reason this is safe. "Make the green ball spin
+ * faster" names a colour and asks for nothing of the kind, so a regex over the
+ * ask fires on a speed request and demands the palette move — a false failure,
+ * the one outcome this layer must never produce. Agent 1 has already worked out
+ * which half of that sentence is the request; reading its output instead of the
+ * user's prose is deferring to the agent whose job that is. */
+const COLOUR_WORD = /colou?r|palett|hue|tint|shade|gradient|\b(red|orange|amber|yellow|gold|green|lime|teal|cyan|blue|navy|indigo|violet|purple|magenta|pink|brown|white|black|grey|gray)\b|#[0-9a-f]{3,8}\b/i;
+/*
+ * The verdicts that need no model.
+ *
+ * This is `withColourDrawCheck` done on pixels rather than on a regex over
+ * fill/stroke lines. The old version asked whether the paint LINES changed,
+ * which a model can satisfy while painting the same colour; this asks whether
+ * the picture changed, which it cannot.
+ *
+ * Returns a correction when the evidence is conclusive, so the caller can retry
+ * without paying for a critic call at all. Silent — null — whenever anything is
+ * uncertain: no capture, no colour criterion, or a request that wants the
+ * colours to move and to stay put at once.
+ */
+export function hardFail(intent, ev) {
+    if (!ev.ok)
+        return null;
+    const keep = intent.constraints.some((c) => COLOUR_WORD.test(c));
+    // Only a criterion the agent itself marked as visible in a frame. A `judge`
+    // criterion mentioning colour is an opinion, and opinions are the critic's.
+    const wants = intent.criteria.some((c) => c.check === "image" && COLOUR_WORD.test(c.text));
+    if (wants && !keep && !ev.paletteChanged) {
+        return [
+            "The rendered colours did not change. The frame before your edit and the",
+            `frame after it both read as ${ev.after.join(", ")}.`,
+            "A new colour variable that is never painted is not a change — edit every",
+            "fill, stroke, gradient stop and rgba() that currently uses the old colour.",
+        ].join(" ");
+    }
+    if (keep && ev.paletteChanged) {
+        return [
+            "The palette was supposed to be preserved and it changed:",
+            `${ev.before.join(", ")} became ${ev.after.join(", ")}.`,
+            "Make the requested change without touching the colours.",
+        ].join(" ");
+    }
+    return null;
+}
+/* ── Agent 3: critic ────────────────────────────────────────────────────── */
+/** Terse enough to be worth its tokens. The critic is told what the pixels
+ *  already settled so it does not spend its answer re-deciding it. */
+function evidenceBlock(ev, hasImage) {
+    const shot = hasImage
+        ? [
+            "AN IMAGE OF THE RESULT IS ATTACHED. It is a photograph of the component",
+            "as it renders right now, after the edit. Look at it before you answer.",
+            "It is the only thing that can settle a criterion about LAYOUT — whether",
+            "shapes overlap, whether they are spread across the area or bunched in a",
+            "corner, whether their sizes actually vary, whether something is centred",
+            "or cut off. Source code cannot answer any of those: `Math.random()`",
+            "positions read as a scatter in a diff and pile up on screen.",
+            "Trust the picture over the code every time they disagree.",
+            "",
+        ]
+        : [];
+    if (!ev.ok) {
+        if (hasImage) {
+            return [
+                ...shot,
+                "PALETTE EVIDENCE: unavailable, but the image above is not — judge every",
+                "[image] criterion from it.",
+            ];
+        }
+        /* The instruction that USED to be here — "judge every criterion from the
+         * source alone" — is how a turn that changed nothing on screen came back
+         * "2/2 met". The critic read the source, saw the edit was present, and
+         * reported the visual criterion as satisfied. Present in the source and
+         * visible in the render are different claims, and only one of them was
+         * being asked about. */
+        return [
+            "RENDER EVIDENCE: none. This component could not be photographed.",
+            "A criterion marked [image] asks what the thing LOOKS LIKE, and you have",
+            "no picture of it. Reading the edit in the source does not answer it: code",
+            "that is present is not the same as a change that is visible. Leave every",
+            "[image] criterion out of BOTH lists — it is unverified, not met.",
+            "Judge the [source] and [judge] criteria normally, and pass on those alone",
+            "unless the source positively shows the request was not carried out.",
+        ];
+    }
+    return [
+        ...shot,
+        "RENDER EVIDENCE — measured from the actual frames, not claimed:",
+        `  palette before: ${ev.before.join(", ")}`,
+        `  palette after:  ${ev.after.join(", ")}`,
+        `  palette changed: ${ev.paletteChanged ? "yes" : "no"}`,
+        "",
+        "These hexes are the pixels currently on screen. They are not an intention",
+        "in the code, a default you found, or a value you traced through a function",
+        "— they were read off the rendered frame after the edit was applied.",
+        "So: if a criterion asks for a colour and `palette after` IS that colour,",
+        "that criterion is MET. Say so. Failing it because the source did not",
+        "convince you is preferring your reading of the code to a photograph of the",
+        "result, and the photograph is the thing the criterion asked about.",
+    ];
+}
+/*
+ * The critic sees the diff, not the whole file.
+ *
+ * A rewrite answer is the complete file, so before + after is two copies of
+ * 7–12k tokens to ask one question. What it is actually judging is what
+ * MOVED, and the pair of "what was asked" and "what changed" is the whole
+ * judgement. The stable rules go first so the block caches across the retries
+ * of one turn, which is exactly when this runs twice.
+ */
+export function buildCriticSystem() {
+    return [
+        "You review one edit to a React component against the brief it was given.",
+        "You are the last check before the user sees it. You do not write code.",
+        "",
+        "Return ONLY a JSON object. No prose, no markdown fence:",
+        '{"pass": true, "met": ["criterion text"], "failed": [], "correction": null}',
+        "",
+        "pass — true only when every criterion is met AND no constraint was broken.",
+        "met / failed — quote the criterion text back, unchanged. `met` is what you",
+        "CONFIRMED, `failed` is what you found wrong. A criterion you could not check",
+        "goes in NEITHER list: it is unverified, and reporting it as met is the one",
+        "answer that makes this review worse than no review.",
+        "correction — on a failure, what the editor must do differently, addressed",
+        "to the editor. Name the specific thing that is wrong and what it should be",
+        "instead. Do not restate the brief. Null on a pass.",
+        "",
+        "How to be useful here:",
+        "  - A change that compiles is not a change that happened. Ask whether the",
+        "    edit would be VISIBLE, not whether it is present in the text.",
+        "  - If an image of the result is attached, it outranks everything else you",
+        "    are shown. Overlap, spacing, size variation, balance and framing are",
+        "    only answerable from it, and a diff that looks correct while the",
+        "    picture looks wrong means the picture is right.",
+        "  - A new prop defaulted to the old behaviour leaves the component exactly",
+        "    as it was. That is a failure however correct the code is.",
+        "  - Judge what was asked. An improvement nobody requested is not a pass",
+        "    for a criterion it does not address.",
+        "  - Look for collateral damage: this edit may have replaced the whole file,",
+        "    so behaviour that nobody asked to change and is now gone is a failure",
+        "    even when no constraint named it.",
+        "  - Be decisive. 'Possibly' is a pass — if you cannot say what is wrong,",
+        "    it is not wrong. A retry costs the user real money.",
+    ].join("\n");
+}
+export function buildCriticUser(intent, changed, ev, 
+/** A frame of the result is attached to this call. Changes what the critic
+ *  can be asked for, so it changes what it is told. */
+hasImage = false) {
+    return [
+        "BRIEF THE EDITOR WAS GIVEN:",
+        intent.prompt,
+        "",
+        ...(intent.constraints.length
+            ? ["MUST NOT HAVE CHANGED:", ...intent.constraints.map((c) => `  - ${c}`), ""]
+            : []),
+        "CRITERIA:",
+        ...intent.criteria.map((c) => `  - [${c.check}] ${c.text}`),
+        "",
+        ...evidenceBlock(ev, hasImage),
+        "",
+        "WHAT CHANGED:",
+        changed,
+    ].join("\n");
+}
+/** Fail open. An unreadable verdict must not fail a turn the compile step
+ *  already accepted — that would make the scaffold a way to lose answers that
+ *  worked, which is worse than having no critic. */
+export function parseVerdict(raw) {
+    const obj = parseLoose(raw);
+    if (!obj)
+        return { pass: true, met: [], failed: [], correction: null };
+    const failed = strs(obj.failed);
+    const correction = str(obj.correction) || null;
+    // The word and the evidence disagree surprisingly often: a model writes a
+    // correction and still says pass. The lists are the answer, `pass` is the
+    // summary — trust the lists.
+    const pass = obj.pass === true && !failed.length;
+    return {
+        pass,
+        met: strs(obj.met),
+        failed,
+        correction: pass ? null : correction,
+    };
+}
+/** The retry's instruction: the original brief, plus what went wrong. Not a
+ *  conversation — the editing model gets one self-contained ask each time, the
+ *  same as every other turn on this page. */
+export function withCorrection(instruction, correction) {
+    return [
+        instruction,
+        "",
+        "A previous attempt at this was rejected. What was wrong with it:",
+        correction,
+        "",
+        "Fix that. The result must satisfy the whole request, not only the correction.",
+    ].join("\n");
+}
+/** Did this retry do better than the last one? Two attempts that meet the same
+ *  number of criteria are a loop, and a third call would buy the same answer a
+ *  third time. */
+export const improved = (now, prev) => !prev || now.met.length > prev.met.length;
+/* How much of a rewrite the critic is shown.
+ *
+ * A code answer is the COMPLETE file, so before + after is two copies of 7-12k
+ * tokens to ask one question — more than the edit that produced it cost. What
+ * is being judged is what moved, so it gets the diff, which `diff.ts` already
+ * computes for the review panel. Nothing new is calculated here.
+ *
+ * The cap is a real limit, not a formality: a model that rewrote every line
+ * produces a diff as long as the file, and quietly truncating it would have the
+ * critic pass a file on the strength of its first 300 lines. When it truncates
+ * it SAYS so, so the critic knows it is judging a sample and can say it could
+ * not tell. */
+const DIFF_MAX_LINES = 300;
+export function changeSummary(before, after) {
+    const d = diffLines(before, after, 2);
+    if (!d.hunks.length)
+        return "Nothing changed in the file.";
+    const head = `${d.added} lines added, ${d.removed} removed${d.coarse ? " (too large to align line by line — shown as a wholesale replacement)" : ""}.`;
+    const lines = [];
+    for (const h of d.hunks) {
+        lines.push(`@@ -${h.aStart} +${h.bStart} @@`);
+        for (const l of h.lines)
+            lines.push(`${l.t}${l.text}`);
+        if (lines.length > DIFF_MAX_LINES)
+            break;
+    }
+    const cut = lines.length > DIFF_MAX_LINES;
+    return [
+        head,
+        ...lines.slice(0, DIFF_MAX_LINES),
+        ...(cut
+            ? [
+                "",
+                `[truncated — ${d.hunks.length} hunks in total. You are seeing part of`,
+                "the change. Say so rather than passing what you could not read.]",
+            ]
+            : []),
+    ].join("\n");
+}
+/** Only what the props route can show the critic. The file did not move, so
+ *  the diff IS the patch. */
+export function patchSummary(applied, before, props) {
+    if (!applied || !Object.keys(applied).length) {
+        return "Nothing was changed. No prop values moved.";
+    }
+    return Object.entries(applied)
+        .map(([k, v]) => {
+        const spec = props[k];
+        const range = spec?.type === "number" ? ` (range ${spec.min}..${spec.max})` : "";
+        return `${k}: ${JSON.stringify(before[k])} -> ${JSON.stringify(v)}${range}`;
+    })
+        .join("\n");
+}
+//# sourceMappingURL=agents.js.map