diff --git a/README.md b/README.md
index 877a498..0e6a92c 100644
--- a/README.md
+++ b/README.md
@@ -13,6 +13,11 @@
 * Added ability to suffer immense pain, trying to use a UI created/modified by pifreak!
 * Added ability to upload list of SEEDS in TXT or CSV format!
 
+## Assistant, WebMCP, and seed lists
+* **Chat button (top right):** an in-app Balatro assistant powered by the Anthropic API. Paste your own API key in its settings (it stays in your browser's localStorage and goes straight to `api.anthropic.com`). It reads and drives the app through tools: analyze a seed, read any ante's shop queue and packs, find items across antes, mark purchases, navigate, load seed lists, edit the JAML filter, and `remember` notes about you so later sessions are personalized.
+* **WebMCP:** the same tools are registered on `document.modelContext` (with the `@mcp-b/webmcp-polyfill` fallback), so browser agents and the Chrome DevTools WebMCP pane / Model Context Tool Inspector extension can call `analyze_seed`, `get_seed_overview`, `find_items`, `buy_item`, `load_seed_list`, `step_seed_queue`, `set_jaml_filter` and friends directly.
+* **Seed lists:** paste hundreds or thousands of seeds (one per line, comma/space separated, or a CSV with seeds in the first column) into the *Seed list* box in the sidebar. `ArrowLeft` / `ArrowRight` step through them, `Home` / `End` jump to the first/last; neighbours are pre-analyzed so switching is instant.
+
 ## pifreak's roadmap:
 * Continue testing motely-wasm
 * Continue unlocking performance using SharedArrayBuffer properly?
diff --git a/___tests___/webmcp.spec.ts b/___tests___/webmcp.spec.ts
new file mode 100644
index 0000000..b585ce0
--- /dev/null
+++ b/___tests___/webmcp.spec.ts
@@ -0,0 +1,62 @@
+import { describe, expect, it } from "vitest";
+import { analyzeSeed } from "../src/modules/GameEngine";
+import { describeAnte, findItems, summarizeSeed } from "../src/modules/webmcp/summary";
+import { parseSeedList } from "../src/modules/state/store";
+
+const options = { buys: {}, sells: {}, showCardSpoilers: false, unlocks: [], events: [], maxMiscCardSource: 15 };
+
+function analyze(seed: string, antes = 3) {
+    const results = analyzeSeed({ seed, deck: "Ghost Deck", stake: "White Stake", gameVersion: "10106", antes, cardsPerAnte: 20 }, options);
+    if (!results) throw new Error("analysis failed");
+    return results;
+}
+
+describe("seed summaries", () => {
+    it("summarizes every generated ante in order", () => {
+        const summary = summarizeSeed("WEEJOKER", analyze("WEEJOKER", 4), 5);
+        expect(summary.antes.map((a) => a.ante)).toEqual([0, 1, 2, 3, 4]);
+        for (const ante of summary.antes) {
+            expect(ante.shop.length).toBeLessThanOrEqual(5);
+            expect(ante.shopSize).toBeGreaterThan(0);
+            expect(typeof ante.boss).toBe("string");
+            expect(ante.packs.length).toBeGreaterThan(0);
+        }
+    });
+
+    it("finds items where the ante details say they are", () => {
+        const results = analyze("WEEJOKER");
+        const ante1 = describeAnte(results.antes[1]);
+        const first = ante1.shop[0];
+        const bare = first.item.replace(/ \(.*\)$/, "");
+        const hits = findItems(results, [bare])[bare];
+        expect(hits.some((h) => h.ante === 1 && h.source === "shop" && h.index === 0)).toBe(true);
+    });
+
+    it("returns empty matches for unknown names", () => {
+        expect(findItems(analyze("WEEJOKER"), ["Definitely Not A Card"])).toEqual({ "Definitely Not A Card": [] });
+    });
+});
+
+describe("parseSeedList", () => {
+    it("accepts newline, comma and whitespace separated seeds and dedupes", () => {
+        expect(parseSeedList("aleeb\nPIROCKS weejoker\naleeb")).toEqual(["ALEEB", "PIROCKS", "WEEJOKER"]);
+    });
+
+    it("takes the first column of CSV rows, skips numeric tally columns and a seed header", () => {
+        expect(parseSeedList("seed,score\nFAJK8SAR, 11, 1, 0\n16661,2")).toEqual(["FAJK8SAR", "16661"]);
+    });
+
+    it("keeps every seed of a comma-separated list", () => {
+        expect(parseSeedList("ALEEB,PIROCKS, WEEJOKER;16661\tABC1")).toEqual(["ALEEB", "PIROCKS", "WEEJOKER", "ABC1"]);
+    });
+
+    it("includes ante 0 in item searches", () => {
+        const results = analyze("WEEJOKER", 2);
+        const name = describeAnte(results.antes[0]).shop[0].item.replace(/ \(.*\)$/, "");
+        expect(findItems(results, [name])[name].some((h) => h.ante === 0)).toBe(true);
+    });
+
+    it("sanitizes zeros and junk", () => {
+        expect(parseSeedList("a0b-c!d 123456789ABC")).toEqual(["AOBCD", "12345678"]);
+    });
+});
diff --git a/package-lock.json b/package-lock.json
index caf3f67..ac0dcfd 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8,11 +8,13 @@
       "name": "blueprint",
       "version": "1.0.0",
       "dependencies": {
+        "@anthropic-ai/sdk": "^0.125.0",
         "@mantine/carousel": "8.3.14",
         "@mantine/code-highlight": "8.3.14",
         "@mantine/core": "8.3.14",
         "@mantine/hooks": "8.3.14",
         "@mantine/spotlight": "8.3.14",
+        "@mcp-b/webmcp-polyfill": "^5.1.0",
         "@tabler/icons-react": "^3.41.1",
         "@tanstack/react-query": "^5.85.9",
         "embla-carousel-react": "^8.6.0",
@@ -62,6 +64,27 @@
         "node": ">=6.0.0"
       }
     },
+    "node_modules/@anthropic-ai/sdk": {
+      "version": "0.125.0",
+      "resolved": "https://registry.npmjs.org/@anthropic-ai/sdk/-/sdk-0.125.0.tgz",
+      "integrity": "sha512-Hq5wYlXupzJ9M1Fzqjqa3hObcuigEXVZJqSYDgeZGM3wF4qrNERM5Z1OOAeoT9rlod8awJ3uYyJjbQXp1ckIGg==",
+      "license": "MIT",
+      "dependencies": {
+        "json-schema-to-ts": "^3.1.1",
+        "standardwebhooks": "^1.0.0"
+      },
+      "bin": {
+        "anthropic-ai-sdk": "bin/cli"
+      },
+      "peerDependencies": {
+        "zod": "^3.25.0 || ^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "zod": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/@babel/code-frame": {
       "version": "7.27.1",
       "dev": true,
@@ -1111,6 +1134,56 @@
         "react": "^18.x || ^19.x"
       }
     },
+    "node_modules/@mcp-b/webmcp-polyfill": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/@mcp-b/webmcp-polyfill/-/webmcp-polyfill-5.1.0.tgz",
+      "integrity": "sha512-KL09hniFssPY8HBO3qzurWPqm+1JYRwV3wx6x2XSySgo+6BL1XHGsHGIoAO7U9zzigv7TA5keNBoZ+3P1jq18g==",
+      "license": "MIT",
+      "dependencies": {
+        "@mcp-b/webmcp-types": "5.1.0",
+        "@standard-schema/spec": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@mcp-b/webmcp-types": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/@mcp-b/webmcp-types/-/webmcp-types-5.1.0.tgz",
+      "integrity": "sha512-twOKDUr7al60K890HvRcNvoHSfQ2rnGeKJiQs6eUr+Leg+LQ6K+yz3F4K70jykMK1a09ZIgYb3Oc7mAypuKPig==",
+      "license": "MIT",
+      "dependencies": {
+        "@modelcontextprotocol/server": "2.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@modelcontextprotocol/core": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/core/-/core-2.0.0.tgz",
+      "integrity": "sha512-pJCEwGG7Lfr/+PQp9ZTwKXNeO5wzbfKL7H3MYpCorM4oFBoQrdjnBgEoqG+RjhsvS1FKrDbKux+M1HhlnGWqcA==",
+      "license": "MIT",
+      "dependencies": {
+        "zod": "^4.2.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
+    "node_modules/@modelcontextprotocol/server": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/server/-/server-2.0.0.tgz",
+      "integrity": "sha512-YhHWdHfpFMQfd0prsEnxKeS3Qz3ytIGmsS0sth4KDjnacIT7hxk6hXHkJ9KysxlkvTM+WZAtQbbcUhdoP4Hvtw==",
+      "license": "MIT",
+      "dependencies": {
+        "@modelcontextprotocol/core": "2.0.0",
+        "zod": "^4.2.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
     "node_modules/@napi-rs/wasm-runtime": {
       "version": "0.2.12",
       "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-0.2.12.tgz",
@@ -1760,6 +1833,18 @@
         "win32"
       ]
     },
+    "node_modules/@stablelib/base64": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@stablelib/base64/-/base64-1.0.1.tgz",
+      "integrity": "sha512-1bnPQqSxSuc3Ii6MhBysoWCg58j97aUjuCSZrGSmDxNqtytIi0k8utUenAwTZN4V5mXXYGsVUI9zeBqy+jBOSQ==",
+      "license": "MIT"
+    },
+    "node_modules/@standard-schema/spec": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
+      "integrity": "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w==",
+      "license": "MIT"
+    },
     "node_modules/@stylistic/eslint-plugin": {
       "version": "5.6.1",
       "dev": true,
@@ -3858,6 +3943,12 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/fast-sha256": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/fast-sha256/-/fast-sha256-1.3.0.tgz",
+      "integrity": "sha512-n11RGP/lrWEFI/bWdygLxhI+pVeo1ZYIVwvvPkW7azl/rOy+F3HYRZ2K5zeE9mmkhQppyv9sQFx0JM9UabnpPQ==",
+      "license": "Unlicense"
+    },
     "node_modules/fdir": {
       "version": "6.5.0",
       "license": "MIT",
@@ -4733,6 +4824,19 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/json-schema-to-ts": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/json-schema-to-ts/-/json-schema-to-ts-3.1.1.tgz",
+      "integrity": "sha512-+DWg8jCJG2TEnpy7kOm/7/AxaYoaRbjVB4LFZLySZlWn8exGs3A4OLJR966cVvU26N7X9TWxl+Jsw7dzAqKT6g==",
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.18.3",
+        "ts-algebra": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
     "node_modules/json-schema-traverse": {
       "version": "0.4.1",
       "dev": true,
@@ -6227,6 +6331,16 @@
       "version": "0.0.2",
       "license": "MIT"
     },
+    "node_modules/standardwebhooks": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/standardwebhooks/-/standardwebhooks-1.1.1.tgz",
+      "integrity": "sha512-bCbX9ZEyFkWPsRz7Bl3NuQUJohmwGSev/yhr7vhaGPlc4AfIrspIRa6cPTBuI1ItmrTDJ4d/S2hCsfe4+vQGnQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@stablelib/base64": "^1.0.0",
+        "fast-sha256": "^1.3.0"
+      }
+    },
     "node_modules/std-env": {
       "version": "3.9.0",
       "license": "MIT"
@@ -6477,6 +6591,12 @@
         "node": ">=14.0.0"
       }
     },
+    "node_modules/ts-algebra": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ts-algebra/-/ts-algebra-2.0.0.tgz",
+      "integrity": "sha512-FPAhNPFMrkwz76P7cdjdmiShwMynZYN6SgOujD1urY4oNm80Ou9oMdmbR45LotcKOXoy7wSmHkRFE6Mxbrhefw==",
+      "license": "MIT"
+    },
     "node_modules/ts-api-utils": {
       "version": "2.1.0",
       "dev": true,
diff --git a/package.json b/package.json
index e10df94..5095d3b 100644
--- a/package.json
+++ b/package.json
@@ -10,11 +10,13 @@
     "lint": "eslint src"
   },
   "dependencies": {
+    "@anthropic-ai/sdk": "^0.125.0",
     "@mantine/carousel": "8.3.14",
     "@mantine/code-highlight": "8.3.14",
     "@mantine/core": "8.3.14",
     "@mantine/hooks": "8.3.14",
     "@mantine/spotlight": "8.3.14",
+    "@mcp-b/webmcp-polyfill": "^5.1.0",
     "@tabler/icons-react": "^3.41.1",
     "@tanstack/react-query": "^5.85.9",
     "embla-carousel-react": "^8.6.0",
diff --git a/src/App.tsx b/src/App.tsx
index e833f58..da19e3f 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -14,6 +14,11 @@ import { SeedOptionsProvider } from "./modules/state/optionsProvider.tsx";
 import { DownloadSeedResultProvider } from "./modules/state/downloadProvider.tsx";
 import { BlueprintThemeProvider, useBlueprintTheme } from "./modules/state/themeProvider.tsx";
 import { JamlSearchProvider } from "./modules/state/jamlSearchContext.tsx";
+import AssistantDrawer from "./components/AssistantDrawer.tsx";
+import { SeedQueueHotkeys } from "./components/SeedQueue.tsx";
+import { startWebMcp } from "./modules/webmcp/register.ts";
+
+startWebMcp();
 
 const queryClient = new QueryClient()
 
@@ -42,6 +47,8 @@ export default function App() {
             <JamlSearchProvider>
                 <ProviderContainer>
                     <Blueprint/>
+                    <AssistantDrawer/>
+                    <SeedQueueHotkeys/>
                 </ProviderContainer>
             </JamlSearchProvider>
         </BlueprintThemeProvider>
diff --git a/src/components/AssistantDrawer.tsx b/src/components/AssistantDrawer.tsx
new file mode 100644
index 0000000..6b327b6
--- /dev/null
+++ b/src/components/AssistantDrawer.tsx
@@ -0,0 +1,371 @@
+import { useEffect, useRef, useState } from "react";
+import Anthropic from "@anthropic-ai/sdk";
+import { betaTool } from "@anthropic-ai/sdk/helpers/beta/json-schema";
+import {
+    ActionIcon,
+    Badge,
+    Button,
+    Code,
+    Drawer,
+    Group,
+    Paper,
+    PasswordInput,
+    ScrollArea,
+    Select,
+    Stack,
+    Text,
+    Textarea,
+    Tooltip,
+} from "@mantine/core";
+import { IconPlayerStop, IconSend, IconSettings, IconTrash } from "@tabler/icons-react";
+import { useCardStore } from "../modules/state/store.ts";
+import { listTools } from "../modules/webmcp/registry.ts";
+import { listMemory } from "../modules/webmcp/memory.ts";
+import { BALATRO_KNOWLEDGE } from "../modules/webmcp/knowledge.ts";
+import type { BlueprintTool } from "../modules/webmcp/registry.ts";
+
+const KEY_STORAGE = "blueprint-anthropic-key";
+const MODEL_STORAGE = "blueprint-assistant-model";
+const HISTORY_STORAGE = "blueprint-assistant-history";
+const MODELS = [
+    { value: "claude-opus-5", label: "Claude Opus 5" },
+    { value: "claude-sonnet-5", label: "Claude Sonnet 5" },
+    { value: "claude-haiku-4-5", label: "Claude Haiku 4.5" },
+];
+const MAX_HISTORY_MESSAGES = 60;
+
+const SYSTEM_PROMPT = `You are the Blueprint assistant, embedded in Blueprint: a Balatro seed analyzer and router that runs in the user's browser.
+You have tools that read and drive the app: analyze seeds, read per-ante shop queues, packs, tags, vouchers and bosses, search a seed for items, navigate the view, mark purchases, load seed lists, and remember notes about the user.
+Use the tools instead of guessing: any question about a specific seed must be answered from get_seed_overview / get_ante_details / find_items. Call get_app_state first when you do not know what is loaded.
+When the user shares what they like (decks, strategies, jokers, seeds they hunt), call remember so future sessions are personalized.
+Answer like a sharp Balatro player talking to another one: concrete antes, shop indices, pack names. Short paragraphs, no filler.`;
+
+interface Turn {
+    role: "user" | "assistant";
+    text: string;
+    tools: Array<{ name: string; ok: boolean }>;
+}
+
+type History = Array<Anthropic.Beta.BetaMessageParam>;
+
+function readStorage(key: string): string {
+    try {
+        return localStorage.getItem(key) ?? "";
+    } catch {
+        return "";
+    }
+}
+
+function writeStorage(key: string, value: string) {
+    try {
+        if (value) localStorage.setItem(key, value);
+        else localStorage.removeItem(key);
+    } catch {
+        return;
+    }
+}
+
+function loadHistory(): History {
+    try {
+        const parsed = JSON.parse(readStorage(HISTORY_STORAGE) || "[]");
+        return Array.isArray(parsed) ? parsed : [];
+    } catch {
+        return [];
+    }
+}
+
+function turnsFromHistory(history: History): Array<Turn> {
+    const turns: Array<Turn> = [];
+    for (const message of history) {
+        if (message.role === "system") continue;
+        if (typeof message.content === "string") {
+            turns.push({ role: message.role, text: message.content, tools: [] });
+            continue;
+        }
+        const text = message.content
+            .filter((block): block is Anthropic.Beta.BetaTextBlockParam => block.type === "text")
+            .map((block) => block.text)
+            .join("");
+        const toolUses = message.content
+            .filter((block): block is Anthropic.Beta.BetaToolUseBlockParam => block.type === "tool_use")
+            .map((block) => ({ name: block.name, ok: true }));
+        if (message.role === "assistant") {
+            const last = turns[turns.length - 1];
+            if (last && last.role === "assistant") {
+                last.text += text;
+                last.tools.push(...toolUses);
+            } else {
+                turns.push({ role: "assistant", text, tools: toolUses });
+            }
+        } else if (text) {
+            turns.push({ role: "user", text, tools: [] });
+        }
+    }
+    return turns;
+}
+
+function runnableTools(tools: Array<BlueprintTool>, onCall: (name: string, ok: boolean) => void) {
+    return tools.map((tool) =>
+        betaTool({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema as Parameters<typeof betaTool>[0]["inputSchema"],
+            run: async (args) => {
+                try {
+                    const result = await tool.execute((args ?? {}) as Record<string, unknown>);
+                    onCall(tool.name, true);
+                    return JSON.stringify(result);
+                } catch (error) {
+                    onCall(tool.name, false);
+                    throw error;
+                }
+            },
+        }),
+    );
+}
+
+function contextBlock(): string {
+    const s = useCardStore.getState();
+    const notes = listMemory();
+    const lines = [
+        `Loaded seed: ${s.engineState.seed || "(none)"} on ${s.engineState.deck}, ${s.engineState.stake}, antes 1-${s.engineState.maxAnte}, view ${s.applicationState.viewMode}.`,
+        `Seed queue: ${s.seedQueue.seeds.length} seeds, position ${s.seedQueue.index + 1}.`,
+    ];
+    if (notes.length > 0) lines.push(`Notes about this user:\n- ${notes.join("\n- ")}`);
+    return lines.join("\n");
+}
+
+export default function AssistantDrawer() {
+    const opened = useCardStore(state => state.applicationState.assistantOpen);
+    const toggleAssistant = useCardStore(state => state.toggleAssistant);
+
+    const [apiKey, setApiKey] = useState(() => readStorage(KEY_STORAGE));
+    const [model, setModel] = useState(() => readStorage(MODEL_STORAGE) || MODELS[0].value);
+    const [showSettings, setShowSettings] = useState(() => !readStorage(KEY_STORAGE));
+    const [history, setHistory] = useState<History>(loadHistory);
+    const [turns, setTurns] = useState<Array<Turn>>(() => turnsFromHistory(loadHistory()));
+    const [draft, setDraft] = useState("");
+    const [busy, setBusy] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+    const abortRef = useRef<AbortController | null>(null);
+    const viewportRef = useRef<HTMLDivElement>(null);
+
+    useEffect(() => {
+        viewportRef.current?.scrollTo({ top: viewportRef.current.scrollHeight });
+    }, [turns]);
+
+    const persist = (next: History) => {
+        const trimmed = next.length > MAX_HISTORY_MESSAGES ? next.slice(next.length - MAX_HISTORY_MESSAGES) : next;
+        setHistory(trimmed);
+        writeStorage(HISTORY_STORAGE, JSON.stringify(trimmed));
+    };
+
+    const clear = () => {
+        persist([]);
+        setTurns([]);
+        setError(null);
+    };
+
+    const stop = () => abortRef.current?.abort();
+
+    const send = async () => {
+        const text = draft.trim();
+        if (!text || busy) return;
+        if (!apiKey) {
+            setShowSettings(true);
+            setError("Add your Anthropic API key first.");
+            return;
+        }
+        setDraft("");
+        setError(null);
+        setBusy(true);
+        const userMessage: Anthropic.Beta.BetaMessageParam = { role: "user", content: text };
+        const startingHistory: History = [...history, userMessage];
+        setTurns((prev) => [...prev, { role: "user", text, tools: [] }, { role: "assistant", text: "", tools: [] }]);
+
+        const patchAssistant = (patch: (turn: Turn) => Turn) =>
+            setTurns((prev) => {
+                const next = [...prev];
+                const last = next[next.length - 1];
+                if (last?.role === "assistant") next[next.length - 1] = patch(last);
+                return next;
+            });
+
+        const dropEmptyAssistant = () =>
+            setTurns((prev) => {
+                const last = prev[prev.length - 1];
+                return last?.role === "assistant" && !last.text && last.tools.length === 0 ? prev.slice(0, -1) : prev;
+            });
+
+        const controller = new AbortController();
+        abortRef.current = controller;
+        const client = new Anthropic({ apiKey, dangerouslyAllowBrowser: true });
+        const runner = client.beta.messages.toolRunner(
+            {
+                model,
+                max_tokens: 16000,
+                stream: true,
+                max_iterations: 16,
+                betas: ["server-side-fallback-2026-07-01"],
+                fallbacks: "default",
+                output_config: { effort: "medium" },
+                system: [
+                    { type: "text", text: `${SYSTEM_PROMPT}\n\n${BALATRO_KNOWLEDGE}`, cache_control: { type: "ephemeral" } },
+                    { type: "text", text: contextBlock() },
+                ],
+                tools: runnableTools(listTools(), (name, ok) =>
+                    patchAssistant((turn) => ({ ...turn, tools: [...turn.tools, { name, ok }] })),
+                ),
+                messages: startingHistory,
+            },
+            { signal: controller.signal },
+        );
+
+        try {
+            for await (const stream of runner) {
+                stream.on("text", (delta) => patchAssistant((turn) => ({ ...turn, text: turn.text + delta })));
+                const message = await stream.finalMessage();
+                if (message.stop_reason === "pause_turn") {
+                    runner.pushMessages({ role: "assistant", content: message.content });
+                }
+                if (message.stop_reason === "refusal") {
+                    setError(message.stop_details?.explanation ?? "The model declined this request.");
+                }
+            }
+            persist(runner.params.messages as History);
+        } catch (err) {
+            if (controller.signal.aborted) {
+                persist(runner.params.messages as History);
+            } else if (err instanceof Anthropic.AuthenticationError) {
+                setError("Anthropic rejected the API key.");
+                setShowSettings(true);
+            } else if (err instanceof Anthropic.RateLimitError) {
+                setError("Rate limited by Anthropic. Try again in a moment.");
+            } else if (err instanceof Anthropic.APIError) {
+                setError(`Anthropic API error ${err.status}: ${err.message}`);
+            } else {
+                setError(err instanceof Error ? err.message : String(err));
+            }
+        } finally {
+            dropEmptyAssistant();
+            abortRef.current = null;
+            setBusy(false);
+        }
+    };
+
+    return (
+        <Drawer
+            opened={opened}
+            onClose={toggleAssistant}
+            position="right"
+            size="md"
+            title={
+                <Group gap="xs">
+                    <Text fw={700}>Blueprint assistant</Text>
+                    <Badge variant="light" size="sm">{listTools().length} tools</Badge>
+                </Group>
+            }
+            styles={{ body: { display: "flex", flexDirection: "column", height: "calc(100% - 60px)", gap: 8 } }}
+        >
+            <Group gap="xs" justify="space-between">
+                <Group gap="xs">
+                    <Tooltip label="Settings">
+                        <ActionIcon variant={showSettings ? "filled" : "default"} onClick={() => setShowSettings((v) => !v)} aria-label="Assistant settings">
+                            <IconSettings size={16} />
+                        </ActionIcon>
+                    </Tooltip>
+                    <Tooltip label="Clear conversation">
+                        <ActionIcon variant="default" onClick={clear} disabled={busy || turns.length === 0} aria-label="Clear conversation">
+                            <IconTrash size={16} />
+                        </ActionIcon>
+                    </Tooltip>
+                </Group>
+                <Text size="xs" c="dimmed">Tools also exposed via WebMCP (document.modelContext)</Text>
+            </Group>
+
+            {showSettings && (
+                <Paper withBorder p="sm">
+                    <Stack gap="xs">
+                        <PasswordInput
+                            id="assistant-api-key"
+                            label="Anthropic API key"
+                            description="Stored only in this browser (localStorage) and sent straight to api.anthropic.com."
+                            placeholder="sk-ant-..."
+                            value={apiKey}
+                            onChange={(e) => {
+                                setApiKey(e.currentTarget.value);
+                                writeStorage(KEY_STORAGE, e.currentTarget.value.trim());
+                            }}
+                        />
+                        <Select
+                            label="Model"
+                            data={MODELS}
+                            value={model}
+                            allowDeselect={false}
+                            onChange={(value) => {
+                                if (!value) return;
+                                setModel(value);
+                                writeStorage(MODEL_STORAGE, value);
+                            }}
+                        />
+                    </Stack>
+                </Paper>
+            )}
+
+            <ScrollArea style={{ flex: 1 }} viewportRef={viewportRef} type="auto">
+                <Stack gap="sm" p="xs">
+                    {turns.length === 0 && (
+                        <Text size="sm" c="dimmed">
+                            Ask about the loaded seed, hunt items across antes, mark purchases, or paste a seed list. The assistant drives the app through the same tools browser agents get via WebMCP.
+                        </Text>
+                    )}
+                    {turns.map((turn, i) => (
+                        <Paper
+                            key={i}
+                            p="sm"
+                            radius="md"
+                            withBorder
+                            style={{ alignSelf: turn.role === "user" ? "flex-end" : "flex-start", maxWidth: "92%" }}
+                        >
+                            {turn.tools.length > 0 && (
+                                <Group gap={4} mb={6}>
+                                    {turn.tools.map((call, j) => (
+                                        <Badge key={j} size="xs" variant="dot" color={call.ok ? "teal" : "red"}>{call.name}</Badge>
+                                    ))}
+                                </Group>
+                            )}
+                            <Text size="sm" style={{ whiteSpace: "pre-wrap" }}>
+                                {turn.text || (busy && i === turns.length - 1 ? "…" : "")}
+                            </Text>
+                        </Paper>
+                    ))}
+                    {error && <Code block color="red">{error}</Code>}
+                </Stack>
+            </ScrollArea>
+
+            <Group gap="xs" align="flex-end" wrap="nowrap">
+                <Textarea
+                    id="assistant-input"
+                    placeholder="Where is Perkeo in this seed? Load these seeds… Buy the Blueprint in ante 2…"
+                    autosize
+                    minRows={1}
+                    maxRows={5}
+                    style={{ flex: 1 }}
+                    value={draft}
+                    onChange={(e) => setDraft(e.currentTarget.value)}
+                    onKeyDown={(e) => {
+                        if (e.key === "Enter" && !e.shiftKey) {
+                            e.preventDefault();
+                            void send();
+                        }
+                    }}
+                />
+                {busy ? (
+                    <Button color="red" onClick={stop} leftSection={<IconPlayerStop size={16} />}>Stop</Button>
+                ) : (
+                    <Button id="assistant-send" onClick={() => void send()} disabled={!draft.trim()} leftSection={<IconSend size={16} />}>Send</Button>
+                )}
+            </Group>
+        </Drawer>
+    );
+}
diff --git a/src/components/SeedQueue.tsx b/src/components/SeedQueue.tsx
new file mode 100644
index 0000000..1536000
--- /dev/null
+++ b/src/components/SeedQueue.tsx
@@ -0,0 +1,127 @@
+import { useEffect, useState } from "react";
+import { ActionIcon, Badge, Button, Group, Stack, Text, Textarea, Tooltip } from "@mantine/core";
+import { useHotkeys } from "@mantine/hooks";
+import { IconChevronLeft, IconChevronRight, IconPlayerSkipBack, IconPlayerSkipForward, IconTrash } from "@tabler/icons-react";
+import { parseSeedList, useCardStore } from "../modules/state/store.ts";
+import { prefetchSeedAnalysis } from "../modules/state/analysisResultProvider.tsx";
+
+const PREFETCH_RADIUS = 2;
+
+export function SeedQueueHotkeys() {
+    const seeds = useCardStore(state => state.seedQueue.seeds);
+    const index = useCardStore(state => state.seedQueue.index);
+    const engineState = useCardStore(state => state.engineState);
+    const stepSeedQueue = useCardStore(state => state.stepSeedQueue);
+    const jumpSeedQueue = useCardStore(state => state.jumpSeedQueue);
+
+    useHotkeys([
+        ["ArrowRight", () => stepSeedQueue(1)],
+        ["ArrowLeft", () => stepSeedQueue(-1)],
+        ["Home", () => jumpSeedQueue(0)],
+        ["End", () => jumpSeedQueue(seeds.length - 1)],
+    ]);
+
+    useEffect(() => {
+        if (seeds.length === 0) return;
+        const targets: Array<string> = [];
+        for (let offset = 1; offset <= PREFETCH_RADIUS; offset++) {
+            if (seeds[index + offset]) targets.push(seeds[index + offset]);
+            if (seeds[index - offset]) targets.push(seeds[index - offset]);
+        }
+        let cancelled = false;
+        const run = () => {
+            if (cancelled) return;
+            const next = targets.shift();
+            if (!next) return;
+            prefetchSeedAnalysis(next);
+            setTimeout(run, 0);
+        };
+        const timer = setTimeout(run, 150);
+        return () => {
+            cancelled = true;
+            clearTimeout(timer);
+        };
+    }, [seeds, index, engineState]);
+
+    return null;
+}
+
+export function SeedQueueControls() {
+    const seeds = useCardStore(state => state.seedQueue.seeds);
+    const index = useCardStore(state => state.seedQueue.index);
+    const stepSeedQueue = useCardStore(state => state.stepSeedQueue);
+    const jumpSeedQueue = useCardStore(state => state.jumpSeedQueue);
+    if (seeds.length === 0) return null;
+    return (
+        <Group gap={4} wrap="nowrap">
+            <ActionIcon variant="default" size="sm" onClick={() => jumpSeedQueue(0)} disabled={index === 0} aria-label="First seed">
+                <IconPlayerSkipBack size={14} />
+            </ActionIcon>
+            <ActionIcon variant="default" size="sm" onClick={() => stepSeedQueue(-1)} disabled={index === 0} aria-label="Previous seed">
+                <IconChevronLeft size={14} />
+            </ActionIcon>
+            <Tooltip label="ArrowLeft / ArrowRight step, Home / End jump">
+                <Badge variant="light" size="lg" style={{ fontVariantNumeric: "tabular-nums" }}>
+                    {index + 1} / {seeds.length}
+                </Badge>
+            </Tooltip>
+            <ActionIcon variant="default" size="sm" onClick={() => stepSeedQueue(1)} disabled={index >= seeds.length - 1} aria-label="Next seed">
+                <IconChevronRight size={14} />
+            </ActionIcon>
+            <ActionIcon variant="default" size="sm" onClick={() => jumpSeedQueue(seeds.length - 1)} disabled={index >= seeds.length - 1} aria-label="Last seed">
+                <IconPlayerSkipForward size={14} />
+            </ActionIcon>
+        </Group>
+    );
+}
+
+export function SeedQueuePanel() {
+    const seeds = useCardStore(state => state.seedQueue.seeds);
+    const setSeedQueue = useCardStore(state => state.setSeedQueue);
+    const clearSeedQueue = useCardStore(state => state.clearSeedQueue);
+    const [text, setText] = useState("");
+    const parsed = parseSeedList(text);
+
+    const load = () => {
+        if (parsed.length === 0) return;
+        setSeedQueue(parsed);
+        setText("");
+    };
+
+    return (
+        <Stack gap="xs" mb="xs">
+            <Textarea
+                id="seed-queue-input"
+                label="Seed list"
+                description="Paste seeds (one per line, comma or space separated, or a CSV with seeds in the first column). Arrow keys step through them."
+                placeholder={"ALEEB\nPIROCKS\nWEEJOKER"}
+                autosize
+                minRows={2}
+                maxRows={6}
+                value={text}
+                onChange={(e) => setText(e.currentTarget.value)}
+                onKeyDown={(e) => {
+                    if (e.key === "Enter" && (e.ctrlKey || e.metaKey)) load();
+                }}
+            />
+            <Group gap="xs" wrap="nowrap">
+                <Button id="seed-queue-load" size="xs" onClick={load} disabled={parsed.length === 0} style={{ flex: 1 }}>
+                    Load {parsed.length > 0 ? parsed.length : ""} seeds
+                </Button>
+                {seeds.length > 0 && (
+                    <Tooltip label="Clear seed list">
+                        <ActionIcon variant="default" size="lg" onClick={clearSeedQueue} aria-label="Clear seed list">
+                            <IconTrash size={16} />
+                        </ActionIcon>
+                    </Tooltip>
+                )}
+            </Group>
+            {seeds.length > 0 && (
+                <Group justify="space-between">
+                    <Text size="xs" c="dimmed">{seeds.length} queued</Text>
+                    <SeedQueueControls />
+                </Group>
+            )}
+        </Stack>
+    );
+}
diff --git a/src/components/blueprint/jamlView/JamlView.tsx b/src/components/blueprint/jamlView/JamlView.tsx
index 8a54bad..c2d8989 100644
--- a/src/components/blueprint/jamlView/JamlView.tsx
+++ b/src/components/blueprint/jamlView/JamlView.tsx
@@ -9,6 +9,10 @@ import {
     JimboStatusPill,
     JimboText,
     JimboTextInput,
+    estimateEtaSeconds,
+    estimateJamlRarity,
+    formatEta,
+    formatOneIn,
     parseJaml,
 } from "jaml-ui";
 import { JamlAesthetic, MotelyDeck, MotelyStake } from "motely-wasm";
@@ -71,6 +75,7 @@ export default function JamlView() {
     const [error, setError] = useState<string | null>(null);
     const [results, setResults] = useState<Array<MotelySeedScore>>([]);
     const [stats, setStats] = useState<SearchStats>(EMPTY_STATS);
+    const [searchedJaml, setSearchedJaml] = useState<string | null>(null);
 
     // Search source (mutually exclusive engine modes).
     const [scopeMode, setScopeMode] = useState<ScopeMode>("random");
@@ -161,6 +166,32 @@ export default function JamlView() {
 
     const isSearching = status === "running" || status === "booting";
 
+    const estimate = useMemo(() => {
+        try {
+            return estimateJamlRarity(jamlText);
+        } catch {
+            return null;
+        }
+    }, [jamlText]);
+    const hits = stats.matchingSeeds || results.length;
+    const measured = hits > 0 && stats.seedsSearched > 0 && searchedJaml === jamlText;
+    const estimatedP = estimate?.combined.oneIn ? estimate.combined.pPerSeed : 0;
+    const pPerSeed = measured ? hits / stats.seedsSearched : estimatedP;
+    const calculus = pPerSeed > 0
+        ? {
+            source: measured
+                ? `measured: ${formatNumber(hits)} ÷ ${formatNumber(stats.seedsSearched)}`
+                : searchedJaml !== null && searchedJaml !== jamlText
+                    ? "estimated from the edited filter, ±10x (search stats belong to the previous filter)"
+                    : "estimated from the filter, ±10x",
+            oneIn: formatOneIn(1 / pPerSeed),
+            expected: 1 / pPerSeed,
+            coinFlip: Math.LN2 / pPerSeed,
+            almostCertain: Math.log(20) / pPerSeed,
+            eta: (seeds: number) => stats.seedsPerSecond > 0 ? formatEta(estimateEtaSeconds(1 / seeds, stats.seedsPerSecond)) : "—",
+        }
+        : null;
+
     const buildScope = useCallback((): SearchScope => {
         switch (scopeMode) {
             case "random":
@@ -187,6 +218,7 @@ export default function JamlView() {
         setError(null);
         setResults([]);
         setStats(EMPTY_STATS);
+        setSearchedJaml(jamlText);
         collectedRef.current = [];
 
         const config: SearchConfig = {
@@ -298,6 +330,35 @@ export default function JamlView() {
                 </JimboStack>
             </JimboPanel>
 
+            <JimboPanel title="Calculus" tone="grey">
+                {calculus ? (
+                    <JimboStack gap="xs">
+                        <JimboRow justify="between">
+                            <JimboText size="xs" tone="grey">Rarity</JimboText>
+                            <JimboText size="sm">{calculus.oneIn}</JimboText>
+                        </JimboRow>
+                        <JimboText size="xs" tone="grey">{calculus.source}</JimboText>
+                        <JimboRow justify="between">
+                            <JimboText size="xs" tone="grey">Expected wait (1/p)</JimboText>
+                            <JimboText size="sm">{formatNumber(Math.round(calculus.expected))} · {calculus.eta(calculus.expected)}</JimboText>
+                        </JimboRow>
+                        <JimboRow justify="between">
+                            <JimboText size="xs" tone="grey">Coin flip (ln 2/p)</JimboText>
+                            <JimboText size="sm">{formatNumber(Math.round(calculus.coinFlip))} · {calculus.eta(calculus.coinFlip)}</JimboText>
+                        </JimboRow>
+                        <JimboRow justify="between">
+                            <JimboText size="xs" tone="grey">95% (ln 20/p)</JimboText>
+                            <JimboText size="sm">{formatNumber(Math.round(calculus.almostCertain))} · {calculus.eta(calculus.almostCertain)}</JimboText>
+                        </JimboRow>
+                        {stats.seedsPerSecond === 0 && (
+                            <JimboText size="xs" tone="grey">Times appear once the rig speed is measured.</JimboText>
+                        )}
+                    </JimboStack>
+                ) : (
+                    <JimboText size="xs" tone="grey">No estimate for this filter yet; rarity is measured once the search has hits.</JimboText>
+                )}
+            </JimboPanel>
+
             <JimboPanel title="Source" tone="gold">
                 <JimboStack gap="sm">
                     <div style={{ display: "grid", gridTemplateColumns: "1fr 1fr", gap: 6 }}>
diff --git a/src/components/blueprint/layout/header.tsx b/src/components/blueprint/layout/header.tsx
index 6cd0156..dd268d7 100644
--- a/src/components/blueprint/layout/header.tsx
+++ b/src/components/blueprint/layout/header.tsx
@@ -1,6 +1,8 @@
 import React from "react";
 import {useViewportSize} from "@mantine/hooks";
-import {AppShell, Box, Burger, Button, Center, Container, CopyButton, Group, Title} from "@mantine/core";
+import {ActionIcon, AppShell, Box, Burger, Button, Center, Container, CopyButton, Group, Title, Tooltip} from "@mantine/core";
+import {IconMessageChatbot} from "@tabler/icons-react";
+import {SeedQueueControls} from "../../SeedQueue.tsx";
 import {useCardStore} from "../../../modules/state/store.ts";
 import SearchSeedInput from "../../searchInput.tsx";
 import {GaEvent} from "../../../modules/useGA.ts";
@@ -13,6 +15,8 @@ export default function Header() {
 
     const outputOpened = useCardStore(state => state.applicationState.asideOpen);
     const toggleOutput = useCardStore(state => state.toggleOutput);
+    const assistantOpened = useCardStore(state => state.applicationState.assistantOpen);
+    const toggleAssistant = useCardStore(state => state.toggleAssistant);
 
     return (
         <AppShell.Header>
@@ -30,7 +34,8 @@ export default function Header() {
                     </Group>
 
                     <Group align={'center'}>
-{width > 600 && start && <Box id="search-input-header"><SearchSeedInput /></Box>}
+                        {width > 900 && <SeedQueueControls />}
+                        {width > 600 && start && <Box id="search-input-header"><SearchSeedInput /></Box>}
                         {width > 700 && start && (
                             <CopyButton value={new URL(window.location.href).toString()}>
                                 {({ copied, copy }) => (
@@ -40,6 +45,17 @@ export default function Header() {
                                 )}
                             </CopyButton>
                         )}
+                        <Tooltip label="Chat with the Blueprint assistant">
+                            <ActionIcon
+                                id="assistant-toggle"
+                                variant={assistantOpened ? 'filled' : 'default'}
+                                size="lg"
+                                aria-label="Open assistant"
+                                onClick={toggleAssistant}
+                            >
+                                <IconMessageChatbot size={20} />
+                            </ActionIcon>
+                        </Tooltip>
                         <Burger id="side-panel-toggle" opened={outputOpened} onClick={() => {
                             GaEvent('side_panel_toggled')
                             toggleOutput()
diff --git a/src/components/blueprint/layout/navbar.tsx b/src/components/blueprint/layout/navbar.tsx
index 876b419..d0c334b 100644
--- a/src/components/blueprint/layout/navbar.tsx
+++ b/src/components/blueprint/layout/navbar.tsx
@@ -27,6 +27,7 @@ import { GaEvent } from "../../../modules/useGA.ts";
 import SeedInputAutoComplete from "../../SeedInputAutoComplete.tsx";
 import UnlocksModal from "../../unlocksModal.tsx";
 import FeaturesModal from "../../FeaturesModal.tsx";
+import { SeedQueuePanel } from "../../SeedQueue.tsx";
 import { DrawSimulatorModal } from "../../DrawSimulatorModal.tsx";
 import { RerollCalculatorModal } from "../../RerollCalculatorModal.tsx";
 
@@ -43,7 +44,8 @@ export default function Navbar() {
     const setUseCardPeek = useCardStore(state => state.setUseCardPeek);
     const maxMiscCardSource = useCardStore(state => state.applicationState.maxMiscCardSource);
     const setMiscMaxSource = useCardStore(state => state.setMiscMaxSource);
-    const maxAnte = useCardStore(state => state.applicationState.selectedAnte ?? 8);
+    const maxAnte = useCardStore(state => state.engineState.maxAnte);
+    const setMaxAnte = useCardStore(state => state.setMaxAnte);
 
     const setSeed = useCardStore(state => state.setSeed);
     const setDeck = useCardStore(state => state.setDeck);
@@ -59,7 +61,6 @@ export default function Navbar() {
     const rerollCalculatorMetadata = useCardStore(state => state.applicationState.rerollCalculatorMetadata);
     const closeRerollCalculatorModal = useCardStore(state => state.closeRerollCalculatorModal);
     const reset = useCardStore(state => state.reset);
-    const setSelectedAnte = useCardStore(state => state.setSelectedAnte);
 
     const handleAnalyzeClick = () => {
         setStart(true);
@@ -135,7 +136,7 @@ export default function Navbar() {
                                     value={maxAnte}
                                     onChange={(val) => {
                                         const n = Number(val) || 8;
-                                        setSelectedAnte(Math.max(1, Math.min(n, 39)));
+                                        setMaxAnte(Math.max(1, Math.min(n, 39)));
                                     }}
                                     min={1}
                                     max={39}
@@ -187,6 +188,7 @@ export default function Navbar() {
                                 ]}
                             />
                         </Group>
+                        <SeedQueuePanel />
                         <InputLabel>Cards per Ante</InputLabel>
                         <Button.Group w={'100%'} mb="xs">
                             <Button variant="default" size="sm" onClick={() => setCardsPerAnte(50)}>50</Button>
diff --git a/src/components/blueprint/standardView/index.tsx b/src/components/blueprint/standardView/index.tsx
index 758e5f3..ccd8ae6 100644
--- a/src/components/blueprint/standardView/index.tsx
+++ b/src/components/blueprint/standardView/index.tsx
@@ -543,7 +543,6 @@ function Main() {
             {SeedResults && viewMode === 'text' && <Index />}
             {SeedResults && viewMode === 'simple' && <Simple />}
             {viewMode === 'jaml' && <JamlView />}
-            {SeedResults && viewMode === 'blueprint' && <SeedExplorer />}
             {SeedResults && <SnapshotModal />}
         </AppShell.Main>
     )
diff --git a/src/modules/state/analysisResultProvider.tsx b/src/modules/state/analysisResultProvider.tsx
index a88fda6..ed77993 100644
--- a/src/modules/state/analysisResultProvider.tsx
+++ b/src/modules/state/analysisResultProvider.tsx
@@ -2,8 +2,12 @@ import React, { createContext, useContext, useMemo } from "react";
 
 
 import { analyzeSeed } from "../GameEngine/index.ts";
-import { useCardStore } from "./store.ts";
+import { startingDeckCards, useCardStore } from "./store.ts";
 import { useSeedOptionsContainer } from "./optionsProvider.tsx";
+import type { AnalyzeOptions } from "../GameEngine/index.ts";
+import type { InitialState } from "./store.ts";
+import type { OptionsProviderProps } from "./optionsProvider.tsx";
+import type { DeckCard } from "../deckUtils.ts";
 import type { SeedResultsContainer } from "../GameEngine/CardEngines/Cards.ts";
 
 export const SeedResultContext = createContext<SeedResultsContainer | null | undefined>(null);
@@ -16,17 +20,57 @@ export function useSeedResultsContainer() {
     return context;
 }
 
-
-// Simple in-memory cache
 const resultCache = new Map<string, SeedResultsContainer>();
 
-// Helper to generate a cache key from all influential state
-function getCacheKey(state: any, options: any, seed: string) {
-    // We exclude seed from the base state object and append it explicitly
+type EngineState = InitialState['engineState'];
+
+function getCacheKey(state: EngineState, options: AnalyzeOptions, seed: string) {
     const { seed: _seed, ...restState } = state;
     return JSON.stringify({ ...restState, options, seed });
 }
 
+function runAnalysis(state: EngineState, options: AnalyzeOptions, seed: string) {
+    const cacheKey = getCacheKey(state, options, seed);
+    const cached = resultCache.get(cacheKey);
+    if (cached) return cached;
+    const result = analyzeSeed({ ...state, seed, antes: state.maxAnte }, options);
+    if (result) resultCache.set(cacheKey, result);
+    return result;
+}
+
+function optionsFromStore(): AnalyzeOptions {
+    const s = useCardStore.getState();
+    return {
+        maxMiscCardSource: s.applicationState.maxMiscCardSource,
+        showCardSpoilers: s.applicationState.showCardSpoilers,
+        unlocks: s.engineState.selectedOptions,
+        events: s.eventState.events,
+        updates: [],
+        buys: s.shoppingState.buys,
+        sells: s.shoppingState.sells,
+        lockedCards: s.lockState.lockedCards,
+        customDeck: s.deckState.cards,
+    };
+}
+
+function optionsForSeed(seed: string, state: EngineState): AnalyzeOptions {
+    const options = optionsFromStore();
+    if (seed === state.seed) return options;
+    return { ...options, buys: {}, sells: {}, customDeck: startingDeckCards(seed, state) };
+}
+
+export function analyzeSeedFromStore(seed?: string, overrides?: Partial<EngineState>) {
+    const state = { ...useCardStore.getState().engineState, ...overrides };
+    const target = seed ?? state.seed;
+    if (!target) return undefined;
+    return runAnalysis(state, optionsForSeed(target, state), target);
+}
+
+export function prefetchSeedAnalysis(seed: string) {
+    const state = useCardStore.getState().engineState;
+    runAnalysis(state, optionsForSeed(seed, state), seed);
+}
+
 export function SeedResultProvider({ children }: { children: React.ReactNode }) {
     const start = useCardStore(state => state.applicationState.start);
     const analyzeState = useCardStore(state => state.engineState);
@@ -37,29 +81,9 @@ export function SeedResultProvider({ children }: { children: React.ReactNode })
         if (!start) {
             return undefined;
         }
-
-        const cacheKey = getCacheKey(analyzeState, options, analyzeState.seed);
-
-        if (resultCache.has(cacheKey)) {
-            return resultCache.get(cacheKey);
-        }
-
-        // Analyze and cache
-        const result = analyzeSeed(analyzeState, {
-            ...options,
-            customDeck: deckCards
-        });
-        if (result) {
-            resultCache.set(cacheKey, result);
-        }
-        return result;
+        return runAnalysis(analyzeState, toAnalyzeOptions(options, deckCards), analyzeState.seed);
     }, [analyzeState, deckCards, options, start]);
 
-    // Expose a way to pre-warm the cache from other components
-    // We attach this to the window or export a hook, but for now, 
-    // passing it via context or just exporting a function that reads the store might be cleaner.
-    // For simplicity in this specialized app, we'll keep the cache global.
-
     return (
         <SeedResultContext.Provider value={seedResult}>
                 {children}
@@ -67,14 +91,6 @@ export function SeedResultProvider({ children }: { children: React.ReactNode })
     )
 }
 
-export function prefetchSeedAnalysis(seed: string, state: any, options: any) {
-    const cacheKey = getCacheKey(state, options, seed);
-    if (resultCache.has(cacheKey)) return; // Already cached
-
-    // Create a version of state with the new seed
-    const newState = { ...state, seed };
-    const result = analyzeSeed(newState, options);
-    if (result) {
-        resultCache.set(cacheKey, result);
-    }
+function toAnalyzeOptions(options: OptionsProviderProps, customDeck: Array<DeckCard>): AnalyzeOptions {
+    return { ...options, customDeck };
 }
diff --git a/src/modules/state/jamlSearchContext.tsx b/src/modules/state/jamlSearchContext.tsx
index 4f20a17..24a519a 100644
--- a/src/modules/state/jamlSearchContext.tsx
+++ b/src/modules/state/jamlSearchContext.tsx
@@ -1,4 +1,6 @@
-import { createContext, useContext, useState } from 'react';
+import { createContext, useContext, useEffect, useRef, useState } from 'react';
+import { registerTools } from '../webmcp/registry.ts';
+import { useCardStore } from './store.ts';
 import type { ReactNode } from 'react';
 
 interface JamlSearchState {
@@ -59,6 +61,36 @@ export function JamlSearchProvider({ children }: { children: ReactNode }) {
     const [selectedFilterKey, setSelectedFilterKey] = useState<string>('default');
     const [customJamlText, setCustomJamlText] = useState<string>('');
 
+    const jamlRef = useRef(jamlText);
+    useEffect(() => {
+        jamlRef.current = jamlText;
+    }, [jamlText]);
+
+    useEffect(() => registerTools([
+        {
+            name: 'get_jaml_filter',
+            description: 'Read the JAML filter currently in the JAML search editor.',
+            inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+            execute: () => ({ jaml: jamlRef.current }),
+        },
+        {
+            name: 'set_jaml_filter',
+            description: 'Replace the JAML filter in the JAML search editor and switch to the JAML view. JAML is Jimbo\'s Ante Markup Language: name/deck/stake plus must/should/mustNot clause lists.',
+            inputSchema: {
+                type: 'object',
+                properties: { jaml: { type: 'string', minLength: 1 } },
+                required: ['jaml'],
+                additionalProperties: false,
+            },
+            execute: (input) => {
+                const jaml = String(input.jaml ?? '');
+                setJamlText(jaml);
+                useCardStore.getState().setViewMode('jaml');
+                return { lines: jaml.split('\n').length };
+            },
+        },
+    ]), []);
+
     return (
         <JamlSearchContext.Provider value={{
             searchMode, funnyMode, funnyKeywords, jamlText, selectedFilterKey, customJamlText,
diff --git a/src/modules/state/store.ts b/src/modules/state/store.ts
index 31a3ebe..9a3928d 100644
--- a/src/modules/state/store.ts
+++ b/src/modules/state/store.ts
@@ -51,6 +51,11 @@ export interface InitialState {
         rerollStartIndex: number;
         conversionSourceId: string | null;
         apiEndpoint: string;
+        assistantOpen: boolean;
+    };
+    seedQueue: {
+        seeds: Array<string>;
+        index: number;
     };
     searchState: {
         searchTerm: string;
@@ -105,6 +110,11 @@ interface StoreActions {
     setSelectedBlind: (selectedBlind: Blinds) => void;
     toggleSettings: () => void;
     toggleOutput: () => void;
+    toggleAssistant: () => void;
+    setSeedQueue: (seeds: Array<string>) => void;
+    jumpSeedQueue: (index: number) => void;
+    stepSeedQueue: (delta: number) => void;
+    clearSeedQueue: () => void;
     setApiEndpoint: (apiEndpoint: string) => void;
     setMiscSource: (source: string) => void;
     setAsideTab: (tab: string) => void;
@@ -139,6 +149,68 @@ interface StoreActions {
     reset: () => void;
 }
 export interface CardStore extends InitialState, StoreActions { }
+
+const SEED_QUEUE_KEY = 'blueprint-seed-queue';
+
+function loadSeedQueue(): InitialState['seedQueue'] {
+    try {
+        const raw = localStorage.getItem(SEED_QUEUE_KEY);
+        if (raw) {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed.seeds)) {
+                const index = Math.min(Math.max(0, Number(parsed.index) || 0), Math.max(0, parsed.seeds.length - 1));
+                return { seeds: parsed.seeds.filter((s: unknown) => typeof s === 'string'), index };
+            }
+        }
+    } catch {
+        return { seeds: [], index: 0 };
+    }
+    return { seeds: [], index: 0 };
+}
+
+function saveSeedQueue(queue: InitialState['seedQueue']) {
+    try {
+        localStorage.setItem(SEED_QUEUE_KEY, JSON.stringify(queue));
+    } catch {
+        return;
+    }
+}
+
+export function startingDeckCards(seed: string, engine: Pick<InitialState['engineState'], 'deck' | 'stake' | 'showmanOwned' | 'gameVersion'>): Array<DeckCard> {
+    const params = new InstanceParams(
+        new Deck(deckMap[engine.deck]),
+        new Stake(stakeMap[engine.stake]),
+        engine.showmanOwned,
+        Number(engine.gameVersion)
+    );
+    return new Game(seed, params).initDeck().map((card, i) => convertGameCardToDeckCard(card, i));
+}
+
+export function parseSeedList(text: string): Array<string> {
+    const seen = new Set<string>();
+    const seeds: Array<string> = [];
+    const push = (token: string) => {
+        const seed = sanitizeSeed(token);
+        if (seed && !seen.has(seed)) {
+            seen.add(seed);
+            seeds.push(seed);
+        }
+    };
+    for (const line of text.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) continue;
+        if (/[,;|\t]/.test(trimmed)) {
+            const [first, ...rest] = trimmed.split(/[,;|\t]/).map((field) => field.trim());
+            if (first.toLowerCase() === 'seed') continue;
+            push(first);
+            rest.filter((field) => /[a-z]/i.test(field)).forEach(push);
+        } else {
+            trimmed.split(/\s+/).forEach(push);
+        }
+    }
+    return seeds;
+}
+
 const initialState: InitialState = {
     engineState: {
         seed: '',
@@ -175,8 +247,10 @@ const initialState: InitialState = {
         rerollStartIndex: 0,
         drawSimulatorModalOpen: false,
         conversionSourceId: null,
-        apiEndpoint: 'https://motelyjaml-pi.8pi.me'
+        apiEndpoint: 'https://motelyjaml-pi.8pi.me',
+        assistantOpen: false,
     },
+    seedQueue: loadSeedQueue(),
     searchState: {
         searchTerm: '',
         searchResults: [],
@@ -302,17 +376,7 @@ export const useCardStore = create<CardStore>()(
                         prev.searchState = initialState.searchState;
                         prev.applicationState.hasSettingsChanged = true;
 
-                        const deckType = deckMap[prev.engineState.deck];
-                        const stakeType = stakeMap[prev.engineState.stake];
-                        const params = new InstanceParams(
-                            new Deck(deckType),
-                            new Stake(stakeType),
-                            prev.engineState.showmanOwned,
-                            Number(prev.engineState.gameVersion)
-                        );
-                        const game = new Game(prev.engineState.seed, params);
-                        const gameCards = game.initDeck();
-                        prev.deckState.cards = gameCards.map((card, i) => convertGameCardToDeckCard(card, i));
+                        prev.deckState.cards = startingDeckCards(prev.engineState.seed, prev.engineState);
                         prev.deckState.isInitialized = true;
                     }, undefined, 'Global/SetSeed'),
                     setDeck: (deck: string) => set((prev) => {
@@ -322,18 +386,7 @@ export const useCardStore = create<CardStore>()(
                         // Create Game instance for deck initialization
                         // Only if we have a seed, otherwise use standard generation
                         if (prev.engineState.seed) {
-                            const deckType = deckMap[deck];
-                            const stakeType = stakeMap[prev.engineState.stake];
-                            const params = new InstanceParams(
-                                new Deck(deckType),
-                                new Stake(stakeType),
-                                prev.engineState.showmanOwned,
-                                Number(prev.engineState.gameVersion)
-                            );
-                            const game = new Game(prev.engineState.seed, params);
-
-                            const gameCards = game.initDeck();
-                            prev.deckState.cards = gameCards.map((card, i) => convertGameCardToDeckCard(card, i));
+                            prev.deckState.cards = startingDeckCards(prev.engineState.seed, prev.engineState);
                         } else {
                             const starterDeck = generateStartingDeck(deck);
                             prev.deckState.cards = starterDeck;
@@ -426,6 +479,37 @@ export const useCardStore = create<CardStore>()(
                     toggleOutput: () => set((prev) => {
                         prev.applicationState.asideOpen = !prev.applicationState.asideOpen;
                     }, undefined, 'Global/ToggleOutput'),
+                    toggleAssistant: () => set((prev) => {
+                        prev.applicationState.assistantOpen = !prev.applicationState.assistantOpen;
+                    }, undefined, 'Global/ToggleAssistant'),
+                    setSeedQueue: (seeds) => {
+                        set((prev) => {
+                            prev.seedQueue = { seeds, index: 0 };
+                            saveSeedQueue(prev.seedQueue);
+                        }, undefined, 'SeedQueue/Set');
+                        if (seeds.length > 0) get().jumpSeedQueue(0);
+                    },
+                    jumpSeedQueue: (index) => {
+                        const { seeds } = get().seedQueue;
+                        if (seeds.length === 0) return;
+                        const clamped = Math.min(Math.max(0, Math.trunc(index)), seeds.length - 1);
+                        get().setSeed(seeds[clamped]);
+                        set((prev) => {
+                            prev.seedQueue.index = clamped;
+                            prev.applicationState.start = true;
+                            prev.applicationState.viewMode = prev.applicationState.viewMode === 'jaml'
+                                ? 'blueprint'
+                                : prev.applicationState.viewMode;
+                            saveSeedQueue(prev.seedQueue);
+                        }, undefined, 'SeedQueue/Jump');
+                    },
+                    stepSeedQueue: (delta) => {
+                        get().jumpSeedQueue(get().seedQueue.index + delta);
+                    },
+                    clearSeedQueue: () => set((prev) => {
+                        prev.seedQueue = { seeds: [], index: 0 };
+                        saveSeedQueue(prev.seedQueue);
+                    }, undefined, 'SeedQueue/Clear'),
                     setApiEndpoint: (apiEndpoint) => set((prev) => {
                         prev.applicationState.apiEndpoint = apiEndpoint;
                     }, undefined, 'Global/SetApiEndpoint'),
@@ -629,7 +713,7 @@ export const useCardStore = create<CardStore>()(
                         buys: state.shoppingState.buys,
                         sells: state.shoppingState.sells
                     },
-                    applicationState: state.applicationState,
+                    applicationState: { ...state.applicationState, assistantOpen: false },
                     searchState: state.searchState,
                     deckState: state.deckState
                 }),
diff --git a/src/modules/webmcp/knowledge.ts b/src/modules/webmcp/knowledge.ts
new file mode 100644
index 0000000..2e3537b
--- /dev/null
+++ b/src/modules/webmcp/knowledge.ts
@@ -0,0 +1,83 @@
+export const BALATRO_KNOWLEDGE = `
+## What Balatro is
+
+Balatro (LocalThunk, 2024) is a poker-themed roguelike deckbuilder: play poker hands from a 52-card deck to beat escalating "blinds"; Jokers, consumables and vouchers bend the rules.
+
+**Run structure.** A run is 8 Antes (Endless continues past 8). Each Ante has three blinds in order: **Small Blind** (1x base chips, reward $3), **Big Blind** (1.5x, $4), **Boss Blind** (2x, $5, plus a rule-breaking effect). White-stake base chips per Ante: 300, 800, 2000, 5000, 11000, 20000, 35000, 50000; Green/Purple stakes scale harder . Small and Big Blinds can be **skipped** for a **Tag** (you forfeit that blind's money and its shop). Boss Blinds cannot be skipped. Defaults: 4 hands, 3 discards, hand size 8, 5 Joker slots, 2 consumable slots, $4 starting money. Money earns interest: $1 per $5 held, capped at $5 (i.e. $25 held); Seed Money/Money Tree raise the cap.
+
+**Scoring.** Score = Chips × Mult. Each played hand type has a base (e.g. High Card 5×1, Pair 10×2, Flush 35×4) that Planet cards level up. Scored cards add their chip value; Jokers add +Chips, +Mult, or ×Mult. Evaluation is left to right across Jokers and scored cards, so order matters for copy/retrigger Jokers. Flat +Mult wins early; only ×Mult and retriggers keep pace after Ante ~4. The IEEE-754 overflow at ~1e308 displays as **naneinf**; Plasma Deck (score = ((Chips+Mult)/2)²) needs only ~1e154 Mult to reach it.
+
+**Shops.** After each non-skipped blind: 2 card slots (Overstock/Overstock Plus add up to 2 more), 1 voucher slot (restocks after each Boss), 2 booster-pack slots. Reroll costs $5, +$1 per reroll, resets each shop (Reroll Surplus/Glut reduce it). Card-slot pool weights: Joker 20, Tarot 4, Planet 4; playing cards only with Magic Trick, Spectrals only on Ghost Deck . Shop Joker rarity: 70% Common, 25% Uncommon, 5% Rare; Legendaries never appear in shops. Shop edition odds: Foil 2%, Holographic 1.4%, Polychrome 0.3%, Negative 0.3% (Hone ×2, Glow Up ×4) . Packs: Standard (playing cards), Arcana (Tarot), Celestial (Planet), Buffoon (Jokers), Spectral; sizes Normal (choose 1 of 3, $4), Jumbo (1 of 5, $6), Mega (2 of 5, $8). The first shop of a run always contains a Buffoon pack, but it is a normal 1-of-3 pack, not a Mega. Slang to normalize: "tarot pack" = Arcana, "planet pack" = Celestial, "joker pack" = Buffoon, "ghost pack" = Spectral, "playing card pack" = Standard.
+
+**Vouchers (32, 16 pairs; tier 2 requires tier 1 bought, so earliest is Ante 2).** Overstock → Overstock Plus (shop slots); Clearance Sale → Liquidation (25%/50% off); Hone → Glow Up (edition rates); Reroll Surplus → Reroll Glut; Crystal Ball → Omen Globe (+1 consumable slot; Spectrals in Arcana packs); Telescope → Observatory (Celestial packs contain your most-played hand's Planet; held Planets give ×1.5 to their hand); Grabber → Nacho Tong (+hands); Wasteful → Recyclomancy (+discards); Tarot Merchant → Tarot Tycoon; Planet Merchant → Planet Tycoon; Director's Cut → Retcon (reroll boss once per Ante $10 / unlimited); Paint Brush → Palette (+hand size); Magic Trick → Illusion (playing cards in shop, then with modifiers); Blank → Antimatter (nothing → +1 Joker slot); Seed Money → Money Tree (interest cap $10/$20); Hieroglyph → Petroglyph (Ante −1, costs a hand/discard; enables "ante 0").
+
+**Consumables.** Tarot (22): The Fool (copy last Tarot/Planet), Magician (Lucky), High Priestess (2 Planets), Empress (Mult), Emperor (2 Tarots), Hierophant (Bonus), Lovers (Wild), Chariot (Steel), Justice (Glass), Hermit (double money, max $20), Wheel of Fortune (1 in 4 edition on a Joker), Strength (+1 rank), Hanged Man (destroy 2), Death (copy right card onto left), Temperance (Joker sell value, max $50), Devil (Gold), Tower (Stone), Star/Moon/Sun/World (3 cards to Diamonds/Clubs/Hearts/Spades), Judgement (random Joker). Planet (12): Pluto High Card, Mercury Pair, Uranus Two Pair, Venus Three of a Kind, Saturn Straight, Jupiter Flush, Earth Full House, Mars Four of a Kind, Neptune Straight Flush, Planet X Five of a Kind, Ceres Flush House, Eris Flush Five. Spectral (18): Familiar/Grim/Incantation (destroy 1, add enhanced face cards/Aces/numbers), Talisman (Gold Seal), Aura (edition), Deja Vu (Red Seal), Trance (Blue Seal), Medium (Purple Seal), Ouija (one rank, −1 hand size), Sigil (one suit), Cryptid (2 copies of a card), Wraith (Rare Joker, money to $0), Immolate (destroy 5, +$20), Ankh (copy a random Joker, destroy the rest), Hex (Polychrome on a random Joker, destroy the rest), Ectoplasm (Negative on a Joker, −1 hand size), **The Soul** (Legendary Joker), **Black Hole** (all hands +1 level). The Soul has a 0.3% chance per card generated in Arcana and Spectral packs; Black Hole 0.3% in Celestial and Spectral packs. The game avoids offering a consumable you already hold unless you have Showman.
+
+**Enhancements/Seals/Editions.** Enhancements: Bonus +30 chips, Mult +4, Wild (any suit), Glass ×2 (1 in 4 to shatter), Steel ×1.5 while held in hand, Stone +50 chips no rank/suit, Gold $3 if held at end of round, Lucky (1 in 5 +20 Mult, 1 in 15 $20). Seals: Red (retrigger once), Blue (Planet of the final hand if held), Gold ($3 when scored), Purple (Tarot when discarded). Editions: Foil +50 chips, Holographic +10 Mult, Polychrome ×1.5 Mult, **Negative** (+1 Joker slot; on consumables +1 consumable slot; the Negative card occupies no net space).
+
+**Tags (24, skip rewards).** Uncommon/Rare Tag (free Uncommon/Rare Joker in next shop); Negative/Foil/Holographic/Polychrome Tag (the **next base-edition Joker in a shop** becomes free with that edition; the tag waits if none is present); Investment ($25 after next Boss); Voucher (extra voucher in next shop); Boss (reroll boss); Standard/Charm/Meteor/Buffoon (free Mega Standard/Arcana/Celestial/Buffoon pack); Ethereal (free Spectral pack); Handy ($1 per hand played this run); Garbage ($1 per unused discard); Coupon (next shop's initial items free); Double (copies the next tag chosen); Juggle (+3 hand size next round); D6 (rerolls start at $0); Top-up (up to 2 Common Jokers); Speed ($5 per skipped blind); Orbital (+3 levels to a random hand); Economy (double money, max +$40). Tags are attached to each Small/Big Blind at generation; blinds do not "grant" tags for winning. : Negative, Foil, Holographic, Polychrome, Standard, Meteor, Buffoon, Handy, Garbage, Ethereal, Top-up and Orbital have a minimum Ante of 2, so an "Ante 1 Negative Tag" filter should return nothing.
+
+**Legendary Jokers (only via The Soul):** Canio (×Mult when a face card is destroyed; spelling "Caino" is wrong), Triboulet (×2 per scored King/Queen), Yorick (×1 per 23 discards), Chicot (disables Boss Blind effects), Perkeo (Negative copy of a random held consumable at end of shop).
+
+**Decks (15).** Red +1 discard; Blue +1 hand; Yellow +$10; Green no interest, $2/hand and $1/discard left; Black +1 Joker slot, −1 hand; Magic (Crystal Ball, 2× The Fool); Nebula (Telescope, −1 consumable slot); Ghost (Spectrals in shop, starts with Hex); Abandoned (40 cards, no face cards); Checkered (26 Spades, 26 Hearts); Zodiac (Tarot Merchant, Planet Merchant, Overstock); Painted (+2 hand size, −1 Joker slot); Anaglyph (Double Tag per Boss defeated); Plasma (averaged scoring, blinds ×2); Erratic (random ranks/suits, the only deck where \`ErraticSuit\`/\`ErraticRank\` filters apply). "Challenge" is a mode, not a deck, and cannot be seeded.
+
+**Boss Blinds (28; 23 regular, 5 Ante-8 finishers).** Debuffers: The Club/Goad/Window/Head (Clubs/Spades/Diamonds/Hearts), The Plant (face cards), The Pillar (cards played earlier this Ante). Restrictors: The Psychic (exactly 5 cards), The Eye (no repeat hand types), The Mouth (one hand type), The Needle (one hand). Hidden info: The House (first hand face down), The Wheel (1 in 7 face down), The Fish (draws face down), The Mark (face cards face down). Scalers: The Wall (4x chips), The Flint (halves base chips and mult). Others: The Ox ($0 if you play your most-played hand), The Tooth (−$1 per card played), The Arm (−1 hand level), The Hook (discards 2 after each play), The Manacle (−1 hand size), The Water (no discards), The Serpent (always draw 3 after play/discard). Finishers: Amber Acorn (flips/shuffles Jokers), Cerulean Bell (forces a card selected), Crimson Heart (disables a random Joker each hand), Verdant Leaf (all cards debuffed until you sell a Joker), Violet Vessel (3x chips).
+
+**Stakes (8).** White base; Red no Small Blind money; Green faster blind scaling; Black Eternal stickers (can't sell/destroy, ~30%); Blue −1 discard; Purple faster scaling; Orange Perishable stickers (debuffed after 5 rounds); Gold Rental stickers ($3 per round). Stickers gate strategies: Eternal Invisible Joker/Luchador are useless; a Perishable scaler dies before paying off.
+
+**Seeds and RNG.** A seed is 1–8 characters from \`1-9A-Z\` (no zero): 35⁸ ≈ 2.3 trillion seeds ****. Every random event is a pseudo-hash of (a string key + the seed), so each domain has its own independent stream: shop queue per Ante, pack contents, card draw, boss selection, tag selection, edition rolls, and "1 in X" probability rolls (Wheel of Fortune, Lucky cards, Glass) each advance only their own key. Shop queues are keyed by Ante: viewing/rerolling advances that Ante's queue, and 5 rerolls then 7 gives the same sequence as 7 then 5; skipping doesn't skip that Ante's queue. Player choices (buying, rerolling, opening packs) consume queue positions, so an analyzer shows the queue for a given set of choices and Blueprint's "buy" simulation advances it. Same seed + deck + stake + game version (1.0.0n, 1.0.1c, 1.0.1f) + same choices = same run. Unlocks matter: a locked card rolls over to something else on that profile, and Legendaries require having found a Soul once unseeded. \`src/modules/balatrots/enum/\` in Blueprint holds the exact PRNG key strings; never alter them.
+
+## Seed-hunting strategy and terminology
+
+- **God seed**: a seed whose queues line up for a specific build. Prioritise what makes the run (the legendary/engine + its ante window) and rank the rest.
+- **The Soul / "soul card"**: the only Legendary source; hunt it in Arcana/Spectral packs (Mega packs = more cards = more 0.3% rolls). Perkeo can duplicate a held Soul.
+- **negleg**: shorthand for "Negative Legendary" searches (Blueprint README mentions ~8M seeds/s on that filter).
+- **Perkeo loops**: hold one Cryptid → Negative Cryptids every shop → duplicate Red-Seal Steel Kings into 90-card hands; hold Pluto + Observatory → (1.5)^N on High Card ("Observatory infinite"); Blueprint/Brainstorm on Perkeo multiplies the copies.
+- **Baron + Mime** (Steel Kings, Red Seals): (1.5)^4 per King; plus Serpent boss + Burglar to draw the whole deck; the standard naneinf engine. Killed by **The Plant** (debuffs face cards) unless Director's Cut/Retcon is available.
+- **Blueprint/Brainstorm copy**: Blueprint copies the Joker to its right, Brainstorm the leftmost. Copying the ×Mult (Photograph) beats copying the retrigger (Chad): Photo+Chad ×8, Blueprint-on-Photo ×64, Blueprint-on-Chad ×32. Order rule: enabler left of payoff (Midas Mask before Vampire).
+- **PhotoChad**: Photograph + Hanging Chad, $9 for ×8; Glass ×64, Red Seal ×128–256.
+- **Triboulet/Idol engine**: Sock & Buskin or Hanging Chad retriggers on Red-Seal Glass Kings/Queens; The Idol needs a homogenized deck (Death, Hanged Man, Cryptid, Trading Card).
+- **Ankh / Invisible Joker / Showman**: Ankh copies one random Joker and destroys the rest (classic early double-Blueprint); Invisible Joker sold after 2 rounds duplicates a random Joker (only way to double a Legendary); Showman allows duplicates in shops/packs. Selling a Negative Joker while at the cap causes **slot debt** (over cap, can't buy).
+- **Diet Cola / Double Tag stacking**: selling Diet Cola creates a Double Tag; Double Tags stack, so a pile of them cashed on a Negative Tag yields many free Negative Jokers (Anaglyph Deck does this natively).
+- **Tarot looping**: hold Negative copies of all Tarots except Emperor/Fool/Judgement (no Showman) so Emperor always yields Fool + Judgement; Fool re-creates Emperor; each Judgement has 0.3% Negative chance. "150 negatives" screenshot build.
+- **Chicot × Manacle**: multiple Chicots reportedly turn Manacle's −1 hand size into +1 [unverified].
+- **Oops! All 6s "casino"**: doubles listed probability numerators (Bloodstone 1 in 2 → guaranteed, Glass breaks 50%, Wheel boss 2 in 7).
+- **Vampire + Midas Mask**, **Merry Andy + Hit the Road**, **DNA + Hologram**, **Hack + Wee Joker/Fibonacci**: enabler → payoff pairs. Anti-pairs: Vampire + Glass, Madness/Ceremonial Dagger + Eternal, Ride the Bus + Sock & Buskin, Joker Stencil + full board.
+- **Phase rule**: Antes 1–2 need an anchor (+Mult/+Chips: Joker, Sly, Half, Gros Michel); Antes 3–5 need scalers (Constellation, Green Joker, Ride the Bus, Hologram) acquired early enough to grow; Antes 6–8 need 2–3 ×Mult sources. A late Constellation is a trap.
+- **Community seeds [unverified]**: ALEEB (all 5 Legendaries by Ante 3, no skips), 11Y68BMP (double Polychrome Brainstorm + Holo Perkeo Ante 1), MIPK41M6 (Ghost: only Rares and Spectral packs), DCVE28EC (Ghost: Perkeo in Ante 1 shop), 8Q47WV6K (skip both Ante 1 blinds: Triboulet then Perkeo from Mega Arcana packs), 7M1GURT (63 Wheel of Fortune fails), I3EFEF17 (Erratic: 25 Tens), LWQW78CB (early Baron+Mime), YR98CK4B (Negative Perkeo Ante 1); seed index: LEGEJS53 (double Rare Tag), CASHCASH (Spectral tags), GLASS/X3DISXVS (DNA), FULL (Joker Stencil), AYO (Ouija all Kings).
+
+## JAML, Motely, seedfinder.app, and Blueprint
+
+**Motely** is the C# seed-search engine (by tacodiva, commissioned by OptimusPi/pifreak): AVX-512 SIMD, 8 seeds per vector per thread, the fastest CPU searcher. **motely-wasm** is its browser/Node build; v11+ is NativeAOT-LLVM, single-threaded, no SharedArrayBuffer/COI worker, boot once. Blueprint currently pins \`motely-wasm ^26.0.0\` and \`jaml-ui ^4.6.0\`. Search runs client-side in the browser; the MCP server never runs a search. FIXES.md (v22 era) documents: \`Program.jamlyze(seed, deck, stake)\` returns shopQueue, packs[].items, grantedLegendaryJoker and tag-granted Jokers per ante (~1200 seeds/s headless); items are integers with a rarity-paged encoding — \`(v>>8)&0xF0 == 0x50\` marks a Joker, \`(v>>8)&0x0F\` is rarity (0 common, 4 uncommon, 8 rare, C legendary), \`v&0xFF\` indexes the rarity-specific enum, \`(v>>16)&0xFF\` is edition (0x80 Negative); e.g. Blueprint 0x5807, Brainstorm 0x5811, Perkeo 0x5C04. \`jaml-lang\` is the language server (diagnostics/completions/hover), not a compiler; \`jaml-codemirror\` wires it into CodeMirror 6; \`jaml-ui\` provides JamlIde/JamlGameCard components.
+
+**JAML (Jimbo's Ante Markup Language)** is a strict YAML-shaped filter DSL validated at load (schema \`https://mcp.seedfinder.app/jaml.schema.json\`, generated from Motely DTOs; VS Code extension \`pifreak.jaml-language-support\`).
+- Top-level keys: \`name\`, \`deck\`, \`stake\` (plus \`id\`, \`version\`, \`author\`, \`description\`), and clause groups \`must\` (hard gates), \`should\` (add \`score: N\`, summed to rank), \`mustNot\` (disqualifiers). At least one group required.
+- Clause discriminators, PascalCase values: \`joker\` (150), \`rareJoker\`/\`uncommonJoker\`/\`commonJoker\` (same match plus a parse-time rarity check), \`legendaryJoker\` (Canio, Triboulet, Yorick, Chicot, Perkeo), \`voucher\` (32), \`tarotCard\` (22), \`spectralCard\` (18), \`planetCard\` (12), \`boss\` (28), \`tag\` (24), \`smallBlindTag\`/\`bigBlindTag\`, \`standardCard\` (with \`enhancement\`/\`seal\`/\`edition\`), and event keys (\`wheelStaysFlipped\`, \`bloodstoneTrigger\`, \`luckyMoney\`, \`businessPayout\`, \`parkingPayout\`, \`misprintMult\` with \`mult:N\`) whose value is a roll-index array with \`min\`/\`max\`.
+- Shared props: \`antes: [..]\` (0–39; 0 via Hieroglyph), \`score\`, \`label\`, \`edition\` (Negative/Foil/Holographic/Polychrome), \`seal\`, \`enhancement\`, \`sources: {shopItems: [0-7], boosterPacks: [0-5], arcanaPacks, spectralPacks}\`, \`min\`.
+- Defaults: a \`joker:\` clause with no \`sources:\` checks **shop slots only**; legendaries **never** match shopItems and must use \`legendaryJoker:\` with \`boosterPacks\` (or arcana/spectral pack) sources. Tier-2 vouchers can't appear before Ante 2.
+- Names: \`JokerStencil\` (not Stencil Joker), \`EightBall\`/"8 Ball", \`OopsAll6s\`, \`TheSoul\`, \`BlackHole\`, \`DirectorsCut\`, \`GlowUp\`, \`NegativeTag\`, \`ThePlant\`, \`TheSerpent\`, \`VioletVessel\`; decks \`Red…Erratic\`; stakes \`White…Gold\`.
+- **JUMMY** one-liners (\`Blueprint in antes 1 or 2\`, \`Eternal Blueprint in Ante 1\`, \`Perkeo in antes 1, 2, or 3\`) are shorthand for the same clause; they cannot express \`sources:\`.
+- Tips from the docs: keep \`must\` short and early-ante (every clause is a SIMD gate; ten must-jokers = zero hits); push synergy pieces into \`should\` with weights (e.g. Baron must, Mime/Blueprint/Brainstorm/Telescope should); reserve \`mustNot\` for fatal counters like \`boss: ThePlant\` on a face-card build rather than "no Anaglyph". A validated-but-zero-hit filter is usually over-gated. Keyword seed search (e.g. seeds containing PIFREAK) is a search-provider feature, not a JAML key.
+
+Example (from the corpus):
+\`\`\`yaml
+name: Perkeo — negative consumables
+deck: Red
+stake: White
+must:
+  - legendaryJoker: Perkeo
+    antes: [1]
+    sources: { arcanaPacks: [0, 1], spectralPacks: [0, 1] }
+should:
+  - spectralCard: Cryptid
+    antes: [1, 2, 3]
+    score: 45
+  - joker: Blueprint
+    antes: [1, 2]
+    score: 40
+\`\`\`
+
+**seedfinder.app / MCP.** \`mcp.seedfinder.app/mcp\` (server "balatro-seed-oracle"; the earlier "balatro-seedfinder" had get_jaml_schema/validate_jaml/describe_filter/analyze_seeds/open_filter_editor) exposes learn_jaml → plan_seed_search → validate_jaml → show_seedfinder_app (loads a draft into the app editor), plus score_seeds/jamlyze_seeds/find_similar_seeds for known seeds, estimate_keyword_search, save_filter/list_filters/get_filter (Neon), save_seed/list_seeds, and community search parties that split the 2.3T keyspace by block range. Full-keyspace grinding runs on the user's CPU via motely-wasm. A past bug remounted the app iframe once per widget tool call; the fix is one stable \`ui://\` template per tool with data via notifications (MCP Apps, SEP-1865). "The Long Blind" is the Next.js/R3F frontend in the patch doc; \`BalatroSeedOracle.x64.2.0.0.exe\` is the older desktop searcher.
+
+**Blueprint (this app).** "Blueprint – pifreak's version": a Vite + Mantine React fork of Blueprint (miaklwalker), itself derived from MathIsFun0's The Soul (\`immolate.js\`). It takes a seed, deck, stake and version and reconstructs the run per Ante: shop queue, vouchers, tags, boss blind, booster packs and their contents, with a "JAML Mapped" view, in-browser motely-wasm search, and TXT/CSV seed-list upload. "Buying" in the simulator advances the relevant queue so later shops/packs match the live game. The assistant should describe what a given Ante's queue shows, translate wishes into JAML using the rules above, and note unlock/version caveats when a user can't reproduce a seed.
+`;
diff --git a/src/modules/webmcp/memory.ts b/src/modules/webmcp/memory.ts
new file mode 100644
index 0000000..5f55fb6
--- /dev/null
+++ b/src/modules/webmcp/memory.ts
@@ -0,0 +1,34 @@
+const MEMORY_KEY = "blueprint-assistant-memory";
+const MAX_NOTES = 40;
+
+export function listMemory(): Array<string> {
+    try {
+        const parsed = JSON.parse(localStorage.getItem(MEMORY_KEY) ?? "[]");
+        return Array.isArray(parsed) ? parsed.filter((n) => typeof n === "string") : [];
+    } catch {
+        return [];
+    }
+}
+
+export function remember(note: string): Array<string> {
+    const trimmed = note.trim();
+    const notes = listMemory().filter((n) => n !== trimmed);
+    if (trimmed) notes.push(trimmed);
+    const kept = notes.slice(-MAX_NOTES);
+    try {
+        localStorage.setItem(MEMORY_KEY, JSON.stringify(kept));
+    } catch {
+        return kept;
+    }
+    return kept;
+}
+
+export function forget(note?: string): Array<string> {
+    const kept = note ? listMemory().filter((n) => n !== note) : [];
+    try {
+        localStorage.setItem(MEMORY_KEY, JSON.stringify(kept));
+    } catch {
+        return kept;
+    }
+    return kept;
+}
diff --git a/src/modules/webmcp/register.ts b/src/modules/webmcp/register.ts
new file mode 100644
index 0000000..3c39a12
--- /dev/null
+++ b/src/modules/webmcp/register.ts
@@ -0,0 +1,63 @@
+import { initializeWebMCPPolyfill } from "@mcp-b/webmcp-polyfill";
+import { listTools, onToolsChanged, registerTools } from "./registry.ts";
+import { blueprintTools } from "./tools.ts";
+import type { BlueprintTool } from "./registry.ts";
+
+interface ModelContextLike {
+    registerTool: (
+        tool: {
+            name: string;
+            description: string;
+            inputSchema: BlueprintTool["inputSchema"];
+            annotations?: { readOnlyHint?: boolean; consequentialHint?: boolean };
+            execute: (input: Record<string, unknown>, options?: { signal?: AbortSignal }) => Promise<unknown>;
+        },
+        options?: { signal?: AbortSignal },
+    ) => Promise<void>;
+}
+
+const READ_ONLY = new Set(["get_app_state", "get_seed_overview", "get_ante_details", "find_items", "list_purchases", "get_jaml_filter"]);
+
+function modelContext(): ModelContextLike | undefined {
+    const doc = document as Document & { modelContext?: ModelContextLike };
+    if (doc.modelContext?.registerTool) return doc.modelContext;
+    const nav = navigator as Navigator & { modelContext?: ModelContextLike };
+    return nav.modelContext?.registerTool ? nav.modelContext : undefined;
+}
+
+let controller: AbortController | null = null;
+
+async function publish() {
+    const ctx = modelContext();
+    if (!ctx) return;
+    controller?.abort();
+    controller = new AbortController();
+    const { signal } = controller;
+    for (const tool of listTools()) {
+        try {
+            await ctx.registerTool(
+                {
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema,
+                    annotations: { readOnlyHint: READ_ONLY.has(tool.name), consequentialHint: !READ_ONLY.has(tool.name) },
+                    execute: async (input) => JSON.stringify(await tool.execute(input ?? {})),
+                },
+                { signal },
+            );
+        } catch (error) {
+            console.warn(`WebMCP: could not register ${tool.name}`, error);
+        }
+    }
+}
+
+let started = false;
+
+export function startWebMcp() {
+    if (started || typeof document === "undefined") return;
+    started = true;
+    initializeWebMCPPolyfill();
+    registerTools(blueprintTools);
+    onToolsChanged(() => void publish());
+    void publish();
+}
diff --git a/src/modules/webmcp/registry.ts b/src/modules/webmcp/registry.ts
new file mode 100644
index 0000000..129e6ad
--- /dev/null
+++ b/src/modules/webmcp/registry.ts
@@ -0,0 +1,51 @@
+export interface ToolInputSchema {
+    type: "object";
+    properties?: Record<string, unknown>;
+    required?: Array<string>;
+    additionalProperties?: boolean;
+}
+
+export interface BlueprintTool {
+    name: string;
+    description: string;
+    inputSchema: ToolInputSchema;
+    execute: (input: Record<string, unknown>) => unknown | Promise<unknown>;
+}
+
+const tools = new Map<string, BlueprintTool>();
+const listeners = new Set<() => void>();
+
+function notify() {
+    for (const listener of listeners) listener();
+}
+
+export function registerTool(tool: BlueprintTool): () => void {
+    tools.set(tool.name, tool);
+    notify();
+    return () => {
+        if (tools.get(tool.name) === tool) {
+            tools.delete(tool.name);
+            notify();
+        }
+    };
+}
+
+export function registerTools(list: Array<BlueprintTool>): () => void {
+    const unregister = list.map(registerTool);
+    return () => unregister.forEach((fn) => fn());
+}
+
+export function listTools(): Array<BlueprintTool> {
+    return Array.from(tools.values());
+}
+
+export function onToolsChanged(listener: () => void): () => void {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+
+export function callTool(name: string, input: Record<string, unknown> = {}): Promise<unknown> {
+    const tool = tools.get(name);
+    if (!tool) return Promise.reject(new Error(`Unknown tool: ${name}`));
+    return Promise.resolve(tool.execute(input));
+}
diff --git a/src/modules/webmcp/summary.ts b/src/modules/webmcp/summary.ts
new file mode 100644
index 0000000..3a79c54
--- /dev/null
+++ b/src/modules/webmcp/summary.ts
@@ -0,0 +1,126 @@
+import type { Ante, CardTuple, SeedResultsContainer, Stringifies } from "../GameEngine/CardEngines/Cards.ts";
+import type { Blinds } from "../state/store.ts";
+
+export type ItemSource = "shop" | "pack" | "misc" | "voucher" | "tag" | "boss";
+
+export interface ItemLocation {
+    ante: number;
+    source: ItemSource;
+    name: string;
+    edition?: string;
+    index?: number;
+    blind?: Blinds;
+    packIndex?: number;
+    packName?: string;
+    miscSource?: string;
+}
+
+const BLINDS: Array<Blinds> = ["smallBlind", "bigBlind", "bossBlind"];
+
+function label(card: Stringifies | CardTuple | undefined): string {
+    if (!card) return "";
+    const edition = card.edition && card.edition !== "No Edition" ? ` (${card.edition})` : "";
+    return `${card.name}${edition}`;
+}
+
+function sortedAntes(results: SeedResultsContainer): Array<Ante> {
+    return Object.values(results.antes).sort((a, b) => a.ante - b.ante);
+}
+
+export function summarizeSeed(seed: string, results: SeedResultsContainer, shopLimit = 12) {
+    return {
+        seed,
+        antes: sortedAntes(results).map((ante) => ({
+            ante: ante.ante,
+            boss: ante.boss,
+            voucher: ante.voucher,
+            tags: ante.tags,
+            shop: ante.queue.slice(0, shopLimit).map(label),
+            shopSize: ante.queue.length,
+            packs: BLINDS.flatMap((blind) =>
+                ante.blinds[blind].packs.map((pack) => ({
+                    blind,
+                    pack: pack.name,
+                    cards: pack.cards.map(label),
+                })),
+            ),
+        })),
+    };
+}
+
+export function describeAnte(ante: Ante) {
+    return {
+        ante: ante.ante,
+        boss: ante.boss,
+        voucher: ante.voucher,
+        tags: ante.tags,
+        shop: ante.queue.map((card, index) => ({ index, item: label(card), type: card.type })),
+        packs: BLINDS.flatMap((blind) =>
+            ante.blinds[blind].packs.map((pack, packIndex) => ({
+                blind,
+                packIndex,
+                pack: pack.name,
+                choices: pack.choices,
+                cards: pack.cards.map((card, index) => ({ index, item: label(card) })),
+            })),
+        ),
+        miscSources: ante.miscCardSources.map((source) => ({
+            source: source.name,
+            cards: source.cards.slice(0, 15).map((card) => card.joker ?? card.name ?? card.base ?? ""),
+        })),
+    };
+}
+
+function matches(needle: string, name: string | null | undefined): boolean {
+    return !!name && name.toLowerCase().includes(needle);
+}
+
+export function findItems(results: SeedResultsContainer, names: Array<string>, maxPerName = 25): Record<string, Array<ItemLocation>> {
+    const out: Record<string, Array<ItemLocation>> = {};
+    for (const raw of names) {
+        const needle = raw.trim().toLowerCase();
+        if (!needle) continue;
+        const hits: Array<ItemLocation> = [];
+        for (const ante of sortedAntes(results)) {
+            if (matches(needle, ante.voucher)) hits.push({ ante: ante.ante, source: "voucher", name: ante.voucher! });
+            if (matches(needle, ante.boss)) hits.push({ ante: ante.ante, source: "boss", name: ante.boss! });
+            ante.tags.forEach((tag) => {
+                if (matches(needle, tag)) hits.push({ ante: ante.ante, source: "tag", name: tag });
+            });
+            ante.queue.forEach((card, index) => {
+                if (matches(needle, card.name)) {
+                    hits.push({ ante: ante.ante, source: "shop", name: card.name, edition: card.edition, index });
+                }
+            });
+            for (const blind of BLINDS) {
+                ante.blinds[blind].packs.forEach((pack, packIndex) => {
+                    pack.cards.forEach((card, index) => {
+                        if (card && matches(needle, card.name)) {
+                            hits.push({
+                                ante: ante.ante,
+                                source: "pack",
+                                name: card.name,
+                                edition: card.edition,
+                                index,
+                                blind,
+                                packIndex,
+                                packName: pack.name,
+                            });
+                        }
+                    });
+                });
+            }
+            for (const misc of ante.miscCardSources) {
+                misc.cards.forEach((card, index) => {
+                    const name = card.joker ?? card.name;
+                    if (matches(needle, name)) {
+                        hits.push({ ante: ante.ante, source: "misc", name: name, edition: card.edition, index, miscSource: misc.name });
+                    }
+                });
+            }
+            if (hits.length >= maxPerName) break;
+        }
+        out[raw] = hits.slice(0, maxPerName);
+    }
+    return out;
+}
diff --git a/src/modules/webmcp/tools.ts b/src/modules/webmcp/tools.ts
new file mode 100644
index 0000000..7a00078
--- /dev/null
+++ b/src/modules/webmcp/tools.ts
@@ -0,0 +1,337 @@
+import { LOCATIONS, LOCATION_TYPES } from "../const.ts";
+import { BuyMetaData } from "../classes/BuyMetaData.ts";
+import { parseSeedList, useCardStore } from "../state/store.ts";
+import { analyzeSeedFromStore } from "../state/analysisResultProvider.tsx";
+import { sanitizeSeed } from "../utils.ts";
+import { describeAnte, findItems, summarizeSeed } from "./summary.ts";
+import { listMemory, remember } from "./memory.ts";
+import type { Blinds } from "../state/store.ts";
+import type { BlueprintTool } from "./registry.ts";
+import type { CardTuple } from "../GameEngine/CardEngines/Cards.ts";
+
+const DECKS = [
+    "Red Deck", "Blue Deck", "Yellow Deck", "Green Deck", "Black Deck", "Magic Deck", "Nebula Deck",
+    "Ghost Deck", "Abandoned Deck", "Checkered Deck", "Zodiac Deck", "Painted Deck", "Anaglyph Deck",
+    "Plasma Deck", "Erratic Deck",
+];
+const STAKES = ["White Stake", "Red Stake", "Green Stake", "Black Stake", "Blue Stake"];
+const BLINDS: Array<Blinds> = ["smallBlind", "bigBlind", "bossBlind"];
+
+function normalizeName(value: unknown, options: Array<string>, suffix: string): string | undefined {
+    if (typeof value !== "string" || !value.trim()) return undefined;
+    const wanted = value.trim().toLowerCase().replace(new RegExp(`\\s*${suffix}$`), "");
+    return options.find((option) => option.toLowerCase().replace(new RegExp(`\\s*${suffix}$`), "") === wanted);
+}
+
+function currentAnalysis(seed?: unknown) {
+    const target = typeof seed === "string" && seed.trim() ? sanitizeSeed(seed) : undefined;
+    const results = analyzeSeedFromStore(target);
+    if (!results) throw new Error("No seed is loaded. Call analyze_seed with a seed first.");
+    return { seed: target ?? useCardStore.getState().engineState.seed, results };
+}
+
+function anteNumber(value: unknown): number {
+    const ante = Math.trunc(Number(value));
+    if (!Number.isFinite(ante) || ante < 0) throw new Error("ante must be a non-negative integer");
+    return ante;
+}
+
+function appState() {
+    const s = useCardStore.getState();
+    return {
+        seed: s.engineState.seed,
+        deck: s.engineState.deck,
+        stake: s.engineState.stake,
+        maxAnte: s.engineState.maxAnte,
+        cardsPerAnte: s.engineState.cardsPerAnte,
+        gameVersion: s.engineState.gameVersion,
+        view: s.applicationState.viewMode,
+        analyzed: s.applicationState.start && !!s.engineState.seed,
+        selectedAnte: s.applicationState.selectedAnte,
+        selectedBlind: s.applicationState.selectedBlind,
+        purchases: Object.keys(s.shoppingState.buys).length,
+        seedQueue: { count: s.seedQueue.seeds.length, index: s.seedQueue.index },
+        memory: listMemory(),
+    };
+}
+
+export const blueprintTools: Array<BlueprintTool> = [
+    {
+        name: "get_app_state",
+        description: "Current Blueprint state: loaded seed, deck, stake, ante range, active view, selected ante/blind, purchase count, seed queue position, and saved user notes.",
+        inputSchema: { type: "object", properties: {}, additionalProperties: false },
+        execute: () => appState(),
+    },
+    {
+        name: "analyze_seed",
+        description: "Load a Balatro seed into Blueprint and analyze it (shop queues, packs, vouchers, tags, bosses per ante). Optionally set deck, stake and how many antes to generate. Returns a compact per-ante overview.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                seed: { type: "string", description: "1-8 characters, A-Z and 1-9 (no zero)." },
+                deck: { type: "string", enum: DECKS },
+                stake: { type: "string", enum: STAKES },
+                maxAnte: { type: "integer", minimum: 1, maximum: 39 },
+            },
+            required: ["seed"],
+            additionalProperties: false,
+        },
+        execute: (input) => {
+            const seed = sanitizeSeed(String(input.seed ?? ""));
+            if (!seed) throw new Error("seed must contain at least one of A-Z or 1-9");
+            const s = useCardStore.getState();
+            const deck = normalizeName(input.deck, DECKS, "deck");
+            const stake = normalizeName(input.stake, STAKES, "stake");
+            if (deck) s.setDeck(deck);
+            if (stake) s.setStake(stake);
+            if (input.maxAnte !== undefined) s.setMaxAnte(Math.max(1, Math.min(39, anteNumber(input.maxAnte))));
+            s.setSeed(seed);
+            if (s.applicationState.viewMode === "jaml") s.setViewMode("blueprint");
+            s.setStart(true);
+            s.setSelectedAnte(1);
+            const results = analyzeSeedFromStore(seed);
+            if (!results) throw new Error("Analysis failed for that seed");
+            return summarizeSeed(seed, results, 8);
+        },
+    },
+    {
+        name: "get_seed_overview",
+        description: "Per-ante overview of the loaded seed (or a given seed without loading it): boss, voucher, tags, first shop items and every booster pack with its contents.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                seed: { type: "string", description: "Defaults to the loaded seed." },
+                shopLimit: { type: "integer", minimum: 1, maximum: 100, description: "Shop items to include per ante (default 12)." },
+            },
+            additionalProperties: false,
+        },
+        execute: (input) => {
+            const { seed, results } = currentAnalysis(input.seed);
+            return summarizeSeed(seed, results, input.shopLimit ? anteNumber(input.shopLimit) : 12);
+        },
+    },
+    {
+        name: "get_ante_details",
+        description: "Everything Blueprint knows about one ante: full shop queue with indices, packs per blind with card indices, misc card sources (Riff-raff, Judgement, Wraith, The Soul...), tags, voucher, boss.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ante: { type: "integer", minimum: 0, maximum: 39 },
+                seed: { type: "string", description: "Defaults to the loaded seed." },
+            },
+            required: ["ante"],
+            additionalProperties: false,
+        },
+        execute: (input) => {
+            const { results } = currentAnalysis(input.seed);
+            const ante = results.antes[anteNumber(input.ante)];
+            if (!ante) throw new Error(`Ante ${input.ante} is outside the generated range. Increase maxAnte with analyze_seed.`);
+            return describeAnte(ante);
+        },
+    },
+    {
+        name: "find_items",
+        description: "Search the loaded seed (or a given seed) for jokers, consumables, vouchers, tags or bosses by name (case-insensitive substring). Returns where each appears: ante, shop index, pack, or misc source. Legendary jokers (Perkeo, Triboulet, Yorick, Chicot, Canio) only resolve when showCardSpoilers is on (set_options); otherwise search for 'The Soul'.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                names: { type: "array", items: { type: "string" }, minItems: 1, description: "e.g. [\"Perkeo\", \"Diet Cola\", \"Negative Tag\", \"Ankh\"]" },
+                seed: { type: "string", description: "Defaults to the loaded seed." },
+            },
+            required: ["names"],
+            additionalProperties: false,
+        },
+        execute: (input) => {
+            const { seed, results } = currentAnalysis(input.seed);
+            const names = Array.isArray(input.names) ? input.names.map(String) : [String(input.names)];
+            return { seed, matches: findItems(results, names) };
+        },
+    },
+    {
+        name: "go_to_ante",
+        description: "Navigate the Blueprint view to an ante and optionally a blind so the user sees it.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ante: { type: "integer", minimum: 0, maximum: 39 },
+                blind: { type: "string", enum: BLINDS },
+            },
+            required: ["ante"],
+            additionalProperties: false,
+        },
+        execute: (input) => {
+            const s = useCardStore.getState();
+            s.setSelectedAnte(anteNumber(input.ante));
+            if (typeof input.blind === "string" && BLINDS.includes(input.blind as Blinds)) s.setSelectedBlind(input.blind as Blinds);
+            return { selectedAnte: s.applicationState.selectedAnte, selectedBlind: useCardStore.getState().applicationState.selectedBlind };
+        },
+    },
+    {
+        name: "buy_item",
+        description: "Mark a shop item or pack card as purchased in the loaded seed. Purchases change later RNG exactly like the game, so re-read the overview afterwards. Use indices from get_ante_details.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                ante: { type: "integer", minimum: 0, maximum: 39 },
+                source: { type: "string", enum: ["shop", "pack"] },
+                index: { type: "integer", minimum: 0, description: "Shop queue index, or card index inside the pack." },
+                blind: { type: "string", enum: BLINDS, description: "Required for packs." },
+                packIndex: { type: "integer", minimum: 0, description: "Required for packs: pack position within the blind." },
+            },
+            required: ["ante", "source", "index"],
+            additionalProperties: false,
+        },
+        execute: (input) => {
+            const s = useCardStore.getState();
+            const { results } = currentAnalysis();
+            const anteNum = anteNumber(input.ante);
+            const ante = results.antes[anteNum];
+            if (!ante) throw new Error(`Ante ${anteNum} is not generated`);
+            const index = anteNumber(input.index);
+            const blind = (typeof input.blind === "string" && BLINDS.includes(input.blind as Blinds) ? input.blind : s.applicationState.selectedBlind) as Blinds;
+            let buy: BuyMetaData;
+            if (input.source === "shop") {
+                const card = ante.queue[index] as CardTuple | undefined;
+                if (!card) throw new Error(`No shop item at index ${index} in ante ${anteNum}`);
+                buy = new BuyMetaData({
+                    location: LOCATIONS.SHOP,
+                    locationType: LOCATION_TYPES.SHOP,
+                    index,
+                    ante: String(anteNum),
+                    blind,
+                    card,
+                    name: card.name,
+                });
+            } else {
+                const packIndex = anteNumber(input.packIndex);
+                const pack = ante.blinds[blind].packs[packIndex];
+                const card = pack?.cards[index];
+                if (!pack || !card) throw new Error(`No pack card at pack ${packIndex}, card ${index} in ante ${anteNum} ${blind}`);
+                buy = new BuyMetaData({
+                    location: pack.name,
+                    locationType: LOCATION_TYPES.PACK,
+                    index,
+                    packIndex,
+                    ante: String(anteNum),
+                    blind,
+                    card,
+                    name: card.name,
+                });
+            }
+            s.addBuy(buy);
+            s.setSelectedAnte(anteNum);
+            s.setSelectedBlind(blind);
+            return { bought: buy.name, ante: anteNum, blind, source: input.source, index };
+        },
+    },
+    {
+        name: "set_options",
+        description: "Change analysis options. showCardSpoilers reveals what The Soul, Judgement and Wraith give (legendary jokers show as 'The Soul' until it is on). cardsPerAnte is how deep each shop queue is generated; maxMiscCardSource how many cards each misc source lists. The seed is re-analyzed.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                showCardSpoilers: { type: "boolean" },
+                cardsPerAnte: { type: "integer", minimum: 1, maximum: 1000 },
+                maxMiscCardSource: { type: "integer", minimum: 1, maximum: 100 },
+            },
+            additionalProperties: false,
+        },
+        execute: (input) => {
+            const s = useCardStore.getState();
+            if (typeof input.showCardSpoilers === "boolean") s.setShowCardSpoilers(input.showCardSpoilers);
+            if (input.cardsPerAnte !== undefined) s.setCardsPerAnte(Math.max(1, Math.min(1000, anteNumber(input.cardsPerAnte))));
+            if (input.maxMiscCardSource !== undefined) s.setMiscMaxSource(Math.max(1, Math.min(100, anteNumber(input.maxMiscCardSource))));
+            const next = useCardStore.getState();
+            return {
+                showCardSpoilers: next.applicationState.showCardSpoilers,
+                cardsPerAnte: next.engineState.cardsPerAnte,
+                maxMiscCardSource: next.applicationState.maxMiscCardSource,
+            };
+        },
+    },
+    {
+        name: "list_purchases",
+        description: "List every purchase the user has marked in the loaded seed.",
+        inputSchema: { type: "object", properties: {}, additionalProperties: false },
+        execute: () =>
+            Object.values(useCardStore.getState().shoppingState.buys).map((buy) => ({
+                name: buy.name,
+                ante: Number(buy.ante),
+                blind: buy.blind,
+                location: buy.location,
+                index: buy.index,
+                packIndex: buy.packIndex,
+            })),
+    },
+    {
+        name: "clear_purchases",
+        description: "Remove every marked purchase from the loaded seed.",
+        inputSchema: { type: "object", properties: {}, additionalProperties: false },
+        execute: () => {
+            useCardStore.getState().setBuys({});
+            return { cleared: true };
+        },
+    },
+    {
+        name: "load_seed_list",
+        description: "Load many seeds into the seed queue (one per line, whitespace or comma separated; CSV first column). The first seed is analyzed immediately; the user steps through the rest with the arrow keys.",
+        inputSchema: {
+            type: "object",
+            properties: { seeds: { type: "string", description: "Raw text containing the seeds." } },
+            required: ["seeds"],
+            additionalProperties: false,
+        },
+        execute: (input) => {
+            const seeds = parseSeedList(String(input.seeds ?? ""));
+            if (seeds.length === 0) throw new Error("No valid seeds found");
+            useCardStore.getState().setSeedQueue(seeds);
+            return { loaded: seeds.length, first: seeds[0] };
+        },
+    },
+    {
+        name: "step_seed_queue",
+        description: "Move through the loaded seed queue: delta of +1/-1 steps, or an absolute index. Loads and analyzes that seed.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                delta: { type: "integer" },
+                index: { type: "integer", minimum: 0 },
+            },
+            additionalProperties: false,
+        },
+        execute: (input) => {
+            const s = useCardStore.getState();
+            if (s.seedQueue.seeds.length === 0) throw new Error("Seed queue is empty. Call load_seed_list first.");
+            if (input.index !== undefined) s.jumpSeedQueue(anteNumber(input.index));
+            else s.stepSeedQueue(Math.trunc(Number(input.delta ?? 1)) || 1);
+            const q = useCardStore.getState().seedQueue;
+            return { index: q.index, count: q.seeds.length, seed: q.seeds[q.index] };
+        },
+    },
+    {
+        name: "set_view",
+        description: "Switch the main view: 'blueprint' (seed explorer) or 'jaml' (JAML seed search IDE).",
+        inputSchema: {
+            type: "object",
+            properties: { view: { type: "string", enum: ["blueprint", "jaml"] } },
+            required: ["view"],
+            additionalProperties: false,
+        },
+        execute: (input) => {
+            const view = input.view === "jaml" ? "jaml" : "blueprint";
+            useCardStore.getState().setViewMode(view);
+            return { view };
+        },
+    },
+    {
+        name: "remember",
+        description: "Save a short note about this user (favourite decks, strategies they like, seeds they are hunting). Notes persist in their browser and are shown to every future assistant session.",
+        inputSchema: {
+            type: "object",
+            properties: { note: { type: "string", minLength: 1, maxLength: 300 } },
+            required: ["note"],
+            additionalProperties: false,
+        },
+        execute: (input) => ({ notes: remember(String(input.note ?? "")) }),
+    },
+];