@palate/cli 0.0.0-stage → 0.0.2

package/src/mcp/server.mjs

@@ -0,0 +1,1246 @@
+// palate's MCP server: the design loop as tools any agent can call (Claude Code, Codex, Cursor, …), plus
+// prompts that show up as slash commands. Start it with `palate mcp`; it speaks MCP over stdio.
+//
+// The default: palate_plan (triage) → palate_build with the job (one brief for the real route) → (one builder)
+// → the finishing pass (palate_shoot, palate_states, palate_details, palate_critique on request) → palate_point_start (the
+// user points at what's wrong). A job-level question first goes through palate_direction (3 ideas, the user
+// picks one). Variants only when the user asks to explore or for a new kind of screen: palate_variants
+// (sketches) → palate_pick_start with ready (with more than 4: palate_judge_render → a fresh judge scores →
+// palate_judge_score first) → palate_pick_result → palate_build (the winner, built out) → palate_polish.
+// Specific jobs on an existing page: palate_critique → (agent writes findings) → palate_critique_review_start →
+// (the user agrees or disagrees) → palate_critique_review_result → palate_fix (verify) ; palate_vary → pick ;
+// palate_details ; palate_animate. Rules palate proposes (palate_taste learn, palate_fail): palate_rule review_start →
+// (the user keeps or discards each, with its scope) → palate_rule review_result.
+import fs from "node:fs";
+import path from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// stdout carries the protocol; anything palate prints goes to stderr instead.
+console.log = (...a) => console.error(...a);
+
+const DEFAULT_DIR = process.env.PALATE_DIR ?? process.cwd();
+const projectDir = (dir) => path.resolve(dir ?? DEFAULT_DIR);
+const text = (t) => ({ content: [{ type: "text", text: String(t) }] });
+const image = (file) => ({ type: "image", data: fs.readFileSync(file).toString("base64"), mimeType: /\.jpe?g$/i.test(file) ? "image/jpeg" : "image/png" });
+const fail = (e) => ({ isError: true, content: [{ type: "text", text: String(e?.message ?? e) }] });
+const dirArg = { dir: z.string().optional().describe("The project folder (defaults to the folder the agent runs in).") };
+const pending = new Map();
+
+const INSTRUCTIONS = `palate does the last 20%: AI gets a screen most of the way; palate builds it from the user's references, notes and rules, finishes it (shoot, details, critique), and lets the user point at what's wrong. Always start with palate_plan: it decides what the request deserves.
+- direct (a fix, tweak, copy change, or a critique/details finding): change it in place, one palate_shoot with fold: true at 1440, palate_check. No loop.
+- build (the default): build → finish → point.
+1. palate_build with job (the user's words) and route. A new page gets a blueprint first: palate_build answers with palate_blueprint's planner brief (the spec with mood, category truths and clichés; the system; imagery per section; one archetype per section from palate's library). Plan it (yourself or a fresh subagent), palate_blueprint with file until it passes, then palate_build again: one brief for the real route plus one brief per section. Build the foundation and the hero yourself, then every other section in parallel subagents (one each, each owning its component file; each checks only its own section with palate_section, not a full shoot, and ends with early: true), then stitch. Judge each section as it lands: give its early packet to a fresh subagent at once, palate_section with verdict, and send a section below the bar back to its builder once while the others still build; the final gate still judges the whole page. An existing page gets the existing-page blueprint (palate captures it as it is; the plan keeps the brand and marks each section keep, upgrade, remove or add), and only the changed sections are rebuilt. Without subagents (Codex, Cursor), palate_gate with judge "api" when a model API key is set, else "self" (tell the user it is self-judged).
+2. The finishing pass on that page: palate_finish runs the shoot, states, details and the motion check in one call (or separately: palate_shoot (both widths; a failing rule is fixed first, and so is a failing similarity gate: you fix it by changing what it names, you never ask the user), palate_states (build the missing states, then verify: true), palate_details, palate_animate with check if it moves, then always palate_gate: the quality floor, judged independently. It runs palate's floor checks and writes judge packets (a yes/no checklist per section, and the page beside strong real sites in both orders); run each packet with its own fresh subagent in parallel (never judge your own build, never tell the judges which page is ours), then palate_gate with answers. Below the bar: palate writes one repair brief per failing section (up to three); run them in parallel, one fresh subagent each, then palate_gate again; two repair rounds at most, and a round that got worse is rolled back (restore). Then tell the user the verdict in one line, honestly. Don't ask the user anything in the finishing pass. palate_critique only if the user asks for a review.
+3. palate_point_start: the user points at what's wrong in the running app. Then keep listening without being asked: loop palate_point_next (it waits up to 55 s and answers "Still listening" when nothing came; call it again at once), fix each pin, palate_point_crop (before and after at the width they pinned at and the other one, phone or desktop; if the other width broke, fix that too), palate_point_done (it refuses while the other width is broken), and back to palate_point_next. A pin inside a state that needs a click first (an open modal, a dropdown, a tab, a hover menu) carries the steps that opened it, and palate reopens it before every crop; when it couldn't, the check says so, and that never counts as broken. Don't end your turn while point is running. If the user writes something else in chat, answer it, then go back to listening. Stop only when they say they're done or palate_point_next says they pressed Done. Then palate_taste with action "learn"; if it proposed rules, palate_rule with action "review_start" so the user keeps or discards them. To have pins fixed with no chat at all, the user runs palate point --auto: palate runs their agent headless on each pin.
+- research (a new screen with no strong taste history, or the user wants something new or creative): research → direction → build, driven by you with no human step unless palate asks for one. 1. palate_research with the job: run the searches it returns with your own web search, then palate_research again with urls (4–8 official competitor homepages; [] to skip). 2. Open the contact sheet and screenshots, refine the drafted notes in research.md. 3. palate_direction with problem (the job) and from_research; answer with 3 art directions (metaphor, one signature move adapted to the product, the brand kept or a full starter system when the project has none, sections, provenance, wireframe), then palate_direction with the ideas: palate picks from taste when it is confident (or choose "auto" when the user said "just build it") and opens the picker only for a real judgement call, saying why in one line. 4. palate_blueprint with the job (the design decided before code, from the research and the chosen direction), palate_blueprint with file until it passes, then palate_build with the job: it carries the blueprint, the direction, the signature move's recipe and the abstract research notes, and writes one brief per section; deliver the signature moment. Imagery: palate_imagery for CC0 museum photos, palate_texture for materials drawn in code. Use the ideas, never the expression: no copied code, copy, images, illustrations, logos or paid fonts. If the user reacts to a reference, palate_research with action "verdict".
+- match (the user gave their own design to build: a screenshot, a mockup, a Figma frame, "make it look exactly like this"): the design is the spec, not palate's taste. palate_match with source (an image path, a page URL, or a Figma frame link; Figma needs FIGMA_TOKEN, else tell the user to export the frame as PNG) and route: it saves the design, measures it and writes a fidelity brief. Follow it: spec.json first (every value observed, inferred or substituted), then the build in the project's own stack, with no blueprint, archetypes or house-look check and no improvements. Then palate_match with check: true, run its one judge packet with a fresh subagent (never yourself), then palate_match with answers: READY, READY WITH SUBSTITUTIONS, NOT READY (fix what it lists, most visible first; two repair rounds at most) or UNVERIFIED. Tell the user the verdict, every substitution and what was inferred (states, the phone layout). palate_gate and the similarity gate don't apply to a matched route; contrast and clipping only warn, and you never change the design for them.
+- direction (a job-level question or problem: "users wait 20 seconds here, what should they see?"): palate_direction with the problem; answer its brief with 3 ideas (a name, 2–3 sentences, a rough ASCII or tiny HTML wireframe each; no code, no renders), then palate_direction with the ideas: a picker opens in the user's browser. palate_direction with action "result" once they've chosen, then build mode: palate_build carries the chosen idea.
+- quick or full (variants, opt-in: only when the user asks to explore, or a new kind of screen with no history). The triage shows their token cost next to build mode's; offer build mode as the cheaper choice. Then: palate_variants (sketches; build every brief in parallel subagents, each shoots once at 1440 with fold: true) → palate_pick_start with ready right away (more than 4 variants: palate_judge_render, a fresh judge scores, palate_judge_score first) → palate_pick_result → palate_build with name (the winner built out) → palate_polish → palate_taste learn.
+References: when the user gives a screenshot or URL, palate_refs_add it with like and dislike in their words; if they gave none, ask them what they like and dislike about each one, then add the notes (they become rules). palate_stats shows how long loops take and their tokens per mode.
+The user's rules (~/.palate/taste/rules.json) are enforced, not advice: every brief opens with "Your rules (must pass)" and the failures for that kind of screen; palate_shoot reports "Rules: n pass, n fail" and a failing rule is fixed before anything else; the judge ranks down variants that fail one. A rule can hold everywhere, for kinds of screen, on one route, for one component, or only in one project. When they state a rule ("only agent logos before the demo"), palate_rule with action "add": it applies at once. One pin is a one-off fix. What palate infers (the same ask twice, an agreed critique finding, palate_fail with the user's words when they call a screen bad) is only a proposed rule with a suggested scope: nothing carries into later builds until the user keeps it. When palate_taste learn or palate_fail proposes rules, palate_rule with action "review_start" opens a board where the user edits, scopes, keeps or discards each one (then "review_result"); or ask them in chat and call approve / reject. Never approve one they haven't agreed to. Never call a page done while a rule, the similarity gate or the quality gate fails (palate_check says "Not done"). Before you tell the user UI work is finished, palate_guard must pass (every changed screen looked at after its last edit, copy and code tells clean, gates passing); in a project with palate's Stop hook it runs on its own when you stop and sends you back with what is open. A finding that is wrong here: palate_waive with the file and a reason, never to get past a real problem. After writing or changing page copy: palate_copy. A page may not look like the user's other projects (over 50% similar) or copy a captured research reference: taste is how the user judges, not another product's look. Only when the user asked to match another project, pass like with its name.
+For small changes: build, palate_shoot to look at the result, palate_polish, palate_check.
+The last 20% of every screen is its states: after building or changing a screen with data, forms or lists, run palate_states (empty, loading, error, long text, many items, failing images, 320 wide, keyboard, forms pressed twice / failing / offline), build what it says is missing, and verify with verify: true. palate_fix includes its findings.
+For specific jobs on an existing page: palate_critique (a designer's review; the user agrees or disagrees on a board via palate_critique_review_start / _result), palate_fix (fix the agreed findings, then verify), palate_vary (new versions of one section, then palate_pick_start), palate_details (micro-components: avatars, brand marks, inputs, states, favicon), palate_animate (motion that serves the content, with a frame-strip check).
+Every fact must come from the project; never copy other brands' text, logos or imagery.
+Activation: the checks and the finishing pass are free (palate_guard, palate_copy, palate_check, palate_shoot, palate_finish, palate_states, palate_details, palate_animate, palate_gate, palate_imagery, palate_texture, palate_icons). The rest is invite-only: if a tool answers "This part of palate is invite-only", tell the user in one line, ask for their invite code (palate-XXXX-XXXX-XXXX) and call palate_activate with it; without one, build the screen yourself and still run the free finishing pass and palate_guard.`;
+
+const server = new McpServer({ name: "palate", version: "0.1.0" }, { instructions: INSTRUCTIONS });
+
+// Invite-only: the server always starts, but until palate is activated every tool outside auth.FREE_TOOLS
+// answers with the invite message instead of running, so the agent tells the user. See src/auth.mjs.
+const auth = await import("../auth.mjs");
+auth.maybeRecheck({ inProcess: true });
+const registerTool = server.registerTool.bind(server);
+// A long-lived server keeps the code it started with. Run from palate's own checkout, a change to palate since then
+// isn't in this server: say so on every answer (a Moveday gate kept failing on a bug fixed an hour earlier).
+const STARTED = Date.now();
+const SRC = path.resolve(path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1")), "..");
+let staleAt = 0, stale = false;
+const staleNote = () => {
+  if (!auth.devCheckout?.()) return null;
+  if (Date.now() - staleAt > 30_000) {
+    staleAt = Date.now();
+    const walk = (d) => fs.readdirSync(d, { withFileTypes: true }).some((e) => (e.isDirectory() ? walk(path.join(d, e.name)) : /\.(mjs|js)$/.test(e.name) && fs.statSync(path.join(d, e.name)).mtimeMs > STARTED + 1000));
+    try {
+      stale = walk(SRC);
+    } catch {}
+  }
+  return stale ? "Note: palate's code changed after this palate server started, so these answers come from the older code. Restart the palate MCP server (or start a new session) to use the new code." : null;
+};
+const withNote = (res) => {
+  const n = staleNote();
+  return n && Array.isArray(res?.content) ? { ...res, content: [...res.content, { type: "text", text: n }] } : res;
+};
+server.registerTool = (name, config, handler) =>
+  registerTool(name, config, async (...a) => {
+    if (auth.FREE_TOOLS.has(name)) return withNote(await handler(...a)); // the free tools need no code
+    const g = await auth.ensureGate();
+    if (!g.ok) return { isError: true, content: [{ type: "text", text: g.message }] };
+    auth.maybeRecheck({ inProcess: true }); // a long-lived server renews its licence too
+    const res = await handler(...a);
+    return withNote(g.note && Array.isArray(res?.content) ? { ...res, content: [...res.content, { type: "text", text: g.note }] } : res);
+  });
+
+registerTool(
+  "palate_activate",
+  {
+    title: "Activate palate with an invite code",
+    description: "palate is invite-only. When a tool answers \"palate is invite-only\", ask the user for their invite code and call this with it; without a code it reports whether palate is activated. Sends only the code and a random machine id to palate's site, once.",
+    inputSchema: { code: z.string().max(64).optional().describe("The user's invite code, exactly as they gave it: palate-XXXX-XXXX-XXXX") },
+  },
+  async ({ code }) => {
+    try {
+      if (code === undefined) return text(auth.status());
+      if (!auth.CODE_RE.test(code.trim())) return fail("That isn't a palate invite code: codes look like palate-XXXX-XXXX-XXXX. Ask the user to copy it from their invite email.");
+      return text(await auth.activate(code, { mcp: true }));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+// One browser and one dev server for the whole session; closed after 10 idle minutes.
+(await import("../pool.mjs")).keepAlive({ idle: 10 * 60_000 });
+
+server.registerTool(
+  "palate_plan",
+  {
+    title: "Triage the request",
+    description: "Run first for any design request. Decides what it deserves, with the reason and the estimated token cost: direct (a fix or tweak: change in place), build (the default: one build, the finishing pass, then the user points), direction (a job-level question or problem: 3 ideas first), research (a new screen with no strong taste history, or an ask for something new: competitors and craft looked at live, 3 art directions, then one build; its auto flag says palate may pick the direction itself), or variants only when the user asks to explore or for a new kind of screen (quick: 2–3 sketches; full: sketches, judge, pick at 4).",
+    inputSchema: { ...dirArg, request: z.string().describe("The request, in the user's words"), route: z.string().optional().describe("The route it is about, if any"), mode: z.enum(["direct", "build", "direction", "research", "quick", "full", "match"]).optional().describe("Only when the user asked for a mode") },
+  },
+  async ({ dir, request, route, mode }) => {
+    try {
+      const { plan, planText } = await import("../loop/plan.mjs");
+      return text(planText(plan(projectDir(dir), request, { route, mode })));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_context",
+  { title: "Read the project", description: "What this project uses: stack, tokens, fonts, components, screens. Run first.", inputSchema: { ...dirArg } },
+  async ({ dir }) => {
+    try {
+      const { context } = await import("../context.mjs");
+      return text(context(projectDir(dir)));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_taste",
+  {
+    title: "The user's taste profile",
+    description: 'action "show" (default): what palate has learned about the user (rules by kind, the newest rules, proposals waiting for their OK, how often its top-ranked variant was their pick) and the taste profile; "learn": turns patterns in new evidence (agreed critique findings, failures, the same point request twice) into proposed rules, then returns the rest so you can update the profile file it names. When it proposed rules, show the user each one with its scope: palate_rule action "review_start" (a board), or ask in chat and call palate_rule approve / reject. Proposals apply nowhere until kept.',
+    inputSchema: { ...dirArg, action: z.enum(["show", "learn"]).optional() },
+  },
+  async ({ dir, action }) => {
+    try {
+      const { taste } = await import("../loop/taste.mjs");
+      return text(taste(action === "learn" ? "learn" : undefined, { dir: projectDir(dir) }));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_refs_add",
+  {
+    title: "Save the user's references",
+    description: "Save screenshots, image files or URLs the user gives into their personal library (URLs are captured and measured), with what they like and dislike about each. The notes become rules tied to the reference; references with their notes come first in future briefs. Without notes, it tells you to ask the user for them; call it again with the same source and like / dislike.",
+    inputSchema: {
+      sources: z.array(z.string()).min(1).describe("Image file paths or URLs"),
+      like: z.array(z.string()).optional().describe("What the user likes about them, in their words, one item each (e.g. \"the calm spacing\")"),
+      dislike: z.array(z.string()).optional().describe("What the user doesn't like, in their words, one item each (e.g. \"gradient buttons\")"),
+      kind: z.string().optional().describe("Kinds of screen the notes' rules apply to, comma separated (landing, pricing, app, all…); default: from the job"),
+      note: z.string().optional().describe("Any other note"),
+    },
+  },
+  async ({ sources, like, dislike, kind, note }) => {
+    try {
+      const { addRefs, refsAddText } = await import("../loop/myrefs.mjs");
+      const saved = await addRefs(sources, { note: note ?? "", like, dislike, kinds: kind ? kind.split(",") : undefined });
+      return text(refsAddText(saved, { mcp: true }));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_variants",
+  {
+    title: "Plan the variants",
+    description: "Opt-in: only when the user asks to explore (options, directions, variants) or the triage says quick/full for a new kind of screen. Chooses directions from the user's history plus one to explore, finds references, and writes one brief per direction, with the loop's estimated token cost. How many comes from the triage (palate_plan); a request the triage calls direct, build or direction gets no loop. Briefs are sketches (first screen + centrepiece) unless full is true. Build every brief afterwards.",
+    inputSchema: {
+      ...dirArg,
+      job: z.string().describe("What to build, in the user's words"),
+      name: z.string().describe("Short name for this screen, e.g. pricing; variants become routes like pricing-a1"),
+      quick: z.boolean().optional().describe("One variant per direction and no judge step; for small or everyday screens"),
+      refs: z.array(z.string()).optional().describe("The user's own references for this screen: image paths or URLs"),
+      mode: z.enum(["quick", "full"]).optional().describe("Override the triage, only when the user asked to explore"),
+      full: z.boolean().optional().describe("Build whole pages instead of sketches (slower)"),
+      route: z.string().optional().describe("The route this replaces, if it exists"),
+    },
+  },
+  async ({ dir, job, name, quick, refs, mode, full, route }) => {
+    try {
+      const { variants } = await import("../loop/variants.mjs");
+      return text(await variants(projectDir(dir), job, { name, quick: Boolean(quick), refs: refs ?? [], mode, full: Boolean(full), route }));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_judge_render",
+  {
+    title: "Render variants for judging",
+    description: "Renders every variant the same way and returns the rubric and the screenshots. A fresh judge (not the builder) should score them, then call palate_judge_score. ready: first wait until that many variants are built (can take minutes).",
+    inputSchema: { ...dirArg, name: z.string(), ready: z.number().int().min(2).max(8).optional() },
+  },
+  async ({ dir, name, ready }) => {
+    try {
+      const { judge } = await import("../loop/judge.mjs");
+      const d = projectDir(dir);
+      const out = await judge(d, name, { ready });
+      const session = path.join(d, ".palate", "variants", name);
+      const key = JSON.parse(fs.readFileSync(path.join(session, "judge-key.json"), "utf8"));
+      const rubric = fs.readFileSync(path.join(session, "rubric.md"), "utf8");
+      return { content: [{ type: "text", text: `${out}\n\n${rubric}` }, ...key.flatMap((k) => [{ type: "text", text: k.label }, image(k.file)])] };
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_judge_score",
+  {
+    title: "Keep the best variants",
+    description: "Takes the judge's scores (1–10 per quality, plus true/false for each of the user's rules the rubric asks about) and keeps the best variants for the user's pick. Variants that fail a measured rule rank below every variant that passes.",
+    inputSchema: {
+      ...dirArg,
+      name: z.string(),
+      scores: z.array(z.object({ label: z.string(), clarity: z.number(), content_at_glance: z.number(), main_object_dominance: z.number(), chrome_clutter: z.number(), rules: z.record(z.string(), z.boolean()).optional().describe("The rubric's rule questions: rule id → true if the design follows it") })),
+      keep: z.number().int().min(2).max(6).optional(),
+    },
+  },
+  async ({ dir, name, scores, keep }) => {
+    try {
+      const { judge } = await import("../loop/judge.mjs");
+      const d = projectDir(dir);
+      const file = path.join(d, ".palate", "variants", name, "scores.json");
+      fs.writeFileSync(file, JSON.stringify({ scores }, null, 2));
+      return text(await judge(d, name, { scores: file, keep: keep ?? 4 }));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_pick_start",
+  {
+    title: "Let the user choose",
+    description: "Opens the variants side by side in the user's browser, blind; the user clicks the best one. Returns the link at once: give it to the user, then call palate_pick_result. ready: call it right after the briefs go out; it returns at once and opens the picker by itself as soon as that many variants are built.",
+    inputSchema: { ...dirArg, name: z.string(), pairs: z.boolean().optional().describe("Ask every A/B pair instead of one click (for close calls)"), ready: z.number().int().min(2).max(8).optional().describe("Open as soon as this many variants are built") },
+  },
+  async ({ dir, name, pairs, ready }) => {
+    try {
+      const { startPick } = await import("../loop/pick.mjs");
+      const d = projectDir(dir);
+      if (ready) {
+        // Waiting for builders can take minutes: return now, open the picker when they're ready.
+        const entry = { link: null, report: null, waiting: ready };
+        pending.set(`${d}|${name}`, entry);
+        startPick(d, name, { open: true, pairsMode: Boolean(pairs), ready })
+          .then((s) => {
+            entry.link = s.link;
+            return s.done.then((r) => (entry.report = r));
+          })
+          .catch((e) => (entry.report = `Picker failed: ${e.message}`));
+        return text(`The picker will open in the user's browser as soon as ${ready} variants are built. Tell the user it's coming; then call palate_pick_result (it gives the link once it's open).`);
+      }
+      const s = await startPick(d, name, { open: true, pairsMode: Boolean(pairs) });
+      const entry = { link: s.link, report: null };
+      s.done.then((r) => (entry.report = r)).catch((e) => (entry.report = `Picker failed: ${e.message}`));
+      pending.set(`${d}|${name}`, entry);
+      return text(`The picker is open: ${s.link} (${s.summary}). Tell the user to open it if it didn't open by itself and click the design they want. Then call palate_pick_result.`);
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_pick_result",
+  {
+    title: "The user's choice",
+    description: "Returns the winner and the user's reasons once they have picked; otherwise says it is still waiting. Wait for the user before calling again.",
+    inputSchema: { ...dirArg, name: z.string() },
+  },
+  async ({ dir, name }) => {
+    const entry = pending.get(`${projectDir(dir)}|${name}`);
+    if (!entry) return fail(`No picker running for "${name}". Call palate_pick_start first.`);
+    return text(entry.report ?? (entry.link ? `Still waiting for the user to choose at ${entry.link}.` : `Still waiting for ${entry.waiting} variants to be built; the picker opens by itself then.`));
+  },
+);
+
+server.registerTool(
+  "palate_build",
+  {
+    title: "Build it (build mode), or build out a variants winner",
+    description: "Build mode, the default (give job): one brief for the real route with the user's rules, references with their likes and dislikes, taste and the direction they chose; one builder follows it, then the finishing pass (shoot, details, critique on request), then palate_point_start. Logs the brief size and estimated token cost. After a variants pick (give name, no job): the brief that completes the winning sketch into the full page.",
+    inputSchema: {
+      ...dirArg,
+      job: z.string().optional().describe("Build mode: what to build, in the user's words"),
+      route: z.string().optional().describe("Build mode: the real route (e.g. / or /pricing). After a pick: the winning route, if not the recorded winner"),
+      direction: z.string().optional().describe('Build mode: the chosen direction\'s name ("latest" for the newest); default: one chosen for this route today'),
+      refs: z.array(z.string()).optional().describe("Build mode: the user's references for this screen (image paths or URLs); add their notes with palate_refs_add"),
+      name: z.string().optional().describe("After a pick: the loop's name. Build mode: a short name for this build (default from the route)"),
+      like: z.array(z.string()).optional().describe("Build mode, only when the user asked to match another of their projects: its name (the similarity gate then lets its look through)"),
+    },
+  },
+  async ({ dir, job, route, direction, refs, name, like }) => {
+    try {
+      const { build, buildBrief } = await import("../loop/build.mjs");
+      const d = projectDir(dir);
+      const out = job ? await buildBrief(d, job, { route, name, direction, refs: refs ?? [], like: like ?? [] }) : build(d, { name, route });
+      const file = out.match(/Brief: (\S+)/)?.[1];
+      return text(file && fs.existsSync(file) ? `${out}\n\n${fs.readFileSync(file, "utf8")}` : out);
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+// ── the quality floor: blueprint before code, the independent gate after it (src/loop/blueprint.mjs, gate.mjs) ──
+server.registerTool(
+  "palate_blueprint",
+  {
+    title: "Decide the design before code",
+    description: "A new page's first build step (palate_build asks for it). With job: the planner brief: expand the job into a spec (mood from the audience, category truths to keep, clichés to avoid), the system (colours by role including a material tone, type roles), an imagery decision per section, the page's button language (look.buttons, from a library of languages) and one archetype per section from palate's library. Plan it yourself or with a fresh subagent and write the JSON it names. With file: palate checks it (neighbours differ in shape, surfaces vary, material present, AA contrast, a display face with character) and, when it passes, saves it with tokens (layered shadows, the buttons in its language). Then palate_build builds it section by section. No question to the user.",
+    inputSchema: { ...dirArg, job: z.string().optional().describe("What to build, in the user's words (for the planner brief)"), route: z.string().optional(), file: z.string().optional().describe("The blueprint JSON to check and save"), name: z.string().optional(), direction: z.string().optional() },
+  },
+  async ({ dir, job, route, file, name, direction }) => {
+    try {
+      const B = await import("../loop/blueprint.mjs");
+      const d = projectDir(dir);
+      if (file) return text(B.saveBlueprint(d, file, { name }));
+      const out = await B.blueprintBrief(d, job ?? "", { route, name, direction });
+      const brief = out.match(/Brief: (\S+)/)?.[1];
+      return text(brief && fs.existsSync(brief) ? `${out}\n\n${fs.readFileSync(brief, "utf8")}` : out);
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_finish",
+  {
+    title: "The finishing pass, in one call",
+    description: "After building a page: the shoot at both widths (your rules, the similarity gate, the look), every state, the small details and the motion check, in one process sharing one browser and dev server (about a minute, instead of four separate calls). Fix what it names, then palate_states with verify: true for the states you built, then palate_gate.",
+    inputSchema: { ...dirArg, route: z.string(), url: z.string().optional() },
+  },
+  async ({ dir, route, url }) => {
+    try {
+      const d = projectDir(dir);
+      const { shoot } = await import("../shoot.mjs");
+      const { states } = await import("../loop/states.mjs");
+      const { details } = await import("../loop/details.mjs");
+      const { animate } = await import("../loop/animate.mjs");
+      const run = async (name, fn) => {
+        try {
+          const out = await fn();
+          return `## ${name}
+${(typeof out === "string" ? out : out?.text ?? out?.report ?? "").trim()}`;
+        } catch (e) {
+          return `## ${name}
+${name} failed: ${e.message}`;
+        }
+      };
+      const first = await run("shoot", async () => (await shoot(d, route, { url })).report);
+      const rest = await Promise.all([run("states", () => states(d, route, { url })), run("details", () => details(d, route, { url })), run("animate", () => animate(d, route, { url, checkOnly: true }))]);
+      return text([`# Finishing pass ${route}`, first, ...rest].join("\n\n"));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_gate",
+  {
+    title: "The quality floor, judged independently",
+    description: "Run after building a page (part of the finishing pass, always). Without answers: palate renders the page, runs its floor checks (dead space, half-empty sections, one template repeated, one flat colour with no material, monospace as decoration, placeholder text, clipped text, endless phone stacks) and writes judge packets: a yes/no checklist per section and the page beside strong real sites in both orders. Run each packet with its own fresh subagent in parallel; never judge your own build. With answers (the round's folder): the verdict and, below the bar, one repair brief for one section. Two repair rounds at most; restore: <round> rolls a worse round back. Tell the user the verdict honestly.",
+    inputSchema: { ...dirArg, route: z.string(), url: z.string().optional(), answers: z.string().optional().describe("The round folder palate named (or comma-separated answer files)"), restore: z.number().optional().describe("Roll the source back to this round's snapshot"), judge: z.enum(["subagent", "api", "self"]).optional().describe("subagent (default: you run each packet with a fresh subagent); api when you can't start subagents (Codex, Cursor) and a model API key is set: palate judges itself; self only when neither is possible: the verdict is marked self-judged") },
+  },
+  async ({ dir, route, url, answers, restore, judge }) => {
+    try {
+      const { gate } = await import("../loop/gate.mjs");
+      return text(await gate(projectDir(dir), route, { url, answers: answers ? answers.split(",") : undefined, restore, judge }));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_match",
+  {
+    title: "Build from the user's own design",
+    description: "When the user gives their own design to build (a screenshot or mockup PNG/JPG, a page URL, a Figma frame link) and wants it faithfully, not palate's look. With source: saves it into .palate/match/<route>/, measures it (colours by share, surfaces, content blocks, the content's span) and writes the fidelity brief (spec.json with every value observed, inferred or substituted; then the build; states and the phone layout are inferred and listed). A Figma link needs FIGMA_TOKEN; without it palate says to export the frame as PNG. With check: renders the build at the design's width, writes the two side by side and a difference image, measures palette distance, text sizes against the spec, motion, contrast and clipping (warnings only), and writes one judge packet for a fresh subagent. With answers (the check's folder): the verdict, READY, READY WITH SUBSTITUTIONS, NOT READY (what's off, most visible first, with the fix; two repair rounds) or UNVERIFIED. restore: roll a worse round back.",
+    inputSchema: { ...dirArg, source: z.string().optional().describe("An image path, a page URL or a Figma frame link (with node-id)"), route: z.string().optional().describe("The route to build it as; default /"), width: z.number().optional().describe("The design's width in CSS px (default: the image's width; a 2400 px+ image is read as @2x; a URL is captured at 1440)"), check: z.boolean().optional().describe("Check the build against the design and write the judge packet"), answers: z.string().optional().describe("The check's folder, after the judge wrote its answers"), restore: z.number().optional().describe("Roll the source back to this match round's snapshot"), url: z.string().optional().describe("Dev server URL if the project isn't Vite") },
+  },
+  async ({ dir, source, route, width, check, answers, restore, url }) => {
+    try {
+      const { match } = await import("../loop/match.mjs");
+      const res = await match(projectDir(dir), source, { route: route ?? "/", width, check, answers, restore, url });
+      return text(res.text);
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_sections",
+  {
+    title: "palate's section archetypes",
+    description: "The library of section archetypes (kb/sections): structures with their finish, phone layout and the checks the judge uses. kind + tags: ranked matches; show: archetypes in full. The blueprint picks from these; use it when rebuilding a section.",
+    inputSchema: { kind: z.string().optional(), tags: z.array(z.string()).optional(), show: z.array(z.string()).optional(), limit: z.number().optional() },
+  },
+  async ({ kind, tags, show, limit }) => {
+    try {
+      const S = await import("../sections.mjs");
+      if (show?.length) return text(S.sectionBrief(show));
+      const list = kind ? S.matchSections({ kind, tags: tags ?? [], limit: limit ?? 8 }) : S.loadSections();
+      return text(list.map((s) => `${s.id} (${s.kind}, ${s.shape}): ${s.layout}`).join("\n"));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_imagery",
+  {
+    title: "Imagery: open-licence photos",
+    description: "Search for every photo slot on the page in ONE call (queries: 6 to 12 searches, run side by side, cached for a week across projects), pick across all the contact sheets, then one pick call; a second batch only for a slot still empty. Never one search per call. For a section that needs a photo: query searches The Met and Cleveland open access (CC0 only) by default; sources [\"commons\"] searches Wikimedia Commons for everyday photographs (people at work, a shop, a street, a tool), keeping only CC0, public domain and CC BY files with no restrictions (never share-alike, non-commercial or no-derivatives), the licence read from each file. A CC BY photo must be credited on the page (palate writes the line in credits.json; palate_guard checks it is there). It returns contact sheets (12 to a sheet, with ids and pixel sizes) to look at. type narrows to one kind: Photograph for real photographs (also Painting, Print, Drawing, Textile, Ceramic, Sculpture, Glass); artist finds one maker's work (a photographer's name). A source that fails or is rate-limited is named in a note and the other's results still come back; answers are cached for 2 hours in .palate (refresh skips the cache). pick downloads the chosen ids into the project (self-hosted) as web-sized JPEGs (longest side 2400 px; a museum mount trimmed unless trim is false) with credits.json and a credits line to show on the page. Use one treatment for every photo on the page (duotone, tone).",
+    inputSchema: { ...dirArg, query: z.string().optional(), queries: z.array(z.string()).optional().describe("Every search the page needs at once (6 to 12), run side by side: much faster than one call per query"), type: z.string().optional().describe("Photograph, Painting, Print, Drawing, Textile, Ceramic, Sculpture or Glass"), artist: z.string().optional().describe("One maker, e.g. a photographer's name"), pick: z.array(z.string()).optional().describe("Candidate ids to download (met-…, cma-…, wc-…)"), from: z.string().optional().describe("The search's slug, for pick"), trim: z.boolean().optional().describe("For pick: trim a museum mount (default true)"), sources: z.array(z.string()).optional().describe("met, cleveland (the default), commons"), count: z.number().optional(), refresh: z.boolean().optional() },
+  },
+  async ({ dir, query, queries, type, artist, pick, from, trim, sources, count, refresh }) => {
+    try {
+      const I = await import("../loop/imagery.mjs");
+      const d = projectDir(dir);
+      if (pick?.length) return text(await I.pickImages(d, pick, { slug: from, trim: trim !== false }));
+      if (queries?.length > 1 || /\|/.test(query ?? "")) {
+        const out = await I.imageryMany(d, queries?.length ? queries : query, { sources, count, type, refresh });
+        const sheets = [...out.matchAll(/(\S+contact\.png)/g)].map((m) => m[1]).filter((f) => fs.existsSync(f)).slice(0, 6);
+        return sheets.length ? { content: [{ type: "text", text: out }, ...sheets.map(image)] } : text(out);
+      }
+      const out = await I.imagery(d, query ?? "", { sources, count, type, artist, refresh });
+      // Every sheet up to three (36 candidates); any more are named in the text.
+      const sheets = [...out.matchAll(/(\S+contact(?:-\d+)?\.png)/g)].map((m) => m[1]).filter((f) => fs.existsSync(f)).slice(0, 3);
+      return sheets.length ? { content: [{ type: "text", text: out }, ...sheets.map(image)] } : text(out);
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_icons",
+  {
+    title: "Brand icons",
+    description:
+      "Real brand marks for a page that names other products (a works-with row, an integrations grid, import sources, a stack list): writes each as a local SVG in the brand's own colour (mono: currentColor) from Simple Icons at a pinned release, with its source and brand guidelines in brands.json. Use it instead of drawing a logo or hotlinking one. A brand the set doesn't carry is reported with near names; then use the brand's press-kit file or its name in text. Each mark is its owner's trademark: only to name that product, never as the page's own logo.",
+    inputSchema: { ...dirArg, names: z.array(z.string()).min(1).describe("Brand names, e.g. Figma, GitHub, Google Drive"), mono: z.boolean().optional() },
+  },
+  async ({ dir, names, mono }) => {
+    try {
+      const { icons } = await import("../loop/icons.mjs");
+      return text(await icons(projectDir(dir), names, { mono }));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_texture",
+  {
+    title: "A material drawn in code",
+    description: "Writes a seeded, seamless texture into the project (grain, paper, speckle, halftone, linen) in the given colour, with the CSS to use it as a surface or an overlay. For the blueprint's texture slots and material bands.",
+    inputSchema: { ...dirArg, name: z.enum(["grain", "paper", "speckle", "halftone", "linen"]), colour: z.string().optional(), opacity: z.number().optional(), seed: z.string().optional() },
+  },
+  async ({ dir, name, colour, opacity, seed }) => {
+    try {
+      const I = await import("../loop/imagery.mjs");
+      return text(I.writeTexture(projectDir(dir), name, { colour, opacity, seed }));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_bench",
+  {
+    title: "The benchmark",
+    description: "30 fictional briefs in 6 categories, each with real reference sites, to measure palate's from-scratch quality honestly. list; new (id, into: scaffold a project); record (id: the latest gate verdict of the project in dir becomes a result row); report (pass rate, tie-or-win rate against the references, minutes).",
+    inputSchema: { ...dirArg, action: z.enum(["list", "new", "record", "report"]), id: z.string().optional(), into: z.string().optional(), minutes: z.number().optional(), note: z.string().optional() },
+  },
+  async ({ dir, action, id, into, minutes, note }) => {
+    try {
+      const Bn = await import("../loop/bench.mjs");
+      if (action === "list") return text(Bn.listBriefs({}).map((b) => `${b.id} (${b.category}): ${b.job}`).join("\n"));
+      if (action === "new") return text(Bn.scaffold(id, path.resolve(into)));
+      if (action === "record") {
+        const { benchResultFrom } = await import("../loop/gate.mjs");
+        return text(JSON.stringify(Bn.recordResult(id, { ...benchResultFrom(projectDir(dir)), minutes, notes: note }), null, 1));
+      }
+      return text(Bn.benchReport({}));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_direction",
+  {
+    title: "Ideas or art directions before a build",
+    description: 'Call it yourself when palate_plan says direction or research; never ask the user to run anything. Two uses. (1) A job-level ask ("users wait ~20 seconds here, what should they see?"): action "brief" with problem; answer with 3 ideas (name, 2–3 sentences, rough ASCII or tiny HTML wireframe; no code). (2) After palate_research: action "brief" with problem (the job) and from_research; answer with 3 art directions (name, metaphor, signature { move, moment }, brand or a starter system, sections, provenance, summary, wireframe). Then action "pick" with the ideas: palate validates them (AA contrast, licence-safe fonts and imagery, the brand kept), and either picks one itself from the user\'s taste (strong history and a clear lead, or choose "auto" when the user said "just build it") and returns the choice, or opens the picker in the user\'s browser for a real judgement call and says why in one line. action "result": the user\'s choice once made. Then palate_build carries it.',
+    inputSchema: {
+      ...dirArg,
+      action: z.enum(["brief", "pick", "result"]).optional(),
+      problem: z.string().optional().describe("brief: the problem or the job, in the user's words"),
+      route: z.string().optional().describe("brief: the route it is about, if any"),
+      from_research: z.string().optional().describe('brief: the research name from palate_research ("latest" for the newest): asks for 3 art directions'),
+      ideas: z
+        .array(z.object({ name: z.string(), summary: z.string().optional().describe("2–3 sentences"), wireframe: z.string().describe("Rough ASCII (≤16 lines) or a tiny HTML snippet"), format: z.enum(["ascii", "html"]).optional() }).catchall(z.any()))
+        .optional()
+        .describe("pick: the 3 ideas, or the 3 art directions with metaphor, signature, brand or starter, sections, provenance"),
+      choose: z.enum(["auto", "user"]).optional().describe('pick: "auto" when the user said "just build it" (palate picks from taste, no picker); "user" when they asked to choose. Omit: palate decides.'),
+      name: z.string().optional().describe("The direction's name (default: the newest)"),
+    },
+  },
+  async ({ dir, action, problem, route, from_research, ideas, choose, name }) => {
+    try {
+      const D = await import("../loop/direction.mjs");
+      const d = projectDir(dir);
+      const a = action ?? (ideas?.length ? "pick" : "brief");
+      if (a === "result") {
+        const entry = pending.get(`direction|${d}`);
+        if (!entry) return fail("No direction picker running. Call palate_direction with the ideas first.");
+        return text(entry.report ?? `Still waiting for the user to choose at ${entry.link}.`);
+      }
+      if (a === "brief") return text(D.direction(d, problem ?? "", { route, name, fromResearch: from_research }));
+      const s = await D.startDirectionPick(d, { ideas, name, open: true, choose });
+      const warn = s.warnings?.length ? `\n\n${s.warnings.map((w) => `⚠ ${w}`).join("\n")}` : "";
+      if (s.auto) return text(`${await s.done}${warn}`);
+      const entry = { link: s.link, report: null };
+      s.done.then((r) => (entry.report = r)).catch((e) => (entry.report = `Picker failed: ${e.message}`));
+      pending.set(`direction|${d}`, entry);
+      return text(`${s.decision?.why ? `${s.decision.why}\n` : ""}The direction picker is open in the user's browser: ${s.link} (${s.count} ${s.decision ? "directions" : "ideas"}). Tell the user in one line why (above) and that it's open; they choose one (and may like or dislike the references, and add a note). Then call palate_direction with action "result".${warn}`);
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_stats",
+  { title: "How long loops take", description: "Recent loops stage by stage (setup, build, judge, the user's pick), loops under way, estimated tokens per mode (build, direction, variants), and the triage's recent decisions.", inputSchema: { ...dirArg } },
+  async ({ dir }) => {
+    try {
+      const { stats } = await import("../loop/stats.mjs");
+      return text(stats(projectDir(dir)));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_shoot",
+  {
+    title: "Look at a screen",
+    description: "Renders a route at desktop and phone width, returns the screenshots and measured problems (contrast, overflow, small text, generic AI patterns, originality) and the similarity gate: it fails when the page is over 50% like another of the user's projects or too close to a captured reference, naming what is too close and what to change. Fix that yourself and shoot again; don't ask the user. While building variants: widths [1440] and fold: true (first screen only, no principles pass).",
+    inputSchema: { ...dirArg, route: z.string().describe("e.g. /pricing"), url: z.string().optional().describe("Dev server URL if the project isn't Vite"), widths: z.array(z.number().int()).optional().describe("Default [1440, 390]"), tablet: z.boolean().optional().describe("Also 1024 and 768 (tablet is where hero photos blow up behind text); palate_gate always checks them"), fold: z.boolean().optional().describe("First screen only, no full page or principles pass"), like: z.array(z.string()).optional().describe("Only when the user asked this page to match another of their projects: that project's name") },
+  },
+  async ({ dir, route, url, widths, tablet, fold, like }) => {
+    try {
+      const { shoot } = await import("../shoot.mjs");
+      const r = await shoot(projectDir(dir), route, { url, widths, tablet: Boolean(tablet), fold: Boolean(fold), like: like ?? [] });
+      return { content: [{ type: "text", text: r.report }, ...r.files.filter((f) => f.endsWith("-fold.png")).map(image)] };
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_polish",
+  {
+    title: "Polish the chosen design",
+    description: "Shoots the before state and returns the polish steps (Jakub Krehel's better-interface/better-ui, Emil Kowalski's emil-design-eng) with the skill files to apply.",
+    inputSchema: { ...dirArg, route: z.string() },
+  },
+  async ({ dir, route }) => {
+    try {
+      const { polish } = await import("../loop/polish.mjs");
+      return text(await polish(projectDir(dir), route, {}));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_check",
+  { title: "Check changed code", description: "Scans the changed lines for generated-UI tells and token drift, and the changed copy (palate copy).", inputSchema: { ...dirArg } },
+  async ({ dir }) => {
+    try {
+      const { check } = await import("../check.mjs");
+      return text(check(projectDir(dir)));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_section",
+  {
+    title: "Check one section",
+    description:
+      "A section builder's own check, in seconds: the section cropped at 1440, 768 and 390 plus palate's floor checks for it (not a full-page shoot). early: true also writes a packet for a fresh judge with the exact questions the final gate will ask; the builder puts its path in its report and the main build runs the judge at once (a fresh subagent, never the builder), then verdict: true reads the answers. A section below the bar goes back to its builder once, while the other sections still build, so the final gate finds less to repair.",
+    inputSchema: { ...dirArg, route: z.string(), section: z.string().describe("The section's blueprint id (its root element's id), name or a selector"), early: z.boolean().optional(), verdict: z.boolean().optional() },
+  },
+  async ({ dir, route, section, early, verdict }) => {
+    try {
+      const { sectionCheck, sectionVerdict } = await import("../loop/gate.mjs");
+      const d = projectDir(dir);
+      return text(verdict ? sectionVerdict(d, route, section) : await sectionCheck(d, route, section, { judge: Boolean(early) }));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_copy",
+  {
+    title: "Check the copy",
+    description:
+      "Reads the words a page shows, from source with no browser, and flags copy that reads as generated: hype verbs, inflated adjectives, stock filler, placeholder text, proof with no number or source, the \"not just X, it's Y\" turn; habits past their limit (a third intensifier, a second fragment slogan, the same vague button twice). Each finding says what to write instead. Call it after writing or changing page copy, before palate_shoot. Defaults to the changed files; all: true reads every file.",
+    inputSchema: { ...dirArg, files: z.array(z.string()).optional().describe("Files to read (relative to the project)."), all: z.boolean().optional() },
+  },
+  async ({ dir, files, all }) => {
+    try {
+      const d = projectDir(dir);
+      const { lintFiles, copyReport } = await import("../copy.mjs");
+      const { changedFiles } = await import("../guard.mjs");
+      const { execFileSync } = await import("node:child_process");
+      const list = files?.length ? files : all ? execFileSync("git", ["ls-files", "--cached", "--others", "--exclude-standard"], { cwd: d, encoding: "utf8" }).split("\n").filter(Boolean) : (changedFiles(d) ?? []);
+      return text(copyReport(lintFiles(d, list), { files: list.length }));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_guard",
+  {
+    title: "The finish guard",
+    description:
+      "palate's guard decides whether UI work is done: every changed screen looked at by palate after its last edit, the changed copy and code tells clean, no gate failing. report (the default): what is open now; call it before telling the user UI work is finished. install: add it as a stop hook for the agents this project uses (Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot; agents picks them, \"git\" adds a pre-commit check for any agent; global: every project), so the agent is sent back with what is open when it stops (3 rounds at most). Install only when the user asked for it or agreed; uninstall removes it.",
+    inputSchema: { ...dirArg, action: z.enum(["report", "install", "uninstall"]).optional(), agents: z.array(z.string()).optional().describe("claude, codex, cursor, gemini, copilot, git (default: the ones this project uses)"), global: z.boolean().optional() },
+  },
+  async ({ dir, action = "report", agents, global }) => {
+    try {
+      const G = await import("../guard.mjs");
+      const d = projectDir(dir);
+      if (action === "report") return text(G.report(d));
+      return text(G.install(d, { agents, global, remove: action === "uninstall" }));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_waive",
+  {
+    title: "Waive a finding",
+    description:
+      "When a guard, copy or check finding is wrong here (the client's own brand word, a screen no dev server can render), waive it by id with the file and a reason a reviewer would accept, in a sentence. Never waive to get past a real problem; fix it instead. An \"unshot\" waiver lasts until that file changes again. Waivers are listed in every guard report, at most 12 per project. action list shows them; remove deletes one.",
+    inputSchema: { ...dirArg, action: z.enum(["add", "list", "remove"]).optional(), id: z.string().optional(), file: z.string().optional(), reason: z.string().optional() },
+  },
+  async ({ dir, action = "add", id, file, reason }) => {
+    try {
+      const G = await import("../guard.mjs");
+      const d = projectDir(dir);
+      if (action === "list") {
+        const w = G.readWaivers(d);
+        return text(w.length ? w.map((x) => `${x.id}${x.file ? ` · ${x.file}` : ""} · ${x.reason} (${x.by})`).join("\n") : "No waivers in this project.");
+      }
+      if (action === "remove") return text(G.removeWaiver(d, id, file));
+      const r = G.addWaiver(d, { id, file, reason, by: "agent" });
+      return r.ok ? text(r.message) : fail(r.message);
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_search",
+  { title: "Component anatomy", description: "Finds knowledge entries (component anatomy, screen patterns, details) for the parts a screen needs. Returns short cards; read full entries with ids.", inputSchema: { query: z.string(), ids: z.array(z.string()).optional().describe("Read these entries in full instead of searching") } },
+  async ({ query, ids }) => {
+    try {
+      const { card, search, show } = await import("../kb.mjs");
+      if (ids?.length) return text(show(ids).join("\n\n---\n\n"));
+      const r = search(query);
+      return text(r.length ? r.map(card).join("\n\n") : "No matches.");
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+// ── palate_research: competitors and craft, looked at live, before ideation (src/loop/research.mjs) ────────────
+server.registerTool(
+  "palate_research",
+  {
+    title: "Research before a new screen",
+    description:
+      'Call it yourself, without asking, when palate_plan says research (a new screen with no strong taste history, or the user wants something new). Step 1 (job, no urls): palate reads the job and the project (product, audience, mood, a working metaphor, brand or scratch) and returns web searches for competitors and category leaders: run them with your own web search tool, take 4–8 official product homepages, then step 2 (same job, urls): palate looks at them plus its own picks live on this machine (robots.txt respected, a few seconds apart per site, at most 12 pages, never logs in or submits anything), ranks them by craft, the user\'s taste and diversity, and writes research.md and a contact sheet (returned as an image). urls: [] skips the search (palate\'s own picks only). Refine the drafted notes from the screenshots, then palate_direction with from_research. action "verdict" with verdicts records what the user said about a reference ("love R2", "not R4"): palate ranks with it next time and learns rules from repeats.',
+    inputSchema: {
+      ...dirArg,
+      action: z.enum(["research", "verdict"]).optional().describe('Default "research"'),
+      job: z.string().optional().describe("The job, in the user's words"),
+      route: z.string().optional(),
+      urls: z.array(z.string()).optional().describe("Step 2: competitor and category-leader homepages from your searches ([] for palate's own picks only)"),
+      inspire: z.array(z.string()).optional().describe("Well-crafted pages outside the category the user or you want looked at"),
+      name: z.string().optional().describe("The research name (default from the product and screen; verdict: default the newest)"),
+      keep: z.number().optional().describe("How many references to keep (4–6 by default)"),
+      verdicts: z.array(z.object({ id: z.string().describe("R1, R2 … or the site's name"), verdict: z.enum(["like", "dislike"]), note: z.string().optional() })).optional().describe("verdict: what the user said about references"),
+    },
+  },
+  async ({ dir, action, job, route, urls, inspire, name, keep, verdicts }) => {
+    try {
+      const R = await import("../loop/research.mjs");
+      const d = projectDir(dir);
+      if (action === "verdict") {
+        const saved = R.recordVerdicts(d, name, verdicts ?? []);
+        return text(saved.length ? `Noted: ${saved.map((s) => `${s.verdict} ${s.ref} ${s.name}`).join(", ")}. palate ranks with it next time; the same trait in two references becomes a proposed rule at palate_taste learn.` : "No matching references: use their ids (R1, R2 …).");
+      }
+      const res = await R.research(d, job ?? "", { route, urls: urls ?? null, inspire: inspire ?? [], name, keep });
+      const sheet = res.data?.contact;
+      return { content: [{ type: "text", text: res.text }, ...(sheet && fs.existsSync(sheet) ? [image(sheet)] : [])] };
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+// ── end palate_research ──────────────────────────────────────────────────────────────────────────────────────────
+
+// ── palate_moves: the moves library (src/moves.mjs, kb/moves/*.md) ─────────────────────────────────────────────
+server.registerTool(
+  "palate_moves",
+  {
+    title: "Creative moves",
+    description:
+      'The moves library: named creative techniques (a hero that paints itself in, an engraved footer with a colour lens, a self-playing product demo, a designed dark mode, a console easter egg…) with palate\'s own recipes (perf, a11y, reduced motion, no-JS fallback, pitfalls, how to verify). You call this yourself, without being asked, whenever you are ideating a screen or upgrading one that is correct but basic: pick the one signature move and one or two supporting moves that fit the brand, then build them from the brief. The user never needs to name a move. action "search" (default) ranks moves by the brand/mood tags (fits minus avoid); pass history (the user\'s kept/reverted moves from ~/.palate) and screen so moves they kept on this kind of screen rise and reverted ones sink. action "show" returns moves in full; action "brief" returns their recipes as compact Markdown to paste into a build brief.',
+    inputSchema: {
+      action: z.enum(["search", "show", "brief"]).optional().describe('Default "search"'),
+      tags: z.array(z.string()).optional().describe("Brand and mood tags, e.g. calm, crafted, editorial, developer, playful (search)"),
+      kind: z.string().optional().describe("Only moves of this kind: hero, texture, motion, interaction, type, layout, imagery, footer, easter-egg, navigation, data, sound-free-feedback (comma separated for several)"),
+      signature: z.boolean().optional().describe("true: only moves that can be the page's one memorable moment"),
+      exclude: z.array(z.string()).optional().describe("Move ids to leave out (e.g. used recently in this project)"),
+      limit: z.number().optional().describe("How many to return (default 8)"),
+      history: z
+        .array(z.object({ id: z.string(), outcome: z.enum(["kept", "reverted"]), kind: z.string().optional().describe("The kind of screen it was used on") }))
+        .optional()
+        .describe("The user's past outcomes with moves: kept ones rise, reverted ones sink, weighted to screen"),
+      screen: z.string().optional().describe("The kind of screen being built (landing, pricing, app…), to weight history"),
+      ids: z.array(z.string()).optional().describe("Move ids (show, brief)"),
+    },
+  },
+  async ({ action = "search", tags = [], kind, signature, exclude = [], limit = 8, history = [], screen, ids = [] }) => {
+    try {
+      const M = await import("../moves.mjs");
+      if (action === "show") return text(ids.length ? ids.map(M.showMove).join("\n\n---\n\n") : "Pass ids to show.");
+      if (action === "brief") return text(ids.length ? M.moveBrief(ids) : "Pass ids for the brief.");
+      const rows = M.matchMoves({ tags, kind, signature, exclude, limit, history, screen });
+      return text(M.movesReport(rows, { tags, kind, signature }) + '\n\nThen palate_moves with action "brief" and the chosen ids, and build from it.');
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+// ── end palate_moves ─────────────────────────────────────────────────────────────────────────────────────────────
+
+server.registerTool(
+  "palate_fail",
+  {
+    title: "The user called a screen bad",
+    description: 'Records a failure: shoots the route at 1440 (or keeps the screenshots given), saves it in ~/.palate/failures with the user\'s words, and proposes rules from them (a measured check when palate knows one: "logos too small" becomes logo marks of at least 24px), for the user\'s OK and scope before they apply anywhere. Briefs for that kind of screen show the failure itself under "Don\'t do this". Call it whenever the user rejects something.',
+    inputSchema: { ...dirArg, route: z.string().describe("e.g. /"), why: z.string().describe("Why it is bad, in the user's words"), kind: z.string().optional().describe("Kinds of screen it applies to, comma separated (landing, hero, logo cloud, pricing, app…); default: from the route"), shots: z.array(z.string()).optional().describe("Screenshot files to keep instead of shooting"), url: z.string().optional() },
+  },
+  async ({ dir, route, why, kind, shots, url }) => {
+    try {
+      const m = await import("../loop/fail.mjs");
+      return text(await m.fail(projectDir(dir), route, why, { kind, shots, url }));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_rule",
+  {
+    title: "The user's rules",
+    description:
+      'The user\'s rules. Active rules are enforced; what palate infers (repeated asks, agreed critique findings, failures) is only proposed, with the scopes its evidence supports, and applies nowhere until the user keeps it. list (default): active rules, then the proposals "waiting for your OK"; add: a rule the user stated (active at once; only/route/project narrow it); edit: new words, kinds or project for a rule; remove; learn: turn new evidence into proposals; proposed: the proposals with their evidence and scope options; review_start: opens a board in the user\'s browser where they edit, scope, keep or discard each proposal (returns the link at once; then review_result); review_result: waits up to 50 s for their answers (applied as soon as they press Apply); approve: keep one proposal (id; scope, only, route or kind; rule for new words), only after the user said so in chat; reject: discard one (remembered, so the same evidence won\'t propose it again).',
+    inputSchema: {
+      action: z.enum(["list", "add", "edit", "remove", "learn", "proposed", "review_start", "review_result", "approve", "reject"]).optional(),
+      rule: z.string().optional().describe("add/edit: the rule; approve: new words for it, if the user changed them"),
+      id: z.string().optional().describe("edit/remove/approve/reject: the rule id, e.g. R3"),
+      kind: z.string().optional().describe("Kinds of screen, comma separated (landing, hero, logo cloud, team, app, all…)"),
+      scope: z.string().optional().describe('approve: "suggested" (default), "everywhere", or an option id from action proposed (e.g. "component:RoleBadge", "route:/team", "kinds:team", "project:palate-site")'),
+      only: z.string().optional().describe("add/approve: only for this component, e.g. RoleBadge"),
+      route: z.string().optional().describe("add/approve: only on this route, e.g. /team"),
+      project: z.string().optional().describe('add/edit/approve: only in this project (its folder name, e.g. palate-site); edit with "all" makes it hold in every project again'),
+    },
+  },
+  async ({ action, rule: words, id, kind, scope, only, route, project }) => {
+    try {
+      const a = action ?? "list";
+      if (a === "review_start") {
+        const { startRuleBoard } = await import("../loop/rulereview.mjs");
+        const b = await startRuleBoard({ open: true });
+        if (!b) return text("Nothing waiting for the user's OK.");
+        const entry = { link: b.link, report: null };
+        b.done.then((r) => (entry.report = r)).catch((e) => (entry.report = `Rule review failed: ${e.message}`));
+        pending.set("rules", entry);
+        return text(`The rule review board is open: ${b.link} (${b.count} proposed rule${b.count > 1 ? "s" : ""}). Tell the user to open it if it didn't open by itself: for each rule they can edit the words, choose where it applies, and keep or discard it, then press Apply. Then call palate_rule with action "review_result".`);
+      }
+      if (a === "review_result") {
+        const entry = pending.get("rules");
+        if (!entry) return fail('No rule review running. Call palate_rule with action "review_start" first.');
+        for (let i = 0; i < 50 && !entry.report; i++) await new Promise((r) => setTimeout(r, 1000));
+        return text(entry.report ?? `Still waiting for the user at ${entry.link}. Call review_result again when they say they're done.`);
+      }
+      const { rule } = await import("../loop/fail.mjs");
+      const sub = { remove: "rm", approve: "ok", reject: "no" }[a] ?? a;
+      const args = a === "add" ? [words ?? ""] : ["edit", "remove", "approve", "reject"].includes(a) ? [id ?? "", ...(a === "edit" && words ? [words] : [])] : [];
+      return text(rule(sub, args, { kind, only, route, scope, project, dir: DEFAULT_DIR, text: a === "approve" ? words : undefined }));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+// Commands for specific jobs: critique (with the user's review board), fix, vary, details, animate.
+const routeArg = { route: z.string().describe("e.g. / or /pricing"), url: z.string().optional().describe("Dev server URL, if palate shouldn't start or find one") };
+const finding = z.object({
+  id: z.string().optional(),
+  section: z.union([z.string(), z.number()]).describe('The section number from the critique sheet, or "page"'),
+  severity: z.enum(["high", "medium", "low", "idea"]),
+  what: z.string().describe("What is wrong, naming the element"),
+  why: z.string().optional().describe("Why it matters"),
+  fix: z.string().describe("The concrete change"),
+  rubric: z.string().optional().describe("The rubric item, e.g. page.2, section.5, M16"),
+  width: z.number().optional().describe("1440 or 390 when it only shows at one width"),
+});
+
+server.registerTool(
+  "palate_critique",
+  {
+    title: "A designer's review of a page",
+    description: "Renders the route at 1440 and 390, crops every section, measures the whole page (repeated devices, screenshots vs live product, logo rows, motion) and returns a critique sheet with the user's taste and a rubric. Write findings in its schema, then call palate_critique_review_start.",
+    inputSchema: { ...dirArg, ...routeArg },
+  },
+  async ({ dir, route, url }) => {
+    try {
+      const { critique } = await import("../loop/critique.mjs");
+      const r = await critique(projectDir(dir), route, { url });
+      return { content: [{ type: "text", text: r.sheet }, ...r.images.filter((f) => fs.existsSync(f)).map(image)] };
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_critique_review_start",
+  {
+    title: "Let the user review the critique",
+    description: "Saves the findings and opens a review board in the user's browser, where they agree or disagree with each one (disagreements teach their taste). Returns the link at once; then call palate_critique_review_result.",
+    inputSchema: { ...dirArg, route: z.string().optional().describe("The route the critique was for (defaults to the latest critique)"), findings: z.array(finding).optional(), file: z.string().optional().describe("A findings JSON file instead of the findings array") },
+  },
+  async ({ dir, route, findings, file }) => {
+    try {
+      const { latestCritique, startBoard } = await import("../loop/critique.mjs");
+      const d = projectDir(dir);
+      let target = file;
+      if (findings?.length) {
+        const session = latestCritique(d, route);
+        if (!session) throw new Error("No critique yet. Call palate_critique first.");
+        target = path.join(session, "findings.json");
+        fs.writeFileSync(target, JSON.stringify({ route, findings }, null, 2));
+      }
+      if (!target) throw new Error("Pass findings (or a findings file).");
+      const b = await startBoard(d, target, { open: true });
+      const entry = { link: b.link, report: null };
+      b.done.then((r) => (entry.report = r)).catch((e) => (entry.report = `Review board failed: ${e.message}`));
+      pending.set(`critique|${d}`, entry);
+      return text(`The review board is open: ${b.link} (${b.count} findings). Tell the user to open it if it didn't open by itself, mark each finding, and press "Send to the agent". Then call palate_critique_review_result.`);
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_critique_review_result",
+  {
+    title: "The user's verdicts on the critique",
+    description: "Returns which findings the user agreed and disagreed with (and their notes) once they have sent them; otherwise says it is still waiting. Wait for the user before calling again.",
+    inputSchema: { ...dirArg },
+  },
+  async ({ dir }) => {
+    const entry = pending.get(`critique|${projectDir(dir)}`);
+    if (!entry) return fail("No review board running. Call palate_critique_review_start first.");
+    return text(entry.report ?? `Still waiting for the user at ${entry.link}.`);
+  },
+);
+
+server.registerTool(
+  "palate_fix",
+  {
+    title: "Fix what the critique found",
+    description: "A brief from the findings the user agreed with in the latest critique, most severe first, with each section's crops (with no critique: what palate shoot measures as wrong). verify: re-renders each finding's section and returns before | after.",
+    inputSchema: { ...dirArg, ...routeArg, verify: z.boolean().optional() },
+  },
+  async ({ dir, route, url, verify }) => {
+    try {
+      const { fix } = await import("../loop/fix.mjs");
+      const out = await fix(projectDir(dir), route, { url, verify: Boolean(verify) });
+      const imgs = verify ? [...out.matchAll(/(\S+(?:before-after|page-before-after)\.png)/g)].map((m) => m[1]).filter((f) => fs.existsSync(f)) : [];
+      return { content: [{ type: "text", text: out }, ...imgs.map(image)] };
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_vary",
+  {
+    title: "Vary one section",
+    description: "Fresh variations of one section of a page: copies the page into variant routes and writes one brief per variant (a different structural idea and references each). Build every brief, then palate_pick_start with the name it gives.",
+    inputSchema: { ...dirArg, ...routeArg, section: z.string().describe("The section's name, heading, id or a CSS selector"), count: z.number().int().min(2).max(6).optional() },
+  },
+  async ({ dir, route, url, section, count }) => {
+    try {
+      const { vary } = await import("../loop/vary.mjs");
+      return text(await vary(projectDir(dir), route, { section, count: count ?? 3, url }));
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+// ── palate ambition: the remarkable-not-only-correct pass (src/loop/ambition.mjs) ──
+server.registerTool(
+  "palate_ambition",
+  {
+    title: "Make it remarkable, not only correct",
+    description:
+      "Call it yourself as the last step of every finishing pass (after palate_shoot, palate_states, palate_details, palate_animate), with no question to the user. 1) palate_ambition with route: renders the page at 1440, puts the first screen and every section beside the strongest references (the research step's captures, else the user's references, else palate's library) and the signature move, measures what it can, and returns the sheets plus a strict rubric. 2) Look at the sheets, score every section 0–10 on the rubric (screenshot-worthy, memorable moment, signature delivered, type with character, point of view in copy, hierarchy and rhythm against the references, nothing generic), and call palate_ambition with scores: it picks the weakest section and returns its upgrade brief (what's generic, moves from the moves library with recipes, led by what this user kept before, and what to keep). 3) Upgrade that one section once, then palate_ambition with verify: true and moves (the move ids you used): before | after with new scores, and the outcome is logged so palate learns which upgrades this user keeps. If the similarity gate fails, fix that first.",
+    inputSchema: {
+      ...dirArg,
+      ...routeArg,
+      scores: z.union([z.string(), z.record(z.string(), z.any())]).optional().describe('Step 2: your rubric scores, as a file path or inline: {"sections": [{"index": 2, "scores": {"screenshot": 3, "moment": 2, "signature": null, "type": 4, "copy": 5, "hierarchy": 6, "generic": 3}, "generic": "what reads as template", "keep": "what works"}]}'),
+      verify: z.boolean().optional().describe("Step 3: after the one upgrade, re-render that section before | after"),
+      moves: z.array(z.string()).optional().describe("With verify: the move ids you used for the upgrade"),
+    },
+  },
+  async ({ dir, route, url, scores, verify, moves }) => {
+    try {
+      const { ambition } = await import("../loop/ambition.mjs");
+      const out = await ambition(projectDir(dir), route, { url, scores, verify: Boolean(verify), moves });
+      const imgs = [...out.matchAll(/(\S+(?:first-screen|sections-side-by-side|before-after)\.png)/g)].map((m) => m[1]).filter((f) => fs.existsSync(f));
+      return { content: [{ type: "text", text: out }, ...[...new Set(imgs)].map(image)] };
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+// ── end palate ambition ──
+
+server.registerTool(
+  "palate_details",
+  {
+    title: "Upgrade the small parts",
+    description: "Finds generic micro-components (initial avatars, monochrome or missing brand marks, default inputs, bare empty states, raw numbers, emoji, mixed icons, placeholder text, badge soup, missing hover/focus/pressed states, favicon and social image) and returns a brief with each one's upgrade and crops.",
+    inputSchema: { ...dirArg, ...routeArg },
+  },
+  async ({ dir, route, url }) => {
+    try {
+      const { details } = await import("../loop/details.mjs");
+      const out = await details(projectDir(dir), route, { url });
+      const imgs = [...out.matchAll(/(\S+(?:details|logo-cloud-refs)\.png)/g)].map((m) => m[1]).filter((f) => fs.existsSync(f));
+      return { content: [{ type: "text", text: out }, ...imgs.map(image)] };
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_states",
+  {
+    title: "Every state of a screen",
+    description: "The last 20%: finds the screen's stateful parts (lists, tables, cards, forms, numbers, images, text from data, buttons that act) from the DOM and its source, renders each state without touching the code (empty, loading, error 500, network down, no answer, long text, 50 items, one item, images failing, 320 wide, 200% zoom with a keyboard pass, forms pressed twice / failing / offline / empty), measures each one, and returns a brief of the missing states with a contact sheet (a row per part, a column per state). Data written in the code is said to be static, and only DOM-level states run. verify: renders them again and returns each earlier finding before | after.",
+    inputSchema: { ...dirArg, ...routeArg, verify: z.boolean().optional() },
+  },
+  async ({ dir, route, url, verify }) => {
+    try {
+      const { states } = await import("../loop/states.mjs");
+      const out = await states(projectDir(dir), route, { url, verify: Boolean(verify) });
+      const imgs = [out.sheet].filter((f) => f && fs.existsSync(f));
+      return { content: [{ type: "text", text: out.text }, ...imgs.map(image)] };
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_animate",
+  {
+    title: "A motion pass",
+    description: "Runs the motion check (frame strips on load and per section, content left invisible, layout shift, reduced motion, JavaScript off) and returns a brief for motion that serves the content, with the motion skills installed. check: only the check, to verify the pass.",
+    inputSchema: { ...dirArg, ...routeArg, check: z.boolean().optional() },
+  },
+  async ({ dir, route, url, check }) => {
+    try {
+      const { animate } = await import("../loop/animate.mjs");
+      const out = await animate(projectDir(dir), route, { url, checkOnly: Boolean(check) });
+      const imgs = [...out.matchAll(/(\S+-strip\.png)/g)].map((m) => m[1]).filter((f) => fs.existsSync(f));
+      return { content: [{ type: "text", text: out }, ...imgs.map(image)] };
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+// palate point: the user points at elements in their running app and says what should change; the agent
+// takes the requests one at a time (next → fix in the source → crop to verify → done).
+server.registerTool(
+  "palate_point_start",
+  {
+    title: "Let the user point at what to fix",
+    description: "Starts (or reuses) the project's dev server behind palate's overlay and opens it in the user's browser. The user clicks any element, says what should change and sends it; requests queue up as numbered pins. Returns the link; then keep calling palate_point_next for as long as point runs, without waiting to be asked.",
+    inputSchema: { ...dirArg, route: z.string().optional().describe("The page to open, e.g. / or /pricing"), url: z.string().optional().describe("Dev server URL, if palate shouldn't start or find one") },
+  },
+  async ({ dir, route, url }) => {
+    try {
+      const { startPoint } = await import("../point/server.mjs");
+      const d = projectDir(dir);
+      const s = await startPoint(d, { route: route ?? "/", url, open: true });
+      const { pointState } = await import("../point/server.mjs");
+      const agent = (await pointState(d).catch(() => null))?.agent;
+      if (agent?.auto)
+        return text(`palate point is running: ${s.link} (in front of ${s.base}), and palate point --auto is already taking the pins with a headless agent. Give the user the link; you don't need to call palate_point_next.`);
+      return text(`${s.reused ? "palate point is already running" : "palate point is running"}: ${s.link} (in front of ${s.base}). Give the user this link: they turn on point mode with the palate button or Alt+P, click an element, type what should change (or tap a chip) and send. For something inside a modal, a dropdown or a tab, they open it first, then press Alt+P: palate reopens it for every check. The overlay shows them whether you are listening.
+
+Now listen, without waiting to be asked:
+- Call palate_point_next right away, and again every time it returns, for as long as point is running. It waits up to 55 s; "Still listening" means nothing came yet: call it again at once.
+- For each pin: fix it, palate_point_crop to check (it shows both widths; a "broke" at the other width needs fixing too), palate_point_done, then straight back to palate_point_next.
+- Don't end your turn while point is running. If the user writes something else in chat, answer it, then go back to palate_point_next.
+- Stop only when the user says they're done, or palate_point_next says they pressed Done.`);
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_point_next",
+  {
+    title: "The next thing the user pointed at",
+    description: "Waits up to 55 s for the next pin and returns it, marked as being worked on: the user's words and chips, the element (selector, DOM path, component and owners, trimmed HTML, key styles), a crop, and the likely source lines. A pin inside an opened state (a modal, a dropdown, a tab) says which steps open it; palate replays them before every crop. \"Still listening\" means nothing came yet: call it again at once, and keep calling it while point runs (each call tells the overlay you're listening). Stop when it says the user pressed Done.",
+    inputSchema: { ...dirArg, wait: z.number().int().min(1).max(55).optional().describe("Seconds to wait (default 55)") },
+  },
+  async ({ dir, wait }) => {
+    try {
+      const { nextRequest, formatRequest } = await import("../point/server.mjs");
+      const d = projectDir(dir);
+      const r = await nextRequest(d, { wait: wait ?? 55, agent: "mcp" });
+      // Cheap on purpose: idle polling is one short line, no images.
+      if (!r) return text("Still listening. Nothing new; call palate_point_next again.");
+      if (r.stopped) return text("The user stopped point mode (Done in the overlay). Stop calling palate_point_next; tell them what you fixed. If they send more pins later, they can ask you to listen again.");
+      const asked = r.other?.asked && r.other.before?.crop && fs.existsSync(r.other.before.crop) ? [{ type: "text", text: `Before at ${r.other.width} (where the user says the problem is):` }, image(r.other.before.crop)] : [];
+      return { content: [{ type: "text", text: `${formatRequest(r, d)}\n- When it's done, call palate_point_next again right away: the user may have queued more.` }, ...(r.crop && fs.existsSync(r.crop) ? [{ type: "text", text: `Before at ${r.viewport?.width ?? "the pinned width"} (when the user pointed):` }, image(r.crop)] : []), ...asked] };
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_point_crop",
+  {
+    title: "Look at the element now",
+    description: "Re-shoots a request's element after your edit at both widths: the one the user pinned at (their viewport and scroll) and the other one (390 for a desktop pin, 1440 for a phone pin, or the width the user's words name: \"on mobile\", \"at 768px\"). Returns before and now at each, and a verdict for the other width: unchanged, changed (shown; often expected for shared CSS) or broke (the page now scrolls sideways, the element disappeared, or text in it is cut off). Fix a broke before palate_point_done: done refuses while it stands. A pin inside an opened state (a modal, a dropdown, a tab) is shot in that state: palate replays the steps that opened it first, and says when it couldn't reopen it (not checked there, never a break).",
+    inputSchema: { ...dirArg, id: z.string() },
+  },
+  async ({ dir, id }) => {
+    try {
+      const { cropRequest } = await import("../point/server.mjs");
+      const c = await cropRequest(projectDir(dir), id);
+      const has = (f) => f && fs.existsSync(f);
+      const w = c.viewport?.width ?? "the pinned width";
+      const main = c.removed ? `At ${w} (pinned): removed, the element is gone (as asked), so there's no after crop. Before:` : `At ${w} (pinned): before | now${c.trail ? ` (in the state opened by: ${c.trail})` : ""}${c.found === false ? " (the selector no longer matches; this is the region where the element was)" : ""}`;
+      const o = c.other;
+      const state = (s) => (s === "hidden" ? "hidden at this width, so the screen around where it was" : s === "missing" ? "not on the page at this width, so the screen around where it was" : null);
+      const other = o
+        ? [
+            { type: "text", text: `${o.note} Before | now${[state(o.beforeState) && `before: ${state(o.beforeState)}`, state(o.afterState) && `now: ${state(o.afterState)}`].filter(Boolean).map((x) => ` (${x})`).join("")}:` },
+            ...(has(o.before) ? [image(o.before)] : []),
+            ...(has(o.after) ? [image(o.after)] : []),
+          ]
+        : [];
+      const stuck = c.reopen?.state === "couldn't reopen" ? [{ type: "text", text: `At ${w}: palate couldn't reopen the state this element sits in (${c.reopen.why}), so "now" is the page as it loads. That isn't a break; check the change in the code.` }] : [];
+      const fix = o?.verdict === "broke" ? [{ type: "text", text: `Fix ${o.width} before palate_point_done: it refuses while ${o.width} is broken. Then palate_point_crop again.` }] : [];
+      return { content: [{ type: "text", text: main }, ...(has(c.before) ? [image(c.before)] : []), ...(c.removed ? [] : [image(c.file)]), ...stuck, ...other, ...fix] };
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+server.registerTool(
+  "palate_point_done",
+  {
+    title: "Mark a pointed request done",
+    description: "Marks the request done with a one-line summary, re-shoots the element at both widths (the pinned one and the other one) and saves the after crops. The user's pin turns done and shows before and after at both. Refuses while the other width is broken (the page scrolls sideways, the element disappeared, or text in it is cut off): fix it, or pass override only when the user accepts it. Then call palate_point_next for the next one.",
+    inputSchema: { ...dirArg, id: z.string(), summary: z.string().describe("One line: what changed"), removed: z.boolean().optional().describe("You removed the element (as asked): the after view says Removed instead of cropping what sits there now"), override: z.boolean().optional().describe("Mark it done even though the other width broke. Only when the user accepts that; the pin keeps the warning") },
+  },
+  async ({ dir, id, summary, removed, override }) => {
+    try {
+      const { doneRequest } = await import("../point/server.mjs");
+      const r = await doneRequest(projectDir(dir), id, summary, { removed: Boolean(removed), override: Boolean(override) });
+      const o = r.other?.width ? r.other : null;
+      const imgs = [r.crop, r.after, o?.before?.crop, o?.after?.crop].filter((f) => f && fs.existsSync(f));
+      return { content: [{ type: "text", text: `Pin ${r.n} is done${r.removed ? " (removed: the pin shows Removed as the after)" : ""}. Before | after at ${r.viewport?.width ?? "the pinned width"} below${o ? `, then at ${o.width}${o.after?.removed ? " (removed there)" : ""}. ${o.note ?? ""}${o.overridden ? " Done anyway (override): the pin shows the warning to the user." : ""}` : "."} Now call palate_point_next (keep listening; don't end your turn).` }, ...imgs.map(image)] };
+    } catch (e) {
+      return fail(e);
+    }
+  },
+);
+
+const refsStep = (refs) => (refs ? ` My references: ${refs}. palate_refs_add each one with what I like and dislike about it; if I haven't said, ask me first.` : "");
+const finishStep = "Then the finishing pass on that page: palate_shoot at both widths (a failing rule or similarity gate is fixed first, by you), palate_states (build the missing states it lists, then verify: true), palate_details, palate_animate with check if it moves, then palate_ambition (score the sections, upgrade the weakest once, verify). Then palate_point_start and give me the link: I point at what's wrong and you fix exactly that (palate_point_next, palate_point_crop, palate_point_done). Keep calling palate_point_next without waiting for me to tell you, until I say I'm done or press Done in the overlay.";
+const loopPrompt = (screen, refs) =>
+  `Design ${screen} with palate: build, finish, then I point at what's wrong.${refsStep(refs)}
+1. palate_plan first. direct: change it in place, one palate_shoot (widths [1440], fold: true), palate_check, and stop.
+2r. research (a new screen, or I want something new): palate_research with my words, run its searches yourself, palate_research again with the homepages you found, refine its notes from the screenshots, then palate_direction with from_research and 3 art directions; palate picks one or opens the picker if it is a real judgement call. Then step 3. Don't ask me to run anything.
+2. direction (a question or a problem): palate_direction with my words, answer its brief with 3 ideas and rough wireframes (no code), then palate_direction with the ideas and tell me the picker is open; palate_direction with action "result" after I've chosen. Then step 3.
+3. build (the default): palate_context, then palate_build with the job in my words and the route; one builder follows its brief. ${finishStep}
+4. quick or full (variants): only when I asked to explore or it's a new kind of screen. Tell me the token cost the triage shows and offer build mode first; if I still want variants, run the explore flow (palate_variants, palate_pick_start with ready, palate_build with the loop's name).
+Throughout: every brief opens with my rules; if I reject something, palate_fail with my words. At the end, palate_taste with action learn, and if it proposes rules, show them to me (palate_rule review_start).`;
+
+server.registerPrompt(
+  "design",
+  { title: "Design a screen", description: "Triage, then the default: one build from your references and rules, the finishing pass, then you point at what's wrong. Ideas first for a job-level question.", argsSchema: { screen: z.string().describe("What to build"), refs: z.string().optional().describe("Your references: image paths or URLs, comma separated") } },
+  ({ screen, refs }) => ({ messages: [{ role: "user", content: { type: "text", text: loopPrompt(screen, refs) } }] }),
+);
+server.registerPrompt(
+  "explore",
+  { title: "Explore variants", description: "Opt-in: sketches in different directions, your blind pick as soon as they're ready, the winner built out. Costs more tokens than a build.", argsSchema: { screen: z.string(), refs: z.string().optional() } },
+  ({ screen, refs }) =>
+    say(`Explore ${screen} with palate: I want options.${refsStep(refs)}
+1. palate_plan with mode "quick" (one section) or "full" (a page); tell me its token estimate next to build mode's.
+2. palate_context and palate_taste; palate_variants with the job in my words (briefs are sketches: first screen and centrepiece). Build every brief in parallel subagents if you can; each shoots once at 1440 with fold: true.
+3. Right away, palate_pick_start with the ready number the variants result gives (more than 4 variants: palate_judge_render with ready, a fresh judge scores, palate_judge_score first); tell me the picker is coming. palate_pick_result after I've picked.
+4. palate_build with the loop's name; one builder completes the winner, moves it to the real route and deletes the other variants. ${finishStep}
+5. palate_polish; palate_taste with action learn (show me any proposed rules: palate_rule review_start).`),
+);
+server.registerPrompt(
+  "direction",
+  { title: "Ideas for a problem", description: "Describe the problem (\"users wait 20 seconds here\"); get 3 short ideas with rough wireframes, pick one, then it's built.", argsSchema: { problem: z.string().describe("The problem, in your words"), route: z.string().optional() } },
+  ({ problem, route }) =>
+    say(`Help me with this, with palate: "${problem}"${route ? ` (on ${route})` : ""}. palate_direction with the problem${route ? " and route" : ""}; read its brief and answer with 3 different ideas (a name, 2–3 sentences, a rough ASCII or tiny HTML wireframe each; no code). Then palate_direction with the ideas, tell me the picker is open, and palate_direction with action "result" after I've chosen. Then palate_build with the job and route (it carries the idea I chose), one builder. ${finishStep}`),
+);
+server.registerPrompt(
+  "polish",
+  { title: "Polish a screen", description: "Final polish pass on an existing screen.", argsSchema: { route: z.string() } },
+  ({ route }) => ({ messages: [{ role: "user", content: { type: "text", text: `Polish ${route} with palate: palate_taste, palate_shoot to see it, then palate_polish and apply its steps; shoot again and keep only changes that look better; palate_check at the end.` } }] }),
+);
+
+const say = (t) => ({ messages: [{ role: "user", content: { type: "text", text: t } }] });
+server.registerPrompt(
+  "critique",
+  { title: "Critique a page", description: "A designer's review, section by section; you agree or disagree with each finding.", argsSchema: { route: z.string() } },
+  ({ route }) => say(`Critique ${route} with palate: palate_critique, then open every section crop and write specific findings in its schema (whole-page findings for repeated devices, static screenshots and missing motion; at least one idea for each generic section). Then palate_critique_review_start with the findings and give me the link; palate_critique_review_result after I've sent my verdicts. Don't change any code yet.`),
+);
+server.registerPrompt(
+  "fix",
+  { title: "Fix a page", description: "Fixes the critique findings you agreed with (or what is measurably wrong), then verifies each one.", argsSchema: { route: z.string() } },
+  ({ route }) => say(`Fix ${route} with palate: palate_fix and follow its brief, most severe first, keeping the design's idea. Then palate_fix with verify: true, open each before | after and tell me per finding: fixed, partly or not. Finish with palate_check and the project's typecheck.`),
+);
+server.registerPrompt(
+  "vary",
+  { title: "Vary one section", description: "Fresh variations of one section, shown in the page; you pick.", argsSchema: { route: z.string(), section: z.string().describe("The section's name, heading or selector") } },
+  ({ route, section }) => say(`Vary the "${section}" section of ${route} with palate: palate_vary, build every brief (parallel subagents if you can, each changing only the section in its route), then palate_pick_start with the name it gave and give me the link; palate_pick_result after I've picked. Then do what the result says: move the winner into the page and delete every variant route.`),
+);
+server.registerPrompt(
+  "details",
+  { title: "Upgrade the small parts", description: "Avatars, brand marks, inputs, empty states, numbers, icons, states, favicon: the micro-details pass.", argsSchema: { route: z.string() } },
+  ({ route }) => say(`Run palate's details pass on ${route}: palate_details, look at the crops, and upgrade each part as its brief says, with real content only (real people's photos or generated avatars, official brand marks). Then palate_details again to confirm they're gone, and palate_shoot to look at the result.`),
+);
+server.registerPrompt(
+  "states",
+  { title: "Every state of a screen", description: "Empty, loading, error, long text, many items, failing images, narrow, keyboard, forms pressed twice: rendered, measured, and the missing ones built.", argsSchema: { route: z.string() } },
+  ({ route }) => say(`Run palate's states pass on ${route}: palate_states, open the contact sheet and the crops of each finding, then build the missing states its brief lists, most important first, with the project's own components and the copy guidance (empty states say what to do next; errors say what happened and what to do). Don't change the design otherwise. Then palate_states with verify: true, open the before | after and tell me per finding: fixed or still failing. If palate says the data is static, tell me which states it couldn't simulate.`),
+);
+server.registerPrompt(
+  "animate",
+  { title: "Add motion that serves the content", description: "A motion pass with a frame-strip check, reduced motion and no-JS verified.", argsSchema: { route: z.string() } },
+  ({ route }) => say(`Run palate's motion pass on ${route}: palate_animate, read the strips and the brief, read the motion skills it names, and add motion where it explains something (never hiding content). Then palate_animate with check: true and look at the strips: no hidden content (normal, reduced motion, JavaScript off), no layout shift.`),
+);
+
+server.registerPrompt(
+  "point",
+  { title: "Fix what I point at", description: "Opens your app with palate's overlay: click any element, say what should change, and the agent fixes exactly that, live.", argsSchema: { route: z.string().optional().describe("The page to open, e.g. / or /pricing") } },
+  ({ route }) =>
+    say(`Run palate point${route ? ` on ${route}` : ""}: palate_point_start${route ? ` with route "${route}"` : ""} and give me the link. Then keep listening for my pins without waiting for me to say anything, and don't end your turn while point is running:
+- Call palate_point_next, and call it again every time it returns. "Still listening" means nothing came yet: call it again at once.
+- For each pin: fix exactly that element or section in the source it points to (confirm the file by the text and classes; change nothing around it; keep the project's tokens and components); palate_point_crop to verify it looks better at both widths, fixing once more if not (and fixing the other width if it broke); palate_point_done with the id and a one-line summary; then straight back to palate_point_next.
+- For a pin with "Variants of this", run palate_vary with that route and the pin's selector as the section, build the briefs, and palate_pick_start instead of editing in place; mark it done once the pick is made real.
+- If I write something else in chat, answer it, then go back to palate_point_next.
+- Stop only when I say I'm done, or palate_point_next says I pressed Done in the overlay.`),
+);
+
+await server.connect(new StdioServerTransport());