@genart-dev/mcp-server 0.1.0

package/dist/lib.js

@@ -0,0 +1,3862 @@
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as z2 } from "zod";
+
+// src/tools/workspace.ts
+import { readFile, writeFile, stat } from "fs/promises";
+import { basename, dirname } from "path";
+import {
+  parseGenart,
+  serializeWorkspace
+} from "@genart-dev/core";
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function kebabify(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+async function fileExists(path) {
+  try {
+    await stat(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function dirExists(path) {
+  try {
+    const s = await stat(path);
+    return s.isDirectory();
+  } catch {
+    return false;
+  }
+}
+function arrangePositions(sketches, layout, spacing) {
+  if (sketches.length === 0) return [];
+  if (layout === "row") {
+    let x = 0;
+    return sketches.map((s) => {
+      const pos = { file: s.file, position: { x, y: 0 } };
+      x += s.width + spacing;
+      return pos;
+    });
+  }
+  if (layout === "column") {
+    let y = 0;
+    return sketches.map((s) => {
+      const pos = { file: s.file, position: { x: 0, y } };
+      y += s.height + spacing;
+      return pos;
+    });
+  }
+  const cols = Math.ceil(Math.sqrt(sketches.length));
+  const maxW = Math.max(...sketches.map((s) => s.width));
+  const maxH = Math.max(...sketches.map((s) => s.height));
+  const cellW = maxW + spacing;
+  const cellH = maxH + spacing;
+  return sketches.map((s, i) => ({
+    file: s.file,
+    position: {
+      x: i % cols * cellW,
+      y: Math.floor(i / cols) * cellH
+    }
+  }));
+}
+function computeViewport(positions) {
+  if (positions.length === 0) return { x: 0, y: 0, zoom: 1 };
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const p of positions) {
+    const w = p.width ?? 1200;
+    const h = p.height ?? 1200;
+    if (p.position.x < minX) minX = p.position.x;
+    if (p.position.y < minY) minY = p.position.y;
+    if (p.position.x + w > maxX) maxX = p.position.x + w;
+    if (p.position.y + h > maxY) maxY = p.position.y + h;
+  }
+  const centerX = (minX + maxX) / 2;
+  const centerY = (minY + maxY) / 2;
+  const totalW = maxX - minX;
+  const totalH = maxY - minY;
+  const zoom = Math.min(1, Math.min(1920 / (totalW + 200), 1080 / (totalH + 200)));
+  return { x: Math.round(centerX), y: Math.round(centerY), zoom: Math.round(zoom * 100) / 100 };
+}
+async function createWorkspace(state, input) {
+  const absPath = state.resolvePath(input.path);
+  if (!absPath.endsWith(".genart-workspace")) {
+    throw new Error("Path must end with .genart-workspace");
+  }
+  if (!state.remoteMode) {
+    const parentDir = dirname(absPath);
+    if (!await dirExists(parentDir)) {
+      throw new Error(`Parent directory does not exist: ${parentDir}`);
+    }
+    if (await fileExists(absPath)) {
+      throw new Error(
+        `Workspace already exists at ${absPath}. Use open_workspace to load it.`
+      );
+    }
+  }
+  const sketchRefs = [];
+  const sketchDefs = [];
+  if (input.sketches && input.sketches.length > 0) {
+    for (const sketchPath of input.sketches) {
+      const absSketchPath = state.resolvePath(sketchPath);
+      if (!await fileExists(absSketchPath)) {
+        throw new Error(`Sketch file not found: ${absSketchPath}`);
+      }
+      try {
+        const raw = await readFile(absSketchPath, "utf-8");
+        const json2 = JSON.parse(raw);
+        const def = parseGenart(json2);
+        sketchDefs.push({
+          file: basename(absSketchPath),
+          width: def.canvas.width,
+          height: def.canvas.height
+        });
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        throw new Error(`Invalid .genart file: ${absSketchPath} \u2014 ${msg}`);
+      }
+    }
+    const layout = input.arrangement ?? "grid";
+    const spacing = input.spacing ?? 200;
+    const positions = arrangePositions(sketchDefs, layout, spacing);
+    for (const p of positions) {
+      sketchRefs.push({ file: p.file, position: p.position });
+    }
+  }
+  const viewport = computeViewport(
+    sketchRefs.map((r) => {
+      const def = sketchDefs.find((d) => d.file === r.file);
+      return { position: r.position, width: def?.width, height: def?.height };
+    })
+  );
+  const ts = now();
+  const ws = {
+    "genart-workspace": "1.0",
+    id: kebabify(input.title),
+    title: input.title,
+    created: ts,
+    modified: ts,
+    viewport,
+    sketches: sketchRefs
+  };
+  const json = serializeWorkspace(ws);
+  if (state.remoteMode) {
+    state.workspacePath = absPath;
+    state.workspace = ws;
+    state.sketches.clear();
+    state.selection.clear();
+    state.emitMutation("workspace:loaded", { path: absPath, title: ws.title });
+  } else {
+    await writeFile(absPath, json, "utf-8");
+    await state.loadWorkspace(absPath);
+  }
+  state.emitMutation("workspace:updated", { path: absPath });
+  return {
+    success: true,
+    path: absPath,
+    title: input.title,
+    sketchCount: sketchRefs.length,
+    viewport,
+    fileContent: json
+  };
+}
+async function openWorkspace(state, input) {
+  const absPath = state.resolvePath(input.path);
+  if (!absPath.endsWith(".genart-workspace")) {
+    throw new Error("Path must end with .genart-workspace");
+  }
+  if (!await fileExists(absPath)) {
+    throw new Error(`Workspace not found: ${absPath}`);
+  }
+  try {
+    await state.loadWorkspace(absPath);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (msg.includes("not found") || msg.includes("ENOENT")) {
+      throw e;
+    }
+    throw new Error(`Invalid workspace file: ${absPath} \u2014 ${msg}`);
+  }
+  const ws = state.requireWorkspace();
+  const sketches = ws.sketches.map((ref) => {
+    const loaded = state.getSketch(
+      // Find by filename match
+      [...state.sketches.entries()].find(
+        ([, v]) => basename(v.path) === ref.file
+      )?.[0] ?? ""
+    );
+    const def = loaded?.definition;
+    return {
+      file: ref.file,
+      position: ref.position,
+      label: ref.label,
+      id: def?.id,
+      title: def?.title,
+      renderer: def?.renderer ? { type: def.renderer.type, version: def.renderer.version } : void 0,
+      canvas: def?.canvas ? { width: def.canvas.width, height: def.canvas.height } : void 0,
+      locked: ref.locked ?? false,
+      visible: ref.visible ?? true
+    };
+  });
+  state.emitMutation("workspace:updated", { path: absPath });
+  return {
+    success: true,
+    path: absPath,
+    id: ws.id,
+    title: ws.title,
+    viewport: ws.viewport,
+    sketchCount: ws.sketches.length,
+    sketches,
+    groups: ws.groups ?? []
+  };
+}
+async function addSketchToWorkspace(state, input) {
+  const ws = state.requireWorkspace();
+  const absSketchPath = state.resolvePath(input.sketchPath);
+  if (!await fileExists(absSketchPath)) {
+    throw new Error(`Sketch file not found: ${absSketchPath}`);
+  }
+  const file = basename(absSketchPath);
+  if (ws.sketches.some((s) => s.file === file)) {
+    throw new Error(
+      `Sketch '${file}' is already in the workspace`
+    );
+  }
+  let def;
+  try {
+    def = await state.loadSketch(absSketchPath);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`Invalid .genart file: ${absSketchPath} \u2014 ${msg}`);
+  }
+  const position = input.position ?? autoPosition(ws, def);
+  const newRef = {
+    file,
+    position,
+    ...input.label ? { label: input.label } : {}
+  };
+  state.workspace = {
+    ...ws,
+    modified: now(),
+    sketches: [...ws.sketches, newRef]
+  };
+  await state.saveWorkspace();
+  state.emitMutation("workspace:updated", { added: file });
+  return {
+    success: true,
+    file,
+    id: def.id,
+    title: def.title,
+    position,
+    sketchCount: state.workspace.sketches.length
+  };
+}
+function autoPosition(ws, def) {
+  if (ws.sketches.length === 0) return { x: 0, y: 0 };
+  let maxRight = -Infinity;
+  for (const s of ws.sketches) {
+    const right = s.position.x + 1200;
+    if (right > maxRight) maxRight = right;
+  }
+  return { x: maxRight + 200, y: 0 };
+}
+async function removeSketchFromWorkspace(state, input) {
+  const ws = state.requireWorkspace();
+  const loaded = state.getSketch(input.sketchId);
+  if (!loaded) {
+    throw new Error(`Sketch not found: '${input.sketchId}'`);
+  }
+  const file = basename(loaded.path);
+  const hadSketch = ws.sketches.some((s) => s.file === file);
+  if (!hadSketch) {
+    throw new Error(`Sketch '${input.sketchId}' is not in the workspace`);
+  }
+  const newSketches = ws.sketches.filter((s) => s.file !== file);
+  const newGroups = ws.groups?.map((g) => ({
+    ...g,
+    sketchFiles: g.sketchFiles.filter((f) => f !== file)
+  })).filter((g) => g.sketchFiles.length > 0);
+  state.workspace = {
+    ...ws,
+    modified: now(),
+    sketches: newSketches,
+    ...newGroups && newGroups.length > 0 ? { groups: newGroups } : {}
+  };
+  state.sketches.delete(input.sketchId);
+  state.selection.delete(input.sketchId);
+  if (input.deleteFile) {
+    const { unlink: unlink2 } = await import("fs/promises");
+    try {
+      await unlink2(loaded.path);
+    } catch {
+    }
+  }
+  await state.saveWorkspace();
+  state.emitMutation("workspace:updated", { removed: file });
+  return {
+    success: true,
+    removedId: input.sketchId,
+    removedFile: file,
+    fileDeleted: input.deleteFile ?? false,
+    sketchCount: state.workspace.sketches.length
+  };
+}
+async function listWorkspaceSketches(state, input) {
+  const ws = state.requireWorkspace();
+  const sketches = ws.sketches.map((ref) => {
+    const loaded = [...state.sketches.values()].find(
+      (v) => basename(v.path) === ref.file
+    );
+    const def = loaded?.definition;
+    const entry = {
+      file: ref.file,
+      position: ref.position,
+      label: ref.label,
+      id: def?.id,
+      title: def?.title,
+      renderer: def?.renderer.type,
+      canvas: def ? { width: def.canvas.width, height: def.canvas.height } : void 0,
+      parameterCount: def?.parameters.length ?? 0,
+      colorCount: def?.colors.length ?? 0,
+      locked: ref.locked ?? false,
+      visible: ref.visible ?? true
+    };
+    if (input.includeState && def) {
+      entry.state = def.state;
+    }
+    return entry;
+  });
+  return {
+    success: true,
+    workspace: {
+      id: ws.id,
+      title: ws.title,
+      path: state.workspacePath
+    },
+    sketchCount: sketches.length,
+    sketches
+  };
+}
+
+// src/tools/sketch.ts
+import { writeFile as writeFile2, stat as stat2, unlink } from "fs/promises";
+import { basename as basename2, dirname as dirname2, resolve } from "path";
+import {
+  createDefaultRegistry,
+  resolvePreset,
+  serializeGenart,
+  serializeWorkspace as serializeWorkspace2
+} from "@genart-dev/core";
+var VALID_RENDERERS = [
+  "p5",
+  "three",
+  "glsl",
+  "canvas2d",
+  "svg"
+];
+var KEBAB_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function now2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+async function fileExists2(path) {
+  try {
+    await stat2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validateRendererType(type) {
+  if (!VALID_RENDERERS.includes(type)) {
+    throw new Error(
+      `Unknown renderer type: '${type}'. Valid types: ${VALID_RENDERERS.join(", ")}`
+    );
+  }
+}
+function validateKebabId(id) {
+  if (!KEBAB_RE.test(id)) {
+    throw new Error(
+      "ID must be kebab-case: lowercase letters, numbers, hyphens"
+    );
+  }
+}
+function validateParameters(parameters) {
+  const keys = /* @__PURE__ */ new Set();
+  for (const p of parameters) {
+    if (keys.has(p.key)) {
+      throw new Error(`Duplicate parameter key: '${p.key}'`);
+    }
+    keys.add(p.key);
+    if (p.default < p.min || p.default > p.max) {
+      throw new Error(
+        `Parameter '${p.key}' default (${p.default}) outside range [${p.min}, ${p.max}]`
+      );
+    }
+  }
+}
+function resolveCanvas(canvas) {
+  if (!canvas) {
+    return resolvePreset("square-1200");
+  }
+  if (canvas.preset) {
+    return resolvePreset(canvas.preset);
+  }
+  return {
+    width: canvas.width ?? 1200,
+    height: canvas.height ?? 1200
+  };
+}
+function buildState(parameters, colors, seed) {
+  const params = {};
+  for (const p of parameters) {
+    params[p.key] = p.default;
+  }
+  const colorPalette = colors.map((c) => c.default);
+  return { seed, params, colorPalette };
+}
+async function createSketch(state, input) {
+  const absPath = state.resolvePath(input.path);
+  if (!absPath.endsWith(".genart")) {
+    throw new Error("Path must end with .genart");
+  }
+  validateKebabId(input.id);
+  if (!state.remoteMode && await fileExists2(absPath)) {
+    throw new Error(
+      `File already exists at ${absPath}. Use update_sketch or fork_sketch.`
+    );
+  }
+  const rendererType = input.renderer ?? "p5";
+  validateRendererType(rendererType);
+  const canvasDims = resolveCanvas(input.canvas);
+  const parameters = input.parameters ?? [];
+  const colors = input.colors ?? [];
+  if (parameters.length > 0) {
+    validateParameters(parameters);
+  }
+  let algorithm = input.algorithm;
+  if (!algorithm) {
+    const registry4 = createDefaultRegistry();
+    const adapter = registry4.resolve(rendererType);
+    algorithm = adapter.getAlgorithmTemplate();
+  }
+  const seed = input.seed ?? Math.floor(Math.random() * 1e5);
+  const ts = now2();
+  const sketch = {
+    genart: "1.1",
+    id: input.id,
+    title: input.title,
+    created: ts,
+    modified: ts,
+    renderer: { type: rendererType, version: "1.x" },
+    canvas: canvasDims,
+    parameters,
+    colors,
+    state: buildState(parameters, colors, seed),
+    algorithm,
+    ...input.philosophy ? { philosophy: input.philosophy } : {},
+    ...input.themes && input.themes.length > 0 ? { themes: input.themes } : {},
+    ...input.skills && input.skills.length > 0 ? { skills: input.skills } : {},
+    ...input.agent ? { agent: input.agent } : {},
+    ...input.model ? { model: input.model } : {}
+  };
+  const json = serializeGenart(sketch);
+  if (!state.remoteMode) {
+    await writeFile2(absPath, json, "utf-8");
+  }
+  state.sketches.set(input.id, { definition: sketch, path: absPath });
+  state.emitMutation("sketch:created", { id: input.id, path: absPath });
+  if (state.remoteMode && !input.addToWorkspace) {
+    const file = basename2(absPath);
+    if (!state.workspace) {
+      const ts2 = now2();
+      state.workspace = {
+        "genart-workspace": "1.0",
+        id: "session",
+        title: "genart.dev",
+        created: ts2,
+        modified: ts2,
+        viewport: { x: 0, y: 0, zoom: 1 },
+        sketches: [{ file, position: { x: 0, y: 0 } }]
+      };
+      state.workspacePath = state.resolvePath("workspace.genart-workspace");
+      state.emitMutation("workspace:loaded", { path: state.workspacePath, title: state.workspace.title });
+    } else {
+      let maxRight = 0;
+      for (const s of state.workspace.sketches) {
+        const right = s.position.x + 1200;
+        if (right > maxRight) maxRight = right;
+      }
+      state.workspace = {
+        ...state.workspace,
+        modified: now2(),
+        sketches: [...state.workspace.sketches, { file, position: { x: maxRight + 200, y: 0 } }]
+      };
+      state.emitMutation("workspace:updated", { added: file });
+    }
+  }
+  let workspaceContent;
+  if (input.addToWorkspace) {
+    const wsPath = state.resolvePath(input.addToWorkspace);
+    if (state.workspace && state.workspacePath === wsPath) {
+      const file = basename2(absPath);
+      const ws = state.requireWorkspace();
+      let maxRight = 0;
+      for (const s of ws.sketches) {
+        const right = s.position.x + 1200;
+        if (right > maxRight) maxRight = right;
+      }
+      const position = ws.sketches.length === 0 ? { x: 0, y: 0 } : { x: maxRight + 200, y: 0 };
+      state.workspace = {
+        ...ws,
+        modified: now2(),
+        sketches: [...ws.sketches, { file, position }]
+      };
+      workspaceContent = serializeWorkspace2(state.workspace);
+      if (!state.remoteMode) {
+        await writeFile2(wsPath, workspaceContent, "utf-8");
+      }
+      state.emitMutation("workspace:updated", { added: file });
+    }
+  }
+  return {
+    success: true,
+    path: absPath,
+    id: input.id,
+    title: input.title,
+    renderer: rendererType,
+    canvas: canvasDims,
+    seed,
+    fileContent: json,
+    ...workspaceContent ? { workspaceContent } : {}
+  };
+}
+async function openSketch(state, input) {
+  state.requireWorkspace();
+  const loaded = state.requireSketch(input.sketchId);
+  const def = loaded.definition;
+  state.setSelection([input.sketchId]);
+  state.emitMutation("selection:changed", { selected: [input.sketchId] });
+  return {
+    success: true,
+    id: def.id,
+    title: def.title,
+    renderer: def.renderer.type,
+    canvas: { width: def.canvas.width, height: def.canvas.height },
+    parameterCount: def.parameters.length,
+    colorCount: def.colors.length,
+    seed: def.state.seed,
+    philosophy: def.philosophy ?? null,
+    algorithmLength: def.algorithm.length
+  };
+}
+async function updateSketch(state, input) {
+  state.requireWorkspace();
+  const loaded = state.requireSketch(input.sketchId);
+  const def = loaded.definition;
+  const updatableFields = [
+    "title",
+    "philosophy",
+    "canvas",
+    "parameters",
+    "colors",
+    "themes",
+    "seed",
+    "skills"
+  ];
+  const updated = [];
+  for (const field of updatableFields) {
+    if (input[field] !== void 0) {
+      updated.push(field);
+    }
+  }
+  if (updated.length === 0) {
+    throw new Error(
+      "No fields to update. Provide at least one of: title, philosophy, canvas, parameters, colors, themes, seed, skills"
+    );
+  }
+  if (input.parameters) {
+    validateParameters(input.parameters);
+  }
+  let canvasDims = { width: def.canvas.width, height: def.canvas.height };
+  if (input.canvas) {
+    canvasDims = resolveCanvas(input.canvas);
+  }
+  const newParams = input.parameters ?? def.parameters;
+  const newColors = input.colors ?? def.colors;
+  const newSeed = input.seed ?? def.state.seed;
+  const newState = buildState(newParams, newColors, newSeed);
+  const newDef = {
+    ...def,
+    modified: now2(),
+    canvas: canvasDims,
+    parameters: newParams,
+    colors: newColors,
+    state: newState,
+    ...input.title !== void 0 ? { title: input.title } : {},
+    ...input.philosophy !== void 0 ? { philosophy: input.philosophy } : {},
+    ...input.themes !== void 0 ? { themes: input.themes } : {},
+    ...input.seed !== void 0 ? { state: { ...newState, seed: input.seed } } : {},
+    ...input.skills !== void 0 ? { skills: input.skills } : {},
+    ...input.agent ? { agent: input.agent } : {},
+    ...input.model ? { model: input.model } : {}
+  };
+  state.sketches.set(input.sketchId, {
+    definition: newDef,
+    path: loaded.path
+  });
+  const json = serializeGenart(newDef);
+  if (!state.remoteMode) {
+    await writeFile2(loaded.path, json, "utf-8");
+  }
+  state.emitMutation("sketch:updated", { id: input.sketchId, updated });
+  return {
+    success: true,
+    sketchId: input.sketchId,
+    updated,
+    canvas: canvasDims,
+    parameterCount: newDef.parameters.length,
+    colorCount: newDef.colors.length,
+    seed: newDef.state.seed,
+    fileContent: json
+  };
+}
+async function updateAlgorithm(state, input) {
+  state.requireWorkspace();
+  const loaded = state.requireSketch(input.sketchId);
+  const def = loaded.definition;
+  if (!input.algorithm || input.algorithm.trim() === "") {
+    throw new Error("Algorithm cannot be empty");
+  }
+  const shouldValidate = input.validate !== false;
+  let validationPassed = true;
+  if (shouldValidate) {
+    const registry4 = createDefaultRegistry();
+    const adapter = registry4.resolve(def.renderer.type);
+    const result = adapter.validate(input.algorithm);
+    if (!result.valid) {
+      throw new Error(
+        `Algorithm validation failed: ${result.errors.join("; ")}`
+      );
+    }
+  }
+  const newDef = {
+    ...def,
+    modified: now2(),
+    algorithm: input.algorithm,
+    ...input.agent ? { agent: input.agent } : {},
+    ...input.model ? { model: input.model } : {}
+  };
+  state.sketches.set(input.sketchId, {
+    definition: newDef,
+    path: loaded.path
+  });
+  const json = serializeGenart(newDef);
+  if (!state.remoteMode) {
+    await writeFile2(loaded.path, json, "utf-8");
+  }
+  state.emitMutation("sketch:updated", {
+    id: input.sketchId,
+    updated: ["algorithm"]
+  });
+  return {
+    success: true,
+    sketchId: input.sketchId,
+    renderer: def.renderer.type,
+    algorithmLength: input.algorithm.length,
+    validationPassed,
+    fileContent: json
+  };
+}
+async function saveSketch(state, input) {
+  const loaded = state.requireSketch(input.sketchId);
+  const newDef = {
+    ...loaded.definition,
+    modified: now2()
+  };
+  state.sketches.set(input.sketchId, {
+    definition: newDef,
+    path: loaded.path
+  });
+  const json = serializeGenart(newDef);
+  if (!state.remoteMode) {
+    await writeFile2(loaded.path, json, "utf-8");
+  }
+  state.emitMutation("sketch:saved", { id: input.sketchId, path: loaded.path });
+  return {
+    success: true,
+    sketchId: input.sketchId,
+    path: loaded.path,
+    fileContent: json
+  };
+}
+async function forkSketch(state, input) {
+  const ws = state.requireWorkspace();
+  const source = state.requireSketch(input.sourceId);
+  const sourceDef = source.definition;
+  validateKebabId(input.newId);
+  if (state.getSketch(input.newId)) {
+    throw new Error(
+      `Sketch with ID '${input.newId}' already exists in workspace`
+    );
+  }
+  const sourceDir = dirname2(source.path);
+  const newPath = resolve(sourceDir, `${input.newId}.genart`);
+  if (await fileExists2(newPath)) {
+    throw new Error(`File already exists at ${newPath}`);
+  }
+  const mods = input.modifications ?? {};
+  let rendererType = sourceDef.renderer.type;
+  if (mods.renderer) {
+    validateRendererType(mods.renderer);
+    rendererType = mods.renderer;
+  }
+  const canvasDims = mods.canvas ? resolveCanvas(mods.canvas) : { width: sourceDef.canvas.width, height: sourceDef.canvas.height };
+  const parameters = mods.parameters ?? [...sourceDef.parameters];
+  const colors = mods.colors ?? [...sourceDef.colors];
+  const algorithm = mods.algorithm ?? sourceDef.algorithm;
+  const philosophy = mods.philosophy ?? sourceDef.philosophy;
+  const generateNewSeed = input.newSeed !== false;
+  const seed = generateNewSeed ? Math.floor(Math.random() * 1e5) : sourceDef.state.seed;
+  const title = input.title ?? `${sourceDef.title} (fork)`;
+  const ts = now2();
+  const forkedDef = {
+    genart: "1.1",
+    id: input.newId,
+    title,
+    created: ts,
+    modified: ts,
+    renderer: { type: rendererType, version: "1.x" },
+    canvas: canvasDims,
+    parameters,
+    colors,
+    state: buildState(parameters, colors, seed),
+    algorithm,
+    ...philosophy ? { philosophy } : {},
+    ...sourceDef.themes ? { themes: [...sourceDef.themes] } : {},
+    ...sourceDef.skills ? { skills: [...sourceDef.skills] } : {},
+    ...input.agent ? { agent: input.agent } : {},
+    ...input.model ? { model: input.model } : {}
+  };
+  const json = serializeGenart(forkedDef);
+  if (!state.remoteMode) {
+    await writeFile2(newPath, json, "utf-8");
+  }
+  state.sketches.set(input.newId, { definition: forkedDef, path: newPath });
+  let position = input.position;
+  if (!position) {
+    const sourceRef = ws.sketches.find(
+      (s) => s.file === basename2(source.path)
+    );
+    if (sourceRef) {
+      position = {
+        x: sourceRef.position.x + sourceDef.canvas.width + 200,
+        y: sourceRef.position.y
+      };
+    } else {
+      position = { x: 0, y: 0 };
+    }
+  }
+  const file = basename2(newPath);
+  state.workspace = {
+    ...ws,
+    modified: now2(),
+    sketches: [...ws.sketches, { file, position }]
+  };
+  const workspaceJson = serializeWorkspace2(state.workspace);
+  if (!state.remoteMode) {
+    await writeFile2(state.workspacePath, workspaceJson, "utf-8");
+  }
+  state.emitMutation("sketch:created", { id: input.newId, path: newPath });
+  state.emitMutation("workspace:updated", { added: file });
+  return {
+    success: true,
+    sourceId: input.sourceId,
+    forkedSketch: {
+      id: input.newId,
+      title,
+      path: newPath,
+      renderer: rendererType,
+      canvas: canvasDims,
+      seed,
+      position
+    },
+    fileContent: json,
+    workspaceContent: workspaceJson
+  };
+}
+async function deleteSketch(state, input) {
+  const ws = state.requireWorkspace();
+  const loaded = state.requireSketch(input.sketchId);
+  const file = basename2(loaded.path);
+  const newSketches = ws.sketches.filter((s) => s.file !== file);
+  const newGroups = ws.groups?.map((g) => ({
+    ...g,
+    sketchFiles: g.sketchFiles.filter((f) => f !== file)
+  })).filter((g) => g.sketchFiles.length > 0);
+  state.workspace = {
+    ...ws,
+    modified: now2(),
+    sketches: newSketches,
+    ...newGroups && newGroups.length > 0 ? { groups: newGroups } : {}
+  };
+  state.sketches.delete(input.sketchId);
+  state.selection.delete(input.sketchId);
+  const shouldDelete = !input.keepFile;
+  if (shouldDelete) {
+    try {
+      await unlink(loaded.path);
+    } catch {
+    }
+  }
+  await state.saveWorkspace();
+  state.emitMutation("sketch:deleted", { id: input.sketchId });
+  state.emitMutation("workspace:updated", { removed: file });
+  return {
+    success: true,
+    deletedId: input.sketchId,
+    path: loaded.path,
+    fileDeleted: shouldDelete,
+    sketchCount: state.workspace.sketches.length
+  };
+}
+
+// src/tools/selection.ts
+import { basename as basename3 } from "path";
+async function getSelection(state, input) {
+  const ws = state.requireWorkspace();
+  const includeAlgorithm = input.includeAlgorithm !== false;
+  const includePhilosophy = input.includePhilosophy !== false;
+  const includeNeighbors = input.includeNeighbors === true;
+  const selected = [];
+  for (const id of state.selection) {
+    const loaded = state.getSketch(id);
+    if (!loaded) continue;
+    const def = loaded.definition;
+    const ref = ws.sketches.find((s) => s.file === basename3(loaded.path));
+    const entry = {
+      id: def.id,
+      title: def.title,
+      path: loaded.path,
+      renderer: { type: def.renderer.type, version: def.renderer.version },
+      canvas: { preset: void 0, width: def.canvas.width, height: def.canvas.height },
+      state: def.state,
+      parameters: def.parameters,
+      colors: def.colors,
+      themes: def.themes ?? [],
+      skills: def.skills ?? [],
+      position: ref?.position ?? { x: 0, y: 0 },
+      snapshotCount: def.snapshots?.length ?? 0
+    };
+    if (includePhilosophy) {
+      entry.philosophy = def.philosophy ?? null;
+    }
+    if (includeAlgorithm) {
+      entry.algorithm = def.algorithm;
+    }
+    selected.push(entry);
+  }
+  const neighbors = [];
+  if (includeNeighbors && selected.length > 0) {
+    const selectedIds = new Set(state.selection);
+    for (const ref of ws.sketches) {
+      const loaded = [...state.sketches.values()].find(
+        (v) => basename3(v.path) === ref.file
+      );
+      if (!loaded || selectedIds.has(loaded.definition.id)) continue;
+      const isNear = selected.some((sel) => {
+        const selPos = sel.position;
+        const dx = Math.abs(ref.position.x - selPos.x);
+        const dy = Math.abs(ref.position.y - selPos.y);
+        return dx <= 2e3 && dy <= 2e3;
+      });
+      if (isNear) {
+        neighbors.push({
+          id: loaded.definition.id,
+          title: loaded.definition.title,
+          renderer: loaded.definition.renderer.type,
+          position: ref.position
+        });
+      }
+    }
+  }
+  return {
+    selected,
+    workspace: {
+      id: ws.id,
+      title: ws.title,
+      sketchCount: ws.sketches.length
+    },
+    neighbors
+  };
+}
+async function selectSketch(state, input) {
+  state.requireWorkspace();
+  if (!input.sketchIds || input.sketchIds.length === 0) {
+    throw new Error("At least one sketch ID is required");
+  }
+  for (const id of input.sketchIds) {
+    state.requireSketch(id);
+  }
+  if (input.addToSelection) {
+    for (const id of input.sketchIds) {
+      state.selection.add(id);
+    }
+  } else {
+    state.setSelection(input.sketchIds);
+  }
+  const selected = [...state.selection];
+  state.emitMutation("selection:changed", { selected });
+  return {
+    success: true,
+    selected,
+    selectionCount: selected.length
+  };
+}
+async function getEditorState(state) {
+  if (!state.workspace) {
+    return {
+      hasWorkspace: false,
+      workingDirectory: state.basePath,
+      workspace: null,
+      selection: [],
+      sketches: []
+    };
+  }
+  const ws = state.workspace;
+  const sketches = [...state.sketches.values()].map((loaded) => {
+    const def = loaded.definition;
+    return {
+      id: def.id,
+      title: def.title,
+      renderer: def.renderer.type,
+      canvas: { width: def.canvas.width, height: def.canvas.height },
+      parameterCount: def.parameters.length,
+      colorCount: def.colors.length,
+      seed: def.state.seed
+    };
+  });
+  return {
+    hasWorkspace: true,
+    workingDirectory: state.basePath,
+    workspace: {
+      id: ws.id,
+      title: ws.title,
+      path: state.workspacePath,
+      sketchCount: ws.sketches.length,
+      viewport: ws.viewport,
+      groups: ws.groups ?? []
+    },
+    selection: [...state.selection],
+    sketches
+  };
+}
+
+// src/tools/parameters.ts
+import {
+  resolvePreset as resolvePreset2
+} from "@genart-dev/core";
+function now3() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var HEX_RE = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+function updateSketchInState(state, id, newDef) {
+  const loaded = state.requireSketch(id);
+  state.sketches.set(id, { definition: newDef, path: loaded.path });
+}
+async function setParameters(state, input) {
+  state.requireWorkspace();
+  const loaded = state.requireSketch(input.sketchId);
+  const def = loaded.definition;
+  const validKeys = new Set(def.parameters.map((p) => p.key));
+  const updated = [];
+  for (const [key, value] of Object.entries(input.params)) {
+    if (!validKeys.has(key)) {
+      throw new Error(
+        `Unknown parameter: '${key}'. Valid keys: ${[...validKeys].join(", ")}`
+      );
+    }
+    const paramDef = def.parameters.find((p) => p.key === key);
+    if (value < paramDef.min || value > paramDef.max) {
+      throw new Error(
+        `Parameter '${key}' value ${value} outside range [${paramDef.min}, ${paramDef.max}]`
+      );
+    }
+    updated.push(key);
+  }
+  const newParams = { ...def.state.params, ...input.params };
+  const newState = { ...def.state, params: newParams };
+  const newDef = { ...def, modified: now3(), state: newState };
+  updateSketchInState(state, input.sketchId, newDef);
+  await state.saveSketch(input.sketchId);
+  state.emitMutation("sketch:updated", { id: input.sketchId, updated: ["params"] });
+  return {
+    success: true,
+    sketchId: input.sketchId,
+    updated,
+    state: newState
+  };
+}
+async function setColors(state, input) {
+  state.requireWorkspace();
+  const loaded = state.requireSketch(input.sketchId);
+  const def = loaded.definition;
+  const colorDefs = def.colors;
+  const validKeys = new Set(colorDefs.map((c) => c.key));
+  const updated = [];
+  for (const [key, value] of Object.entries(input.colors)) {
+    if (!validKeys.has(key)) {
+      throw new Error(
+        `Unknown color: '${key}'. Valid keys: ${[...validKeys].join(", ")}`
+      );
+    }
+    if (!HEX_RE.test(value)) {
+      throw new Error(`Invalid hex color for '${key}': '${value}'`);
+    }
+    updated.push(key);
+  }
+  const newPalette = colorDefs.map((cDef) => {
+    if (input.colors[cDef.key] !== void 0) {
+      return input.colors[cDef.key];
+    }
+    const idx = colorDefs.findIndex((c) => c.key === cDef.key);
+    return def.state.colorPalette[idx] ?? cDef.default;
+  });
+  const newState = { ...def.state, colorPalette: newPalette };
+  const newDef = { ...def, modified: now3(), state: newState };
+  updateSketchInState(state, input.sketchId, newDef);
+  await state.saveSketch(input.sketchId);
+  state.emitMutation("sketch:updated", { id: input.sketchId, updated: ["colors"] });
+  return {
+    success: true,
+    sketchId: input.sketchId,
+    updated,
+    colorPalette: newPalette
+  };
+}
+async function setSeed(state, input) {
+  state.requireWorkspace();
+  const loaded = state.requireSketch(input.sketchId);
+  const def = loaded.definition;
+  const previousSeed = def.state.seed;
+  const newSeed = input.seed ?? Math.floor(Math.random() * 1e5);
+  const newState = { ...def.state, seed: newSeed };
+  const newDef = { ...def, modified: now3(), state: newState };
+  updateSketchInState(state, input.sketchId, newDef);
+  await state.saveSketch(input.sketchId);
+  state.emitMutation("sketch:updated", { id: input.sketchId, updated: ["seed"] });
+  return {
+    success: true,
+    sketchId: input.sketchId,
+    seed: newSeed,
+    previousSeed
+  };
+}
+async function setCanvasSize(state, input) {
+  state.requireWorkspace();
+  const loaded = state.requireSketch(input.sketchId);
+  const def = loaded.definition;
+  const previousCanvas = { width: def.canvas.width, height: def.canvas.height };
+  let newCanvas;
+  if (input.preset) {
+    newCanvas = resolvePreset2(input.preset);
+  } else if (input.width !== void 0 && input.height !== void 0) {
+    newCanvas = { width: input.width, height: input.height };
+  } else {
+    throw new Error("Provide either a preset or both width and height");
+  }
+  const newDef = { ...def, modified: now3(), canvas: newCanvas };
+  updateSketchInState(state, input.sketchId, newDef);
+  await state.saveSketch(input.sketchId);
+  state.emitMutation("sketch:updated", { id: input.sketchId, updated: ["canvas"] });
+  return {
+    success: true,
+    sketchId: input.sketchId,
+    canvas: newCanvas,
+    previousCanvas
+  };
+}
+async function randomizeParameters(state, input) {
+  state.requireWorkspace();
+  const loaded = state.requireSketch(input.sketchId);
+  const def = loaded.definition;
+  if (def.parameters.length === 0) {
+    throw new Error("Sketch has no parameters to randomize");
+  }
+  let paramsToRandomize = def.parameters;
+  if (input.paramKeys && input.paramKeys.length > 0) {
+    const validKeys = new Set(def.parameters.map((p) => p.key));
+    for (const key of input.paramKeys) {
+      if (!validKeys.has(key)) {
+        throw new Error(
+          `Unknown parameter: '${key}'. Valid keys: ${[...validKeys].join(", ")}`
+        );
+      }
+    }
+    const keySet = new Set(input.paramKeys);
+    paramsToRandomize = def.parameters.filter((p) => keySet.has(p.key));
+  }
+  const newParams = { ...def.state.params };
+  const randomized = [];
+  for (const paramDef of paramsToRandomize) {
+    const steps = Math.round((paramDef.max - paramDef.min) / paramDef.step);
+    const randomStep = Math.floor(Math.random() * (steps + 1));
+    newParams[paramDef.key] = paramDef.min + randomStep * paramDef.step;
+    randomized.push(paramDef.key);
+  }
+  const newSeed = input.newSeed ? Math.floor(Math.random() * 1e5) : def.state.seed;
+  const newState = { ...def.state, params: newParams, seed: newSeed };
+  const newDef = { ...def, modified: now3(), state: newState };
+  updateSketchInState(state, input.sketchId, newDef);
+  await state.saveSketch(input.sketchId);
+  state.emitMutation("sketch:updated", { id: input.sketchId, updated: ["params"] });
+  return {
+    success: true,
+    sketchId: input.sketchId,
+    randomized,
+    state: newState
+  };
+}
+
+// src/tools/arrangement.ts
+import { basename as basename4 } from "path";
+function now4() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function getSketchDimensions(state, sketchId) {
+  const loaded = state.getSketch(sketchId);
+  if (!loaded) return { width: 1200, height: 1200 };
+  return {
+    width: loaded.definition.canvas.width,
+    height: loaded.definition.canvas.height
+  };
+}
+function computeViewport2(positions) {
+  if (positions.length === 0) return { x: 0, y: 0, zoom: 1 };
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const p of positions) {
+    if (p.position.x < minX) minX = p.position.x;
+    if (p.position.y < minY) minY = p.position.y;
+    if (p.position.x + p.width > maxX) maxX = p.position.x + p.width;
+    if (p.position.y + p.height > maxY) maxY = p.position.y + p.height;
+  }
+  const centerX = (minX + maxX) / 2;
+  const centerY = (minY + maxY) / 2;
+  const totalW = maxX - minX;
+  const totalH = maxY - minY;
+  const zoom = Math.min(
+    1,
+    Math.min(1920 / (totalW + 200), 1080 / (totalH + 200))
+  );
+  return {
+    x: Math.round(centerX),
+    y: Math.round(centerY),
+    zoom: Math.round(zoom * 100) / 100
+  };
+}
+function layoutGrid(items, spacing, origin) {
+  if (items.length === 0) return [];
+  const cols = Math.ceil(Math.sqrt(items.length));
+  const maxW = Math.max(...items.map((s) => s.width));
+  const maxH = Math.max(...items.map((s) => s.height));
+  const cellW = maxW + spacing;
+  const cellH = maxH + spacing;
+  return items.map((s, i) => ({
+    id: s.id,
+    position: {
+      x: origin.x + i % cols * cellW,
+      y: origin.y + Math.floor(i / cols) * cellH
+    }
+  }));
+}
+function layoutRow(items, spacing, origin) {
+  let x = origin.x;
+  return items.map((s) => {
+    const pos = { id: s.id, position: { x, y: origin.y } };
+    x += s.width + spacing;
+    return pos;
+  });
+}
+function layoutColumn(items, spacing, origin) {
+  let y = origin.y;
+  return items.map((s) => {
+    const pos = { id: s.id, position: { x: origin.x, y } };
+    y += s.height + spacing;
+    return pos;
+  });
+}
+function layoutMasonry(items, spacing, origin) {
+  if (items.length === 0) return [];
+  const cols = Math.ceil(Math.sqrt(items.length));
+  const maxW = Math.max(...items.map((s) => s.width));
+  const cellW = maxW + spacing;
+  const columnHeights = new Array(cols).fill(0);
+  const result = [];
+  for (const item of items) {
+    let minCol = 0;
+    for (let c = 1; c < cols; c++) {
+      if (columnHeights[c] < columnHeights[minCol]) minCol = c;
+    }
+    result.push({
+      id: item.id,
+      position: {
+        x: origin.x + minCol * cellW,
+        y: origin.y + columnHeights[minCol]
+      }
+    });
+    columnHeights[minCol] += item.height + spacing;
+  }
+  return result;
+}
+var VALID_LAYOUTS = ["grid", "row", "column", "masonry"];
+function applyLayout(items, layout, spacing, origin) {
+  switch (layout) {
+    case "row":
+      return layoutRow(items, spacing, origin);
+    case "column":
+      return layoutColumn(items, spacing, origin);
+    case "masonry":
+      return layoutMasonry(items, spacing, origin);
+    case "grid":
+    default:
+      return layoutGrid(items, spacing, origin);
+  }
+}
+async function arrangeSketches(state, input) {
+  const ws = state.requireWorkspace();
+  if (!input.positions || input.positions.length === 0) {
+    throw new Error("At least one position is required");
+  }
+  for (const pos of input.positions) {
+    state.requireSketch(pos.sketchId);
+  }
+  const idToFile = /* @__PURE__ */ new Map();
+  for (const [id, loaded] of state.sketches) {
+    idToFile.set(id, basename4(loaded.path));
+  }
+  const positionMap = new Map(
+    input.positions.map((p) => [idToFile.get(p.sketchId), { x: p.x, y: p.y }])
+  );
+  const newSketches = ws.sketches.map((ref) => {
+    const newPos = positionMap.get(ref.file);
+    if (newPos) {
+      return { ...ref, position: newPos };
+    }
+    return ref;
+  });
+  const viewportItems = input.positions.map((p) => {
+    const dims = getSketchDimensions(state, p.sketchId);
+    return { position: { x: p.x, y: p.y }, width: dims.width, height: dims.height };
+  });
+  const viewport = computeViewport2(viewportItems);
+  state.workspace = { ...ws, modified: now4(), sketches: newSketches, viewport };
+  await state.saveWorkspace();
+  state.emitMutation("workspace:updated", { arranged: input.positions.length });
+  return {
+    success: true,
+    moved: input.positions.length,
+    positions: input.positions.map((p) => ({
+      id: p.sketchId,
+      position: { x: p.x, y: p.y }
+    })),
+    viewport
+  };
+}
+async function autoArrange(state, input) {
+  const ws = state.requireWorkspace();
+  const layout = input.layout ?? "grid";
+  if (!VALID_LAYOUTS.includes(layout)) {
+    throw new Error(
+      `Unknown layout: '${layout}'. Valid layouts: ${VALID_LAYOUTS.join(", ")}`
+    );
+  }
+  const spacing = input.spacing ?? 200;
+  const origin = input.origin ?? { x: 0, y: 0 };
+  let sketchIds;
+  if (input.sketchIds && input.sketchIds.length > 0) {
+    for (const id of input.sketchIds) {
+      state.requireSketch(id);
+    }
+    sketchIds = input.sketchIds;
+  } else {
+    sketchIds = [...state.sketches.keys()];
+  }
+  if (sketchIds.length === 0) {
+    throw new Error("No sketches to arrange");
+  }
+  const sortBy = input.sortBy ?? "created";
+  const sortedItems = sketchIds.map((id) => {
+    const loaded = state.requireSketch(id);
+    const def = loaded.definition;
+    return {
+      id,
+      title: def.title,
+      created: def.created,
+      modified: def.modified,
+      renderer: def.renderer.type,
+      width: def.canvas.width,
+      height: def.canvas.height
+    };
+  }).sort((a, b) => {
+    switch (sortBy) {
+      case "title":
+        return a.title.localeCompare(b.title);
+      case "modified":
+        return a.modified.localeCompare(b.modified);
+      case "renderer":
+        return a.renderer.localeCompare(b.renderer);
+      case "created":
+      default:
+        return a.created.localeCompare(b.created);
+    }
+  });
+  const arranged = applyLayout(sortedItems, layout, spacing, origin);
+  const idToFile = /* @__PURE__ */ new Map();
+  for (const [id, loaded] of state.sketches) {
+    idToFile.set(id, basename4(loaded.path));
+  }
+  const positionMap = new Map(
+    arranged.map((a) => [idToFile.get(a.id), a.position])
+  );
+  const newSketches = ws.sketches.map((ref) => {
+    const newPos = positionMap.get(ref.file);
+    if (newPos) {
+      return { ...ref, position: newPos };
+    }
+    return ref;
+  });
+  const viewportItems = arranged.map((a) => {
+    const item = sortedItems.find((s) => s.id === a.id);
+    return { position: a.position, width: item.width, height: item.height };
+  });
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const item of viewportItems) {
+    if (item.position.x < minX) minX = item.position.x;
+    if (item.position.y < minY) minY = item.position.y;
+    if (item.position.x + item.width > maxX) maxX = item.position.x + item.width;
+    if (item.position.y + item.height > maxY) maxY = item.position.y + item.height;
+  }
+  const boundingBox = {
+    x: minX,
+    y: minY,
+    width: maxX - minX,
+    height: maxY - minY
+  };
+  const viewport = computeViewport2(viewportItems);
+  state.workspace = { ...ws, modified: now4(), sketches: newSketches, viewport };
+  await state.saveWorkspace();
+  state.emitMutation("workspace:updated", { arranged: arranged.length });
+  return {
+    success: true,
+    layout,
+    arranged: arranged.length,
+    positions: arranged.map((a) => ({
+      id: a.id,
+      position: a.position
+    })),
+    boundingBox,
+    viewport
+  };
+}
+async function groupSketches(state, input) {
+  const ws = state.requireWorkspace();
+  if (!input.sketchIds || input.sketchIds.length === 0) {
+    throw new Error("At least one sketch ID is required");
+  }
+  const sketchFiles = [];
+  for (const id of input.sketchIds) {
+    const loaded = state.requireSketch(id);
+    sketchFiles.push(basename4(loaded.path));
+  }
+  const newGroup = {
+    id: input.groupId,
+    label: input.label,
+    sketchFiles,
+    ...input.color ? { color: input.color } : {}
+  };
+  const existingGroups = ws.groups ?? [];
+  const filtered = existingGroups.filter((g) => g.id !== input.groupId);
+  const newGroups = [...filtered, newGroup];
+  state.workspace = { ...ws, modified: now4(), groups: newGroups };
+  await state.saveWorkspace();
+  state.emitMutation("workspace:updated", { groupUpdated: input.groupId });
+  return {
+    success: true,
+    group: newGroup,
+    groupCount: newGroups.length
+  };
+}
+
+// src/tools/gallery.ts
+import { readdir, readFile as readFile3, stat as stat3 } from "fs/promises";
+import { dirname as dirname3, join } from "path";
+import { parseGenart as parseGenart3 } from "@genart-dev/core";
+async function tryParseGenart(absPath) {
+  try {
+    const raw = await readFile3(absPath, "utf-8");
+    const json = JSON.parse(raw);
+    const def = parseGenart3(json);
+    return {
+      id: def.id,
+      title: def.title,
+      renderer: def.renderer.type,
+      canvas: { width: def.canvas.width, height: def.canvas.height },
+      parameterCount: def.parameters.length,
+      colorCount: def.colors.length,
+      snapshotCount: def.snapshots?.length ?? 0,
+      hasPhilosophy: !!def.philosophy,
+      skills: def.skills ?? [],
+      modified: def.modified,
+      path: absPath
+    };
+  } catch {
+    return null;
+  }
+}
+async function scanGenartFiles(dir, recursive) {
+  const results = [];
+  let entries;
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return results;
+  }
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isFile() && entry.name.endsWith(".genart")) {
+      results.push(fullPath);
+    } else if (recursive && entry.isDirectory()) {
+      const sub = await scanGenartFiles(fullPath, true);
+      results.push(...sub);
+    }
+  }
+  return results;
+}
+async function listSketches(state, input) {
+  const dir = input.directory ? state.resolvePath(input.directory) : state.workspacePath ? dirname3(state.workspacePath) : null;
+  if (!dir) {
+    throw new Error("No workspace is currently open and no directory specified");
+  }
+  try {
+    const s = await stat3(dir);
+    if (!s.isDirectory()) {
+      throw new Error(`Not a directory: '${dir}'`);
+    }
+  } catch (e) {
+    if (e instanceof Error && e.message.startsWith("Not a directory")) throw e;
+    throw new Error(`Directory does not exist: '${dir}'`);
+  }
+  const recursive = input.recursive ?? false;
+  const includeUnreferenced = input.includeUnreferenced !== false;
+  const wsFiles = /* @__PURE__ */ new Set();
+  if (state.workspace) {
+    for (const ref of state.workspace.sketches) {
+      const absPath = state.resolveSketchPath(ref.file);
+      wsFiles.add(absPath);
+    }
+  }
+  const genartFiles = await scanGenartFiles(dir, recursive);
+  const sketches = [];
+  for (const filePath of genartFiles) {
+    const inWorkspace = wsFiles.has(filePath);
+    if (!includeUnreferenced && !inWorkspace) continue;
+    const info = await tryParseGenart(filePath);
+    if (!info) continue;
+    sketches.push({
+      id: info.id,
+      title: info.title,
+      renderer: info.renderer,
+      canvas: info.canvas,
+      parameterCount: info.parameterCount,
+      colorCount: info.colorCount,
+      path: info.path,
+      inWorkspace,
+      modified: info.modified
+    });
+  }
+  const inWorkspaceCount = sketches.filter(
+    (s) => s.inWorkspace
+  ).length;
+  return {
+    success: true,
+    directory: dir,
+    sketches,
+    total: sketches.length,
+    inWorkspace: inWorkspaceCount,
+    unreferenced: sketches.length - inWorkspaceCount
+  };
+}
+async function searchSketches(state, input) {
+  state.requireWorkspace();
+  const hasFilter = input.query !== void 0 || input.renderer !== void 0 || input.minParameters !== void 0 || input.maxParameters !== void 0 || input.canvasWidth !== void 0 || input.canvasHeight !== void 0 || input.hasPhilosophy !== void 0 || input.skills !== void 0 && input.skills.length > 0;
+  if (!hasFilter) {
+    throw new Error("At least one search filter is required");
+  }
+  const matches = [];
+  const filters = {};
+  if (input.query !== void 0) filters.query = input.query;
+  if (input.renderer !== void 0) filters.renderer = input.renderer;
+  if (input.minParameters !== void 0) filters.minParameters = input.minParameters;
+  if (input.maxParameters !== void 0) filters.maxParameters = input.maxParameters;
+  if (input.canvasWidth !== void 0) filters.canvasWidth = input.canvasWidth;
+  if (input.canvasHeight !== void 0) filters.canvasHeight = input.canvasHeight;
+  if (input.hasPhilosophy !== void 0) filters.hasPhilosophy = input.hasPhilosophy;
+  if (input.skills !== void 0) filters.skills = input.skills;
+  for (const [, loaded] of state.sketches) {
+    const def = loaded.definition;
+    if (input.query !== void 0) {
+      if (!def.title.toLowerCase().includes(input.query.toLowerCase())) continue;
+    }
+    if (input.renderer !== void 0) {
+      if (def.renderer.type !== input.renderer) continue;
+    }
+    if (input.minParameters !== void 0) {
+      if (def.parameters.length < input.minParameters) continue;
+    }
+    if (input.maxParameters !== void 0) {
+      if (def.parameters.length > input.maxParameters) continue;
+    }
+    if (input.canvasWidth !== void 0) {
+      if (def.canvas.width !== input.canvasWidth) continue;
+    }
+    if (input.canvasHeight !== void 0) {
+      if (def.canvas.height !== input.canvasHeight) continue;
+    }
+    if (input.hasPhilosophy !== void 0) {
+      const has = !!def.philosophy;
+      if (has !== input.hasPhilosophy) continue;
+    }
+    if (input.skills !== void 0 && input.skills.length > 0) {
+      const sketchSkills = new Set(def.skills ?? []);
+      const hasAny = input.skills.some((s) => sketchSkills.has(s));
+      if (!hasAny) continue;
+    }
+    matches.push({
+      id: def.id,
+      title: def.title,
+      renderer: def.renderer.type,
+      canvas: { width: def.canvas.width, height: def.canvas.height },
+      parameterCount: def.parameters.length,
+      colorCount: def.colors.length,
+      snapshotCount: def.snapshots?.length ?? 0,
+      hasPhilosophy: !!def.philosophy,
+      skills: def.skills ?? []
+    });
+  }
+  return {
+    success: true,
+    matches,
+    total: matches.length,
+    filters
+  };
+}
+
+// src/tools/merge.ts
+import { dirname as dirname4, join as join2 } from "path";
+import { writeFile as writeFile3 } from "fs/promises";
+import {
+  serializeGenart as serializeGenart2
+} from "@genart-dev/core";
+function now5() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var VALID_STRATEGIES = ["blend", "layer", "alternate"];
+function blendParameters(sources) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const source of sources) {
+    for (const param of source.parameters) {
+      if (!seen.has(param.key)) {
+        seen.add(param.key);
+        result.push(param);
+      }
+    }
+  }
+  return result;
+}
+function layerParameters(sources) {
+  const result = [];
+  for (let i = 0; i < sources.length; i++) {
+    const source = sources[i];
+    const prefix = `source${i + 1}_`;
+    for (const param of source.parameters) {
+      result.push({
+        ...param,
+        key: `${prefix}${param.key}`,
+        label: `[${i + 1}] ${param.label}`
+      });
+    }
+  }
+  return result;
+}
+function alternateParameters(sources) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (let i = 0; i < sources.length; i += 2) {
+    const source = sources[i];
+    for (const param of source.parameters) {
+      if (!seen.has(param.key)) {
+        seen.add(param.key);
+        result.push(param);
+      }
+    }
+  }
+  return result;
+}
+function mergeColors(sources) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const source of sources) {
+    for (const color of source.colors) {
+      if (!seen.has(color.key)) {
+        seen.add(color.key);
+        result.push(color);
+      }
+    }
+  }
+  return result;
+}
+function alternateColors(sources) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (let i = 1; i < sources.length; i += 2) {
+    const source = sources[i];
+    for (const color of source.colors) {
+      if (!seen.has(color.key)) {
+        seen.add(color.key);
+        result.push(color);
+      }
+    }
+  }
+  if (result.length === 0) {
+    return mergeColors(sources);
+  }
+  return result;
+}
+async function mergeSketches(state, input) {
+  const ws = state.requireWorkspace();
+  if (!input.sourceIds || input.sourceIds.length < 2) {
+    throw new Error("At least 2 source sketches are required");
+  }
+  const strategy = input.strategy ?? "blend";
+  if (!VALID_STRATEGIES.includes(strategy)) {
+    throw new Error(
+      `Unknown merge strategy: '${strategy}'. Valid strategies: ${VALID_STRATEGIES.join(", ")}`
+    );
+  }
+  if (state.getSketch(input.newId)) {
+    throw new Error(`Sketch with ID '${input.newId}' already exists`);
+  }
+  const sources = [];
+  for (const id of input.sourceIds) {
+    const loaded = state.requireSketch(id);
+    sources.push(loaded.definition);
+  }
+  const renderer = input.renderer ?? sources[0].renderer.type;
+  const canvasWidth = input.canvas?.width ?? Math.max(...sources.map((s) => s.canvas.width));
+  const canvasHeight = input.canvas?.height ?? Math.max(...sources.map((s) => s.canvas.height));
+  let parameters;
+  let algorithm;
+  let colors;
+  switch (strategy) {
+    case "layer":
+      parameters = layerParameters(sources);
+      colors = mergeColors(sources);
+      break;
+    case "alternate":
+      parameters = alternateParameters(sources);
+      colors = alternateColors(sources);
+      break;
+    case "blend":
+    default:
+      parameters = blendParameters(sources);
+      colors = mergeColors(sources);
+      break;
+  }
+  algorithm = `// Merged from: ${input.sourceIds.join(", ")}
+// Strategy: ${strategy}
+// TODO: Write a unified algorithm combining the source concepts.
+`;
+  const philosophyParts = sources.filter((s) => s.philosophy).map((s) => `## ${s.title}
+
+${s.philosophy}`);
+  const philosophy = philosophyParts.length > 0 ? philosophyParts.join("\n\n---\n\n") : void 0;
+  const themes = [];
+  const seenThemeNames = /* @__PURE__ */ new Set();
+  for (const source of sources) {
+    for (const theme of source.themes ?? []) {
+      if (!seenThemeNames.has(theme.name)) {
+        seenThemeNames.add(theme.name);
+        themes.push(theme);
+      }
+    }
+  }
+  const skills = [...new Set(sources.flatMap((s) => s.skills ?? []))];
+  const params = {};
+  for (const p of parameters) {
+    params[p.key] = p.default;
+  }
+  const colorPalette = colors.map((c) => c.default);
+  const timestamp = now5();
+  const newDef = {
+    genart: "1.1",
+    id: input.newId,
+    title: input.title,
+    created: timestamp,
+    modified: timestamp,
+    ...skills.length > 0 ? { skills } : {},
+    renderer: { type: renderer, version: sources[0].renderer.version },
+    canvas: { width: canvasWidth, height: canvasHeight },
+    ...philosophy ? { philosophy } : {},
+    parameters,
+    colors,
+    ...themes.length > 0 ? { themes } : {},
+    state: {
+      seed: Math.floor(Math.random() * 1e5),
+      params,
+      colorPalette
+    },
+    algorithm
+  };
+  const wsDir = dirname4(state.workspacePath);
+  const fileName = `${input.newId}.genart`;
+  const filePath = join2(wsDir, fileName);
+  const json = serializeGenart2(newDef);
+  await writeFile3(filePath, json, "utf-8");
+  state.sketches.set(input.newId, { definition: newDef, path: filePath });
+  const maxX = ws.sketches.reduce(
+    (max, ref) => Math.max(max, ref.position.x),
+    0
+  );
+  const newRef = {
+    file: fileName,
+    position: { x: maxX + 1400, y: 0 }
+  };
+  state.workspace = {
+    ...ws,
+    modified: timestamp,
+    sketches: [...ws.sketches, newRef]
+  };
+  await state.saveWorkspace();
+  state.emitMutation("sketch:created", { id: input.newId });
+  const crossRenderer = sources.some((s) => s.renderer.type !== renderer);
+  return {
+    success: true,
+    sketchId: input.newId,
+    title: input.title,
+    path: filePath,
+    renderer,
+    strategy,
+    sources: input.sourceIds,
+    parameterCount: parameters.length,
+    colorCount: colors.length,
+    ...crossRenderer ? {
+      crossRendererNotice: `Source sketches use different renderers. The merged sketch targets '${renderer}' \u2014 the algorithm must be written for this renderer.`
+    } : {}
+  };
+}
+
+// src/tools/snapshot-layout.ts
+import { basename as basename7 } from "path";
+async function snapshotLayout(state, input) {
+  const ws = state.requireWorkspace();
+  const includeGroups = input.includeGroups !== false;
+  const includeState = input.includeState === true;
+  const sketches = [];
+  const rendererCounts = {};
+  for (const ref of ws.sketches) {
+    const loaded = [...state.sketches.values()].find(
+      (v) => basename7(v.path) === ref.file
+    );
+    if (!loaded) continue;
+    const def = loaded.definition;
+    const entry = {
+      id: def.id,
+      title: def.title,
+      renderer: def.renderer.type,
+      position: ref.position,
+      canvas: { width: def.canvas.width, height: def.canvas.height },
+      parameterCount: def.parameters.length,
+      colorCount: def.colors.length,
+      snapshotCount: def.snapshots?.length ?? 0,
+      locked: false,
+      visible: true
+    };
+    if (includeState) {
+      entry.state = {
+        seed: def.state.seed,
+        params: def.state.params,
+        colorPalette: def.state.colorPalette
+      };
+    }
+    sketches.push(entry);
+    const rt = def.renderer.type;
+    rendererCounts[rt] = (rendererCounts[rt] ?? 0) + 1;
+  }
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const sketch of sketches) {
+    const pos = sketch.position;
+    const canvas = sketch.canvas;
+    if (pos.x < minX) minX = pos.x;
+    if (pos.y < minY) minY = pos.y;
+    if (pos.x + canvas.width > maxX) maxX = pos.x + canvas.width;
+    if (pos.y + canvas.height > maxY) maxY = pos.y + canvas.height;
+  }
+  const boundingBox = sketches.length > 0 ? { x: minX, y: minY, width: maxX - minX, height: maxY - minY } : { x: 0, y: 0, width: 0, height: 0 };
+  const groups = [];
+  if (includeGroups && ws.groups) {
+    for (const group of ws.groups) {
+      const sketchIds = [];
+      for (const file of group.sketchFiles) {
+        const loaded = [...state.sketches.values()].find(
+          (v) => basename7(v.path) === file
+        );
+        if (loaded) {
+          sketchIds.push(loaded.definition.id);
+        }
+      }
+      groups.push({
+        id: group.id,
+        label: group.label,
+        sketchIds,
+        ...group.color ? { color: group.color } : {}
+      });
+    }
+  }
+  const result = {
+    success: true,
+    workspace: {
+      id: ws.id,
+      title: ws.title,
+      viewport: ws.viewport
+    },
+    sketches,
+    boundingBox,
+    totalSketches: sketches.length,
+    rendererBreakdown: rendererCounts
+  };
+  if (includeGroups) {
+    result.groups = groups;
+  }
+  return result;
+}
+
+// src/tools/knowledge.ts
+import { createDefaultSkillRegistry } from "@genart-dev/core";
+var registry = createDefaultSkillRegistry();
+async function listSkills(input) {
+  const skills = registry.list(input.category);
+  return {
+    success: true,
+    skills: skills.map((s) => ({
+      id: s.id,
+      name: s.name,
+      category: s.category,
+      complexity: s.complexity,
+      description: s.description
+    })),
+    total: skills.length
+  };
+}
+async function loadSkill(input) {
+  const skill = registry.get(input.skillId);
+  if (!skill) {
+    return {
+      success: false,
+      error: `Skill not found: '${input.skillId}'`,
+      skill: null
+    };
+  }
+  const skillData = {
+    id: skill.id,
+    name: skill.name,
+    category: skill.category,
+    complexity: skill.complexity,
+    description: skill.description,
+    theory: skill.theory,
+    principles: skill.principles,
+    references: skill.references,
+    suggestedParameters: skill.suggestedParameters ?? [],
+    suggestedColors: skill.suggestedColors ?? []
+  };
+  if (input.renderer && skill.examples) {
+    const example = skill.examples[input.renderer];
+    if (example) {
+      skillData["example"] = example;
+    }
+  }
+  return {
+    success: true,
+    skill: skillData
+  };
+}
+var STATIC_GUIDELINES = {
+  parameters: `## Parameter Design Guidelines
+
+- Keep parameter count between 3 and 8 for usability
+- Use intuitive ranges: 0-1 for normalized values, actual units for physical quantities
+- Set defaults that produce an interesting (not extreme) result
+- Group related parameters in tabs for complex sketches
+- Name parameters descriptively: "noiseScale" not "ns"
+- Step size should match visual sensitivity: fine for color, coarse for counts`,
+  animation: `## Animation Guidelines
+
+- Use requestAnimationFrame for smooth 60fps animation
+- Separate initialization from per-frame updates
+- Provide pause/resume control for resource management
+- Use time-based animation (not frame-count) for consistent speed
+- Consider using easing functions for natural motion
+- Keep draw loops lightweight \u2014 precompute what you can in setup`,
+  performance: `## Performance Guidelines
+
+- Only the selected artboard should run live; others should pause
+- Use offscreen rendering for thumbnails
+- Dispose WebGL contexts and GPU resources when unmounting
+- Limit particle/element counts with parameters
+- Use spatial data structures (quadtree, grid) for collision/proximity
+- Profile with Chrome DevTools before optimizing`
+};
+async function getGuidelines(input) {
+  const topic = input.topic;
+  if (STATIC_GUIDELINES[topic]) {
+    return {
+      success: true,
+      topic,
+      guidelines: STATIC_GUIDELINES[topic],
+      relatedSkills: []
+    };
+  }
+  const categoryMap = {
+    composition: "composition",
+    color: "color",
+    colours: "color",
+    layout: "composition",
+    palette: "color"
+  };
+  const category = categoryMap[topic];
+  if (!category) {
+    return {
+      success: false,
+      topic,
+      error: `No guidelines found for topic: '${topic}'. Available topics: composition, color, parameters, animation, performance`,
+      guidelines: null,
+      relatedSkills: []
+    };
+  }
+  const skills = registry.list(category);
+  const guidelines = skills.map(
+    (s) => `### ${s.name}
+
+${s.description}
+
+**Principles:**
+${s.principles.map((p) => `- ${p}`).join("\n")}`
+  ).join("\n\n---\n\n");
+  return {
+    success: true,
+    topic,
+    guidelines: `## ${category.charAt(0).toUpperCase() + category.slice(1)} Guidelines
+
+${guidelines}`,
+    relatedSkills: skills.map((s) => ({
+      id: s.id,
+      name: s.name,
+      complexity: s.complexity
+    }))
+  };
+}
+
+// src/tools/capture.ts
+import { writeFile as writeFile4 } from "fs/promises";
+import {
+  createDefaultRegistry as createDefaultRegistry2
+} from "@genart-dev/core";
+
+// src/capture/headless.ts
+var cachedModule = null;
+async function loadPuppeteer() {
+  if (!cachedModule) {
+    try {
+      const mod = await import("puppeteer");
+      cachedModule = mod.default ?? mod;
+    } catch {
+      throw new Error(
+        "Puppeteer is required for screenshot capture. Install it with: npm install puppeteer"
+      );
+    }
+  }
+  return cachedModule;
+}
+var browserInstance = null;
+async function getBrowser() {
+  if (browserInstance && browserInstance.connected) {
+    return browserInstance;
+  }
+  const puppeteer = await loadPuppeteer();
+  browserInstance = await puppeteer.launch({
+    headless: true,
+    executablePath: process.env.PUPPETEER_EXECUTABLE_PATH || void 0,
+    args: [
+      "--no-sandbox",
+      "--disable-setuid-sandbox",
+      "--disable-gpu",
+      "--disable-dev-shm-usage",
+      "--single-process"
+    ]
+  });
+  return browserInstance;
+}
+async function captureHtml(options) {
+  const { html, width, height, waitMs = 500, imageType = "png", quality } = options;
+  const browser = await getBrowser();
+  const page = await browser.newPage();
+  try {
+    await page.setViewport({ width, height, deviceScaleFactor: 1 });
+    await page.setContent(html, { waitUntil: "domcontentloaded", timeout: 3e4 });
+    await new Promise((resolve3) => setTimeout(resolve3, waitMs));
+    const buffer = await page.screenshot({
+      type: imageType,
+      clip: { x: 0, y: 0, width, height },
+      ...imageType === "jpeg" && quality !== void 0 ? { quality } : {}
+    });
+    const bytes = new Uint8Array(buffer);
+    const mimeType = imageType === "jpeg" ? "image/jpeg" : "image/png";
+    return { bytes, mimeType, width, height };
+  } finally {
+    await page.close();
+  }
+}
+async function captureHtmlMulti(options) {
+  const { html, width, height, waitMs = 500, inlineSize = 400, jpegQuality = 70 } = options;
+  const browser = await getBrowser();
+  const page = await browser.newPage();
+  try {
+    await page.setViewport({ width, height, deviceScaleFactor: 1 });
+    await page.setContent(html, { waitUntil: "domcontentloaded", timeout: 3e4 });
+    await new Promise((resolve3) => setTimeout(resolve3, waitMs));
+    const pngBuffer = await page.screenshot({
+      type: "png",
+      clip: { x: 0, y: 0, width, height }
+    });
+    const previewPng = new Uint8Array(pngBuffer);
+    const scale = Math.min(inlineSize / width, inlineSize / height, 1);
+    const inlineWidth = Math.round(width * scale);
+    const inlineHeight = Math.round(height * scale);
+    await page.setViewport({ width: inlineWidth, height: inlineHeight, deviceScaleFactor: 1 });
+    await new Promise((resolve3) => setTimeout(resolve3, 100));
+    const jpegBuffer = await page.screenshot({
+      type: "jpeg",
+      quality: jpegQuality,
+      clip: { x: 0, y: 0, width: inlineWidth, height: inlineHeight }
+    });
+    const inlineJpeg = new Uint8Array(jpegBuffer);
+    return {
+      previewPng,
+      previewWidth: width,
+      previewHeight: height,
+      inlineJpeg,
+      inlineWidth,
+      inlineHeight
+    };
+  } finally {
+    await page.close();
+  }
+}
+
+// src/tools/capture.ts
+var registry2 = createDefaultRegistry2();
+function applyOverrides(sketch, overrides) {
+  if (overrides.seed === void 0 && overrides.params === void 0) {
+    return sketch;
+  }
+  const newState = {
+    seed: overrides.seed ?? sketch.state.seed,
+    params: overrides.params ? { ...sketch.state.params, ...overrides.params } : sketch.state.params,
+    colorPalette: sketch.state.colorPalette
+  };
+  return { ...sketch, state: newState };
+}
+function generateSketchHtml(sketch, opts) {
+  const effective = applyOverrides(sketch, opts);
+  const adapter = registry2.resolve(effective.renderer.type);
+  if (!adapter) {
+    throw new Error(
+      `Unsupported renderer type: '${effective.renderer.type}'`
+    );
+  }
+  return adapter.generateStandaloneHTML(effective);
+}
+function derivePreviewPath(sketchPath) {
+  return sketchPath.replace(/\.genart$/, ".png");
+}
+async function captureScreenshot(state, input) {
+  state.requireWorkspace();
+  const target = input.target ?? "selected";
+  let sketchId;
+  if (target === "selected") {
+    if (state.selection.size === 0) {
+      throw new Error("No sketch is currently selected");
+    }
+    sketchId = [...state.selection][0];
+  } else {
+    if (!input.sketchId) {
+      throw new Error("sketchId is required when target is 'sketch'");
+    }
+    sketchId = input.sketchId;
+  }
+  const loaded = state.requireSketch(sketchId);
+  const sketch = loaded.definition;
+  try {
+    const html = generateSketchHtml(sketch, {
+      seed: input.seed,
+      params: input.params
+    });
+    const width = input.width ?? sketch.canvas.width;
+    const height = input.height ?? sketch.canvas.height;
+    const inlineSize = input.previewSize ?? 400;
+    const multi = await captureHtmlMulti({
+      html,
+      width,
+      height,
+      inlineSize
+    });
+    const previewPath = derivePreviewPath(loaded.path);
+    const metadata = await buildScreenshotMetadata(state, multi, {
+      target,
+      sketchId,
+      seed: input.seed ?? sketch.state.seed,
+      previewPath
+    });
+    const previewJpegBase64 = Buffer.from(multi.inlineJpeg).toString("base64");
+    return { metadata, previewJpegBase64 };
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`Renderer error for '${sketchId}': ${msg}`);
+  }
+}
+async function buildScreenshotMetadata(state, multi, info) {
+  const metadata = {
+    success: true,
+    target: info.target,
+    sketchId: info.sketchId,
+    width: multi.previewWidth,
+    height: multi.previewHeight,
+    seed: info.seed,
+    previewPath: info.previewPath
+  };
+  if (!state.remoteMode) {
+    await writeFile4(info.previewPath, multi.previewPng);
+    metadata.savedPreviewTo = info.previewPath;
+  }
+  return metadata;
+}
+async function captureBatch(state, input) {
+  state.requireWorkspace();
+  const ids = input.sketchIds ?? [...state.sketches.keys()];
+  if (ids.length === 0) {
+    throw new Error("No sketches to capture");
+  }
+  for (const id of ids) {
+    state.requireSketch(id);
+  }
+  const inlineSize = input.previewSize ?? 200;
+  const items = [];
+  const errors = [];
+  const promises = ids.map(async (id) => {
+    const loaded = state.requireSketch(id);
+    const sketch = loaded.definition;
+    try {
+      const html = generateSketchHtml(sketch, { seed: input.seed });
+      const width = input.width ?? sketch.canvas.width;
+      const height = input.height ?? sketch.canvas.height;
+      const multi = await captureHtmlMulti({
+        html,
+        width,
+        height,
+        inlineSize
+      });
+      const previewPath = derivePreviewPath(loaded.path);
+      const itemMetadata = await buildScreenshotMetadata(state, multi, {
+        target: "sketch",
+        sketchId: id,
+        seed: input.seed ?? sketch.state.seed,
+        previewPath
+      });
+      items.push({
+        metadata: itemMetadata,
+        inlineJpegBase64: Buffer.from(multi.inlineJpeg).toString("base64")
+      });
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      errors.push({ sketchId: id, error: msg });
+    }
+  });
+  await Promise.all(promises);
+  return {
+    metadata: {
+      success: errors.length === 0,
+      total: ids.length,
+      captured: items.length,
+      failed: errors.length,
+      errors: errors.length > 0 ? errors : void 0
+    },
+    items
+  };
+}
+
+// src/tools/export.ts
+import { createWriteStream } from "fs";
+import { stat as stat4, writeFile as writeFile5 } from "fs/promises";
+import { dirname as dirname5 } from "path";
+import archiver from "archiver";
+import {
+  createDefaultRegistry as createDefaultRegistry3,
+  serializeGenart as serializeGenart3
+} from "@genart-dev/core";
+var registry3 = createDefaultRegistry3();
+async function validateOutputPath(outputPath) {
+  const parentDir = dirname5(outputPath);
+  try {
+    const s = await stat4(parentDir);
+    if (!s.isDirectory()) {
+      throw new Error(`Parent directory does not exist: ${parentDir}`);
+    }
+  } catch (e) {
+    if (e instanceof Error && e.message.startsWith("Parent directory")) throw e;
+    throw new Error(`Parent directory does not exist: ${parentDir}`);
+  }
+  try {
+    await stat4(outputPath);
+    throw new Error(
+      `File already exists at ${outputPath}. Delete it first or use a different path.`
+    );
+  } catch (e) {
+    if (e instanceof Error && e.message.startsWith("File already exists")) throw e;
+  }
+}
+function algorithmExtension(rendererType) {
+  return rendererType === "glsl" ? ".glsl" : ".js";
+}
+function applyOverrides2(sketch, overrides) {
+  if (overrides.seed === void 0 && overrides.params === void 0) {
+    return sketch;
+  }
+  const newState = {
+    seed: overrides.seed ?? sketch.state.seed,
+    params: overrides.params ? { ...sketch.state.params, ...overrides.params } : sketch.state.params,
+    colorPalette: sketch.state.colorPalette
+  };
+  return { ...sketch, state: newState };
+}
+async function exportSketch(state, input) {
+  state.requireWorkspace();
+  const loaded = state.requireSketch(input.sketchId);
+  const sketch = applyOverrides2(loaded.definition, {
+    seed: input.seed,
+    params: input.params
+  });
+  await validateOutputPath(input.outputPath);
+  const adapter = registry3.resolve(sketch.renderer.type);
+  if (!adapter) {
+    throw new Error(
+      `Unsupported renderer type: '${sketch.renderer.type}'`
+    );
+  }
+  switch (input.format) {
+    case "html":
+      return await exportHtml(sketch, input.outputPath);
+    case "png":
+      return await exportPng(sketch, input);
+    case "svg":
+      return await exportSvg(sketch, input);
+    case "algorithm":
+      return await exportAlgorithm(sketch, input.outputPath);
+    case "zip":
+      return await exportZip(sketch, input);
+    default:
+      throw new Error(`Unsupported export format: '${input.format}'`);
+  }
+}
+async function exportHtml(sketch, outputPath) {
+  const adapter = registry3.resolve(sketch.renderer.type);
+  const html = adapter.generateStandaloneHTML(sketch);
+  const content = Buffer.from(html, "utf-8");
+  await writeFile5(outputPath, content);
+  return {
+    success: true,
+    sketchId: sketch.id,
+    format: "html",
+    outputPath,
+    fileSize: content.byteLength,
+    renderer: sketch.renderer.type
+  };
+}
+async function exportPng(sketch, input) {
+  const adapter = registry3.resolve(sketch.renderer.type);
+  const html = adapter.generateStandaloneHTML(sketch);
+  const width = input.width ?? sketch.canvas.width;
+  const height = input.height ?? sketch.canvas.height;
+  const result = await captureHtml({ html, width, height });
+  await writeFile5(input.outputPath, result.bytes);
+  return {
+    success: true,
+    sketchId: sketch.id,
+    format: "png",
+    outputPath: input.outputPath,
+    fileSize: result.bytes.byteLength,
+    renderer: sketch.renderer.type
+  };
+}
+async function exportSvg(sketch, input) {
+  const width = input.width ?? sketch.canvas.width;
+  const height = input.height ?? sketch.canvas.height;
+  if (sketch.renderer.type === "svg") {
+    const content2 = Buffer.from(sketch.algorithm, "utf-8");
+    await writeFile5(input.outputPath, content2);
+    return {
+      success: true,
+      sketchId: sketch.id,
+      format: "svg",
+      outputPath: input.outputPath,
+      fileSize: content2.byteLength,
+      renderer: sketch.renderer.type,
+      notice: null
+    };
+  }
+  const adapter = registry3.resolve(sketch.renderer.type);
+  const html = adapter.generateStandaloneHTML(sketch);
+  const result = await captureHtml({ html, width, height });
+  const b64 = Buffer.from(result.bytes).toString("base64");
+  const svg = `<?xml version="1.0" encoding="UTF-8"?>
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
+     width="${width}" height="${height}" viewBox="0 0 ${width} ${height}">
+  <image width="${width}" height="${height}"
+         href="data:image/png;base64,${b64}"/>
+</svg>`;
+  const content = Buffer.from(svg, "utf-8");
+  await writeFile5(input.outputPath, content);
+  return {
+    success: true,
+    sketchId: sketch.id,
+    format: "svg",
+    outputPath: input.outputPath,
+    fileSize: content.byteLength,
+    renderer: sketch.renderer.type,
+    notice: "Non-SVG renderer \u2014 rasterized PNG embedded in SVG container"
+  };
+}
+async function exportAlgorithm(sketch, outputPath) {
+  const content = Buffer.from(sketch.algorithm, "utf-8");
+  await writeFile5(outputPath, content);
+  return {
+    success: true,
+    sketchId: sketch.id,
+    format: "algorithm",
+    outputPath,
+    fileSize: content.byteLength,
+    renderer: sketch.renderer.type
+  };
+}
+async function exportZip(sketch, input) {
+  const adapter = registry3.resolve(sketch.renderer.type);
+  const width = input.width ?? sketch.canvas.width;
+  const height = input.height ?? sketch.canvas.height;
+  const html = adapter.generateStandaloneHTML(sketch);
+  const genartJson = serializeGenart3(sketch);
+  const algorithm = sketch.algorithm;
+  const algExt = algorithmExtension(sketch.renderer.type);
+  const captureResult = await captureHtml({ html, width, height });
+  const output = createWriteStream(input.outputPath);
+  const archive = archiver("zip", { zlib: { level: 9 } });
+  const finished = new Promise((resolve3, reject) => {
+    output.on("close", resolve3);
+    archive.on("error", reject);
+  });
+  archive.pipe(output);
+  archive.append(html, { name: `${sketch.id}.html` });
+  archive.append(Buffer.from(captureResult.bytes), { name: `${sketch.id}.png` });
+  archive.append(algorithm, { name: `${sketch.id}${algExt}` });
+  archive.append(genartJson, { name: `${sketch.id}.genart` });
+  await archive.finalize();
+  await finished;
+  const s = await stat4(input.outputPath);
+  return {
+    success: true,
+    sketchId: sketch.id,
+    format: "zip",
+    outputPath: input.outputPath,
+    fileSize: s.size,
+    renderer: sketch.renderer.type,
+    contents: [
+      `${sketch.id}.html`,
+      `${sketch.id}.png`,
+      `${sketch.id}${algExt}`,
+      `${sketch.id}.genart`
+    ]
+  };
+}
+
+// src/resources/index.ts
+import {
+  CANVAS_PRESETS,
+  createDefaultRegistry as createDefaultRegistry4,
+  createDefaultSkillRegistry as createDefaultSkillRegistry2
+} from "@genart-dev/core";
+function registerResources(server, state) {
+  registerSkillsResource(server);
+  registerCanvasPresetsResource(server);
+  registerGalleryResource(server, state);
+  registerRenderersResource(server);
+}
+function registerSkillsResource(server) {
+  const skillRegistry = createDefaultSkillRegistry2();
+  server.resource(
+    "skills",
+    "genart://skills",
+    {
+      description: "List available design knowledge skills with id, name, category, complexity, and description.",
+      mimeType: "application/json"
+    },
+    async () => {
+      const skills = skillRegistry.list().map((s) => ({
+        id: s.id,
+        name: s.name,
+        category: s.category,
+        complexity: s.complexity,
+        description: s.description
+      }));
+      return {
+        contents: [
+          {
+            uri: "genart://skills",
+            mimeType: "application/json",
+            text: JSON.stringify(
+              {
+                skills,
+                total: skills.length,
+                categories: skillRegistry.categories()
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+}
+function registerCanvasPresetsResource(server) {
+  server.resource(
+    "canvas-presets",
+    "genart://presets/canvas",
+    {
+      description: "List all built-in canvas dimension presets with id, label, category, width, and height.",
+      mimeType: "application/json"
+    },
+    async () => ({
+      contents: [
+        {
+          uri: "genart://presets/canvas",
+          mimeType: "application/json",
+          text: JSON.stringify(
+            {
+              presets: CANVAS_PRESETS.map((p) => ({
+                id: p.id,
+                label: p.label,
+                category: p.category,
+                width: p.width,
+                height: p.height
+              }))
+            },
+            null,
+            2
+          )
+        }
+      ]
+    })
+  );
+}
+function registerGalleryResource(server, state) {
+  server.resource(
+    "gallery",
+    "genart://gallery",
+    {
+      description: "List all loaded sketches in the active workspace with metadata summaries.",
+      mimeType: "application/json"
+    },
+    async () => {
+      const sketches = [...state.sketches.values()].map(({ definition, path }) => ({
+        id: definition.id,
+        title: definition.title,
+        renderer: definition.renderer,
+        canvas: definition.canvas,
+        parameterCount: definition.parameters?.length ?? 0,
+        colorCount: definition.colors?.length ?? 0,
+        hasPhilosophy: !!definition.philosophy,
+        seed: definition.seed,
+        path
+      }));
+      return {
+        contents: [
+          {
+            uri: "genart://gallery",
+            mimeType: "application/json",
+            text: JSON.stringify(
+              {
+                workspacePath: state.workspacePath,
+                sketchCount: sketches.length,
+                sketches
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+}
+function registerRenderersResource(server) {
+  const registry4 = createDefaultRegistry4();
+  server.resource(
+    "renderers",
+    "genart://renderers",
+    {
+      description: "List all available renderer types with display name, algorithm language, and runtime dependencies.",
+      mimeType: "application/json"
+    },
+    async () => {
+      const types = registry4.list();
+      const renderers = types.map((type) => {
+        const adapter = registry4.resolve(type);
+        return {
+          type: adapter.type,
+          displayName: adapter.displayName,
+          algorithmLanguage: adapter.algorithmLanguage,
+          dependencies: adapter.getRuntimeDependencies().map((dep) => ({
+            name: dep.name,
+            version: dep.version,
+            cdnUrl: dep.cdnUrl
+          }))
+        };
+      });
+      const defaultAdapter = registry4.getDefault();
+      return {
+        contents: [
+          {
+            uri: "genart://renderers",
+            mimeType: "application/json",
+            text: JSON.stringify(
+              {
+                defaultRenderer: defaultAdapter.type,
+                renderers
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/prompts/index.ts
+import { z } from "zod";
+function registerPrompts(server, state) {
+  registerCreateGenerativeArt(server);
+  registerExploreVariations(server, state);
+  registerApplyDesignTheory(server, state);
+}
+function registerCreateGenerativeArt(server) {
+  server.prompt(
+    "create-generative-art",
+    "Create a new piece of generative art with structured guidance",
+    {
+      concept: z.string().describe("The artistic concept or visual idea to explore"),
+      renderer: z.enum(["p5", "three", "glsl", "canvas2d", "svg"]).optional().describe("Renderer to use (default: p5)"),
+      complexity: z.enum(["simple", "moderate", "complex"]).optional().describe("Desired complexity level (default: moderate)"),
+      canvas: z.string().optional().describe("Canvas preset name or WxH dimensions (default: square-1200)")
+    },
+    async (args) => {
+      const renderer = args.renderer ?? "p5";
+      const complexity = args.complexity ?? "moderate";
+      const canvas = args.canvas ?? "square-1200";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: [
+                `Create a generative art sketch with the following specifications:`,
+                ``,
+                `## Concept`,
+                `${args.concept}`,
+                ``,
+                `## Technical Specifications`,
+                `- **Renderer:** ${renderer}`,
+                `- **Complexity:** ${complexity}`,
+                `- **Canvas:** ${canvas}`,
+                ``,
+                `## Steps`,
+                `1. Use \`create_sketch\` to create a new .genart file with a relative path (e.g. \`my-sketch.genart\`)`,
+                `2. Design 3\u20136 parameters that control visual variation (range sliders)`,
+                `3. Define 2\u20134 color parameters for palette control`,
+                `4. Write the algorithm that implements the concept`,
+                `5. Use \`update_algorithm\` to set the algorithm with validation`,
+                `6. Use \`capture_screenshot\` to verify the visual output`,
+                `7. Iterate on parameters and algorithm until the result matches the concept`,
+                ``,
+                `## Guidelines`,
+                `- Parameters should have meaningful ranges that produce visually distinct results`,
+                `- The algorithm should be deterministic given the same seed and parameters`,
+                `- Include a philosophy field describing the artistic intent`,
+                `- Use design principles: balance, contrast, rhythm, harmony`,
+                `- Always pass your \`agent\` name and \`model\` identifier when calling tools that create or modify sketches`,
+                complexity === "simple" ? `- Keep the algorithm under 50 lines with 2\u20133 parameters` : complexity === "complex" ? `- The algorithm can be extensive; use 5+ parameters and consider animation` : `- Aim for 30\u201380 lines with 3\u20135 parameters`
+              ].join("\n")
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+function registerExploreVariations(server, state) {
+  server.prompt(
+    "explore-variations",
+    "Explore parameter and seed variations of an existing sketch",
+    {
+      sketchId: z.string().describe("ID of the sketch to explore variations of"),
+      strategy: z.enum(["seeds", "params", "both", "extremes"]).optional().describe("Variation strategy (default: both)"),
+      count: z.string().optional().describe("Number of variations to explore (default: 6)")
+    },
+    async (args) => {
+      const strategy = args.strategy ?? "both";
+      const count = args.count ?? "6";
+      const sketch = state.getSketch(args.sketchId);
+      let sketchContext = "";
+      if (sketch) {
+        const def = sketch.definition;
+        const params = def.parameters?.map(
+          (p) => `  - ${p.key} (${p.label}): ${p.min}\u2013${p.max}, step ${p.step}, default ${p.default}`
+        ).join("\n");
+        const colors = def.colors?.map((c) => `  - ${c.key} (${c.label}): ${c.default}`).join("\n");
+        sketchContext = [
+          `## Current Sketch: "${def.title}"`,
+          `- **ID:** ${def.id}`,
+          `- **Renderer:** ${def.renderer}`,
+          `- **Canvas:** ${def.canvas.width}\xD7${def.canvas.height}`,
+          `- **Seed:** ${def.seed}`,
+          params ? `- **Parameters:**
+${params}` : `- **Parameters:** none`,
+          colors ? `- **Colors:**
+${colors}` : `- **Colors:** none`
+        ].join("\n");
+      } else {
+        sketchContext = `## Sketch: ${args.sketchId}
+*(Not currently loaded \u2014 use open_sketch or get_selection to load it first)*`;
+      }
+      const strategyInstructions = {
+        seeds: [
+          `## Strategy: Seed Exploration`,
+          `Generate ${count} variations by changing only the seed value.`,
+          `1. Use \`fork_sketch\` to create each variation with \`newSeed: true\``,
+          `2. Use \`capture_batch\` to capture all variations`,
+          `3. Compare the results and identify which seeds produce the most interesting outputs`
+        ].join("\n"),
+        params: [
+          `## Strategy: Parameter Exploration`,
+          `Generate ${count} variations by systematically varying parameters.`,
+          `1. Use \`fork_sketch\` for each variation`,
+          `2. For each fork, use \`set_parameters\` to explore different regions of the parameter space`,
+          `3. Try: minimum values, maximum values, center values, and random combinations`,
+          `4. Use \`capture_batch\` to capture all variations`
+        ].join("\n"),
+        both: [
+          `## Strategy: Combined Exploration`,
+          `Generate ${count} variations by varying both seeds and parameters.`,
+          `1. Create ${count} forks with \`fork_sketch\` (newSeed: true)`,
+          `2. For half the forks, also adjust parameters to explore different visual territories`,
+          `3. Use \`capture_batch\` to capture all variations`,
+          `4. Identify the most visually interesting combinations`
+        ].join("\n"),
+        extremes: [
+          `## Strategy: Extreme Parameter Exploration`,
+          `Generate ${count} variations by pushing parameters to their limits.`,
+          `1. Create forks with all parameters at minimum, all at maximum, and diagonal extremes`,
+          `2. Also create forks with each parameter individually at its min and max`,
+          `3. Use \`capture_batch\` to capture all variations`,
+          `4. This reveals the full range of the parameter space`
+        ].join("\n")
+      };
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: [
+                `Explore variations of an existing generative art sketch.`,
+                ``,
+                sketchContext,
+                ``,
+                strategyInstructions[strategy],
+                ``,
+                `## After Exploration`,
+                `- Use \`auto_arrange\` to lay out all variations in a grid`,
+                `- Use \`snapshot_layout\` to capture the arrangement`,
+                `- Summarize which variations are most interesting and why`,
+                ``,
+                `**Attribution:** Always pass your \`agent\` name and \`model\` identifier when calling \`fork_sketch\` and other tools that create or modify sketches.`
+              ].join("\n")
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+function registerApplyDesignTheory(server, state) {
+  server.prompt(
+    "apply-design-theory",
+    "Apply design theory concepts to improve or evolve a generative art sketch",
+    {
+      sketchId: z.string().describe("ID of the sketch to apply design theory to"),
+      theory: z.enum([
+        "gestalt",
+        "color-theory",
+        "composition",
+        "rhythm-repetition",
+        "negative-space",
+        "contrast"
+      ]).describe("Design theory to apply")
+    },
+    async (args) => {
+      const sketch = state.getSketch(args.sketchId);
+      let sketchContext = "";
+      if (sketch) {
+        const def = sketch.definition;
+        sketchContext = [
+          `## Current Sketch: "${def.title}"`,
+          `- **Renderer:** ${def.renderer}`,
+          `- **Canvas:** ${def.canvas.width}\xD7${def.canvas.height}`,
+          `- **Parameters:** ${def.parameters?.length ?? 0} defined`,
+          `- **Colors:** ${def.colors?.length ?? 0} defined`,
+          def.philosophy ? `- **Philosophy:** ${def.philosophy}` : `- **Philosophy:** not set`
+        ].join("\n");
+      } else {
+        sketchContext = `## Sketch: ${args.sketchId}
+*(Not currently loaded \u2014 use open_sketch first)*`;
+      }
+      const theoryGuides = {
+        gestalt: [
+          `## Theory: Gestalt Principles`,
+          `Apply principles of visual perception to the sketch:`,
+          `- **Proximity:** Group related elements closer together`,
+          `- **Similarity:** Make related elements share visual properties (size, color, shape)`,
+          `- **Continuity:** Align elements to create implied lines and flow`,
+          `- **Closure:** Allow the viewer's mind to complete partial shapes`,
+          `- **Figure-Ground:** Establish clear foreground/background relationships`,
+          ``,
+          `### Implementation`,
+          `1. Analyze the current algorithm for element placement patterns`,
+          `2. Add or modify parameters that control grouping, spacing, and alignment`,
+          `3. Ensure the seed produces consistent perceptual grouping`
+        ].join("\n"),
+        "color-theory": [
+          `## Theory: Color Theory`,
+          `Apply color harmony and contrast principles:`,
+          `- **Complementary:** Use colors opposite on the color wheel for high contrast`,
+          `- **Analogous:** Use adjacent colors for harmony`,
+          `- **Triadic:** Use three evenly-spaced colors for vibrancy`,
+          `- **Value contrast:** Ensure sufficient light/dark variation`,
+          `- **Saturation:** Control intensity for emphasis and depth`,
+          ``,
+          `### Implementation`,
+          `1. Review the current color definitions and themes`,
+          `2. Add color parameters that follow a chosen harmony scheme`,
+          `3. Create 2\u20133 theme presets demonstrating different harmonies`,
+          `4. Update the algorithm to use colors intentionally for depth and emphasis`
+        ].join("\n"),
+        composition: [
+          `## Theory: Composition`,
+          `Apply compositional rules for visual impact:`,
+          `- **Rule of thirds:** Place key elements at intersection points`,
+          `- **Golden ratio:** Use \u03C6 (1.618) for proportional divisions`,
+          `- **Visual weight:** Balance heavy elements with negative space`,
+          `- **Leading lines:** Direct the eye through the composition`,
+          `- **Focal point:** Establish a clear center of interest`,
+          ``,
+          `### Implementation`,
+          `1. Analyze element distribution in the current algorithm`,
+          `2. Add parameters for compositional control (focal point position, density distribution)`,
+          `3. Use mathematical ratios (thirds, golden) for element placement`,
+          `4. Test with \`capture_screenshot\` and verify visual balance`
+        ].join("\n"),
+        "rhythm-repetition": [
+          `## Theory: Rhythm & Repetition`,
+          `Apply rhythmic patterns and controlled repetition:`,
+          `- **Regular rhythm:** Equal spacing between repeated elements`,
+          `- **Alternating rhythm:** Two or more elements in sequence`,
+          `- **Progressive rhythm:** Gradual size, color, or spacing changes`,
+          `- **Random rhythm:** Organic, noise-driven variation within structure`,
+          `- **Fractal repetition:** Self-similar patterns at different scales`,
+          ``,
+          `### Implementation`,
+          `1. Identify repeating elements in the current algorithm`,
+          `2. Add parameters for rhythm type, frequency, and amplitude`,
+          `3. Layer multiple rhythmic patterns for visual complexity`,
+          `4. Use the seed to introduce controlled randomness within the rhythm`
+        ].join("\n"),
+        "negative-space": [
+          `## Theory: Negative Space`,
+          `Use emptiness as a compositional element:`,
+          `- **Active negative space:** Intentional empty areas that form shapes`,
+          `- **Breathing room:** Prevent visual overcrowding`,
+          `- **Figure-ground reversal:** Make negative space as interesting as positive`,
+          `- **Density gradients:** Transition from dense to sparse areas`,
+          ``,
+          `### Implementation`,
+          `1. Add a density/coverage parameter to control fill percentage`,
+          `2. Create regions of intentional emptiness in the algorithm`,
+          `3. Use the canvas edges and margins as compositional anchors`,
+          `4. Test at different density levels with \`capture_screenshot\``
+        ].join("\n"),
+        contrast: [
+          `## Theory: Contrast`,
+          `Apply contrast principles for visual interest:`,
+          `- **Size contrast:** Juxtapose large and small elements`,
+          `- **Color contrast:** Use complementary or value differences`,
+          `- **Shape contrast:** Mix geometric and organic forms`,
+          `- **Texture contrast:** Smooth vs. rough, dense vs. sparse`,
+          `- **Movement contrast:** Static vs. dynamic, fast vs. slow`,
+          ``,
+          `### Implementation`,
+          `1. Identify the dominant visual quality in the current algorithm`,
+          `2. Introduce its opposite as a secondary element`,
+          `3. Add parameters that control the degree of contrast`,
+          `4. Use \`fork_sketch\` to compare low-contrast and high-contrast versions`
+        ].join("\n")
+      };
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: [
+                `Apply design theory to improve a generative art sketch.`,
+                ``,
+                sketchContext,
+                ``,
+                theoryGuides[args.theory],
+                ``,
+                `## Workflow`,
+                `1. Use \`get_selection\` or \`open_sketch\` to examine the current sketch`,
+                `2. Analyze how the theory applies to the existing algorithm`,
+                `3. Use \`fork_sketch\` to create a theory-applied variant`,
+                `4. Modify the fork's algorithm and parameters using the theory principles above`,
+                `5. Use \`capture_screenshot\` to compare before and after`,
+                `6. Update the philosophy field to document the design rationale`,
+                ``,
+                `**Attribution:** Always pass your \`agent\` name and \`model\` identifier when calling tools that create or modify sketches.`
+              ].join("\n")
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/server.ts
+function jsonResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+function toolError(message) {
+  return {
+    content: [{ type: "text", text: JSON.stringify({ error: message }) }],
+    isError: true
+  };
+}
+function createServer(state) {
+  const server = new McpServer(
+    {
+      name: "@genart/mcp-server",
+      version: "0.0.1"
+    },
+    {
+      capabilities: {
+        tools: {},
+        resources: {},
+        prompts: {}
+      }
+    }
+  );
+  registerWorkspaceTools(server, state);
+  registerSketchTools(server, state);
+  registerSelectionTools(server, state);
+  registerParameterTools(server, state);
+  registerArrangementTools(server, state);
+  registerGalleryTools(server, state);
+  registerMergeTools(server, state);
+  registerSnapshotTools(server, state);
+  registerKnowledgeTools(server, state);
+  registerCaptureTools(server, state);
+  registerExportTools(server, state);
+  registerResources(server, state);
+  registerPrompts(server, state);
+  return server;
+}
+function registerWorkspaceTools(server, state) {
+  server.tool(
+    "create_workspace",
+    "Create a new .genart-workspace file with optional initial sketches",
+    {
+      title: z2.string().describe("Workspace title"),
+      path: z2.string().describe("File path (must end in .genart-workspace)"),
+      sketches: z2.array(z2.string()).optional().describe("Initial sketch file paths to include"),
+      arrangement: z2.enum(["grid", "row", "column"]).optional().describe("Auto-arrange initial sketches (default: grid)"),
+      spacing: z2.number().optional().describe("Spacing between arranged sketches in pixels (default: 200)")
+    },
+    async (args) => {
+      try {
+        const result = await createWorkspace(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "open_workspace",
+    "Open an existing .genart-workspace file and load all referenced sketches",
+    {
+      path: z2.string().describe("File path to .genart-workspace file")
+    },
+    async (args) => {
+      try {
+        const result = await openWorkspace(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "add_sketch_to_workspace",
+    "Add an existing .genart sketch file to the active workspace",
+    {
+      sketchPath: z2.string().describe("Path to the .genart file to add"),
+      position: z2.object({
+        x: z2.number().describe("X position on canvas"),
+        y: z2.number().describe("Y position on canvas")
+      }).optional().describe("Canvas position (default: auto-placed to the right)"),
+      label: z2.string().optional().describe("Display label override")
+    },
+    async (args) => {
+      try {
+        const result = await addSketchToWorkspace(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "remove_sketch_from_workspace",
+    "Remove a sketch from the active workspace (optionally delete the file)",
+    {
+      sketchId: z2.string().describe("ID of the sketch to remove"),
+      deleteFile: z2.boolean().optional().describe("Also delete the .genart file from disk (default: false)")
+    },
+    async (args) => {
+      try {
+        const result = await removeSketchFromWorkspace(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "list_workspace_sketches",
+    "List all sketches in the active workspace with metadata",
+    {
+      includeState: z2.boolean().optional().describe("Include current seed and param values (default: false)")
+    },
+    async (args) => {
+      try {
+        const result = await listWorkspaceSketches(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+}
+function registerSketchTools(server, state) {
+  server.tool(
+    "create_sketch",
+    "Create a new .genart sketch file from metadata, parameters, and algorithm",
+    {
+      id: z2.string().describe("URL-safe kebab-case identifier"),
+      title: z2.string().describe("Human-readable title"),
+      path: z2.string().describe("Relative file path (must end in .genart, e.g. 'my-sketch.genart')"),
+      renderer: z2.enum(["p5", "three", "glsl", "canvas2d", "svg"]).optional().describe("Renderer type (default: p5)"),
+      canvas: z2.object({
+        preset: z2.string().optional().describe("Canvas preset name"),
+        width: z2.number().optional().describe("Width in pixels"),
+        height: z2.number().optional().describe("Height in pixels")
+      }).optional().describe("Canvas dimensions (default: square-1200)"),
+      philosophy: z2.string().optional().describe("Markdown design philosophy"),
+      parameters: z2.array(
+        z2.object({
+          key: z2.string(),
+          label: z2.string(),
+          min: z2.number(),
+          max: z2.number(),
+          step: z2.number(),
+          default: z2.number()
+        })
+      ).optional().describe("Parameter definitions"),
+      colors: z2.array(
+        z2.object({
+          key: z2.string(),
+          label: z2.string(),
+          default: z2.string()
+        })
+      ).optional().describe("Color definitions"),
+      themes: z2.array(
+        z2.object({
+          name: z2.string(),
+          colors: z2.array(z2.string())
+        })
+      ).optional().describe("Theme presets"),
+      algorithm: z2.string().optional().describe("Algorithm source code (default: renderer template). For p5: must be `function sketch(p, state) { ... }` in instance mode. State provides: state.WIDTH, state.HEIGHT, state.SEED (number), state.PARAMS (keyed by param key), state.COLORS (keyed by color key, hex strings). Use p5 instance methods (p.createCanvas, p.background, etc)."),
+      seed: z2.number().optional().describe("Initial random seed (default: random)"),
+      skills: z2.array(z2.string()).optional().describe("Design skill references"),
+      addToWorkspace: z2.string().optional().describe("Path to workspace to add sketch to after creation"),
+      agent: z2.string().optional().describe("Your CLI agent name (e.g. 'claude-code', 'codex-cli', 'gemini-cli', 'opencode', 'kiro')"),
+      model: z2.string().optional().describe("Your AI model identifier (e.g. 'claude-opus-4-6', 'gpt-4o', 'gemini-2.5-pro')")
+    },
+    async (args) => {
+      try {
+        const result = await createSketch(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "open_sketch",
+    "Open a sketch by ID to view and edit it (sets selection)",
+    {
+      sketchId: z2.string().describe("ID of the sketch to open")
+    },
+    async (args) => {
+      try {
+        const result = await openSketch(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "update_sketch",
+    "Update metadata, parameters, colors, or canvas of an existing sketch",
+    {
+      sketchId: z2.string().describe("ID of the sketch to update"),
+      title: z2.string().optional().describe("New title"),
+      philosophy: z2.string().optional().describe("New philosophy text (markdown)"),
+      canvas: z2.object({
+        preset: z2.string().optional().describe("Canvas preset name"),
+        width: z2.number().optional().describe("Width in pixels"),
+        height: z2.number().optional().describe("Height in pixels")
+      }).optional().describe("New canvas dimensions"),
+      parameters: z2.array(
+        z2.object({
+          key: z2.string(),
+          label: z2.string(),
+          min: z2.number(),
+          max: z2.number(),
+          step: z2.number(),
+          default: z2.number()
+        })
+      ).optional().describe("Replace parameter definitions"),
+      colors: z2.array(
+        z2.object({
+          key: z2.string(),
+          label: z2.string(),
+          default: z2.string()
+        })
+      ).optional().describe("Replace color definitions"),
+      themes: z2.array(
+        z2.object({
+          name: z2.string(),
+          colors: z2.array(z2.string())
+        })
+      ).optional().describe("Replace theme presets"),
+      seed: z2.number().optional().describe("New random seed"),
+      skills: z2.array(z2.string()).optional().describe("Replace design skill references"),
+      agent: z2.string().optional().describe("Your CLI agent name (e.g. 'claude-code', 'codex-cli', 'gemini-cli', 'opencode', 'kiro')"),
+      model: z2.string().optional().describe("Your AI model identifier (e.g. 'claude-opus-4-6', 'gpt-4o', 'gemini-2.5-pro')")
+    },
+    async (args) => {
+      try {
+        const result = await updateSketch(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "update_algorithm",
+    "Replace the algorithm source code of a sketch",
+    {
+      sketchId: z2.string().describe("ID of the sketch to update"),
+      algorithm: z2.string().describe("New algorithm source code. For p5: must be `function sketch(p, state) { ... }` in instance mode. State provides: state.WIDTH, state.HEIGHT, state.SEED, state.PARAMS (keyed by param key), state.COLORS (keyed by color key)."),
+      validate: z2.boolean().optional().describe("Run renderer-specific validation before saving (default: true)"),
+      agent: z2.string().optional().describe("Your CLI agent name (e.g. 'claude-code', 'codex-cli', 'gemini-cli', 'opencode', 'kiro')"),
+      model: z2.string().optional().describe("Your AI model identifier (e.g. 'claude-opus-4-6', 'gpt-4o', 'gemini-2.5-pro')")
+    },
+    async (args) => {
+      try {
+        const result = await updateAlgorithm(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "save_sketch",
+    "Persist the current in-memory state of a sketch to disk",
+    {
+      sketchId: z2.string().describe("ID of the sketch to save")
+    },
+    async (args) => {
+      try {
+        const result = await saveSketch(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "fork_sketch",
+    "Create a variant of an existing sketch with a new ID and optional modifications",
+    {
+      sourceId: z2.string().describe("ID of the sketch to fork"),
+      newId: z2.string().describe("URL-safe kebab-case ID for the forked sketch"),
+      title: z2.string().optional().describe("Title for the fork (default: '[source title] (fork)')"),
+      position: z2.object({
+        x: z2.number().describe("X position on canvas"),
+        y: z2.number().describe("Y position on canvas")
+      }).optional().describe("Canvas position (default: auto-placed to the right of source)"),
+      modifications: z2.object({
+        renderer: z2.enum(["p5", "three", "glsl", "canvas2d", "svg"]).optional(),
+        canvas: z2.object({
+          preset: z2.string().optional(),
+          width: z2.number().optional(),
+          height: z2.number().optional()
+        }).optional(),
+        parameters: z2.array(
+          z2.object({
+            key: z2.string(),
+            label: z2.string(),
+            min: z2.number(),
+            max: z2.number(),
+            step: z2.number(),
+            default: z2.number()
+          })
+        ).optional(),
+        colors: z2.array(
+          z2.object({
+            key: z2.string(),
+            label: z2.string(),
+            default: z2.string()
+          })
+        ).optional(),
+        algorithm: z2.string().optional(),
+        philosophy: z2.string().optional()
+      }).optional().describe("Fields to override in the fork"),
+      newSeed: z2.boolean().optional().describe("Generate a new random seed for the fork (default: true)"),
+      agent: z2.string().optional().describe("Your CLI agent name (e.g. 'claude-code', 'codex-cli', 'gemini-cli', 'opencode', 'kiro')"),
+      model: z2.string().optional().describe("Your AI model identifier (e.g. 'claude-opus-4-6', 'gpt-4o', 'gemini-2.5-pro')")
+    },
+    async (args) => {
+      try {
+        const result = await forkSketch(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "delete_sketch",
+    "Delete a sketch file from disk and remove it from the workspace",
+    {
+      sketchId: z2.string().describe("ID of the sketch to delete"),
+      keepFile: z2.boolean().optional().describe("Keep the .genart file on disk (default: false)")
+    },
+    async (args) => {
+      try {
+        const result = await deleteSketch(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+}
+function registerSelectionTools(server, state) {
+  server.tool(
+    "get_selection",
+    "Return full context for the currently selected sketch(es) on the canvas",
+    {
+      includeAlgorithm: z2.boolean().optional().describe("Include full algorithm source (default: true)"),
+      includePhilosophy: z2.boolean().optional().describe("Include philosophy markdown (default: true)"),
+      includeNeighbors: z2.boolean().optional().describe("Include summaries of adjacent sketches (default: false)")
+    },
+    async (args) => {
+      try {
+        const result = await getSelection(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "select_sketch",
+    "Set the canvas selection to one or more sketches by ID",
+    {
+      sketchIds: z2.array(z2.string()).describe("IDs of sketches to select"),
+      addToSelection: z2.boolean().optional().describe("Add to existing selection instead of replacing (default: false)")
+    },
+    async (args) => {
+      try {
+        const result = await selectSketch(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "get_editor_state",
+    "Return a full snapshot of the MCP server's current state",
+    {},
+    async () => {
+      try {
+        const result = await getEditorState(state);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "set_working_directory",
+    "Set the working directory for file operations. All paths are resolved relative to this directory.",
+    {
+      path: z2.string().describe("Absolute path to use as the working directory")
+    },
+    async (args) => {
+      try {
+        const dir = args.path;
+        if (!dir.startsWith("/")) {
+          return toolError("Path must be absolute");
+        }
+        state.setBasePath(dir);
+        return jsonResult({ success: true, workingDirectory: dir });
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+}
+function registerParameterTools(server, state) {
+  server.tool(
+    "set_parameters",
+    "Update the runtime parameter values of a sketch's current state",
+    {
+      sketchId: z2.string().describe("ID of the sketch to update"),
+      params: z2.record(z2.number()).describe("Parameter key-value pairs to set")
+    },
+    async (args) => {
+      try {
+        const result = await setParameters(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "set_colors",
+    "Update the runtime color palette values of a sketch's current state",
+    {
+      sketchId: z2.string().describe("ID of the sketch to update"),
+      colors: z2.record(z2.string()).describe("Color key-value pairs to set (hex strings)")
+    },
+    async (args) => {
+      try {
+        const result = await setColors(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "set_seed",
+    "Set the random seed of a sketch, optionally generating a random value",
+    {
+      sketchId: z2.string().describe("ID of the sketch to update"),
+      seed: z2.number().optional().describe("Explicit seed value (default: generate random 0\u201399999)")
+    },
+    async (args) => {
+      try {
+        const result = await setSeed(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "set_canvas_size",
+    "Change the canvas dimensions of a sketch using a preset or explicit width/height",
+    {
+      sketchId: z2.string().describe("ID of the sketch to update"),
+      preset: z2.string().optional().describe("Canvas preset name"),
+      width: z2.number().optional().describe("Explicit width in pixels"),
+      height: z2.number().optional().describe("Explicit height in pixels")
+    },
+    async (args) => {
+      try {
+        const result = await setCanvasSize(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "randomize_parameters",
+    "Generate random values for all or specific parameters within their defined ranges",
+    {
+      sketchId: z2.string().describe("ID of the sketch to randomize"),
+      paramKeys: z2.array(z2.string()).optional().describe("Specific parameter keys to randomize (default: all)"),
+      newSeed: z2.boolean().optional().describe("Also randomize the seed (default: false)")
+    },
+    async (args) => {
+      try {
+        const result = await randomizeParameters(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+}
+function registerArrangementTools(server, state) {
+  server.tool(
+    "arrange_sketches",
+    "Move specific sketches to explicit positions on the canvas",
+    {
+      positions: z2.array(
+        z2.object({
+          sketchId: z2.string().describe("ID of the sketch to move"),
+          x: z2.number().describe("X position on canvas"),
+          y: z2.number().describe("Y position on canvas")
+        })
+      ).describe("Explicit position assignments")
+    },
+    async (args) => {
+      try {
+        const result = await arrangeSketches(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "auto_arrange",
+    "Automatically lay out all or selected sketches using a configurable layout algorithm",
+    {
+      layout: z2.enum(["grid", "row", "column", "masonry"]).optional().describe("Layout algorithm (default: grid)"),
+      sketchIds: z2.array(z2.string()).optional().describe("Specific sketches to arrange (default: all)"),
+      spacing: z2.number().optional().describe("Gap between sketches in pixels (default: 200)"),
+      sortBy: z2.enum(["title", "created", "modified", "renderer"]).optional().describe("Sort order before arranging (default: created)"),
+      origin: z2.object({
+        x: z2.number().describe("X origin"),
+        y: z2.number().describe("Y origin")
+      }).optional().describe("Top-left origin for the arrangement (default: {x:0, y:0})")
+    },
+    async (args) => {
+      try {
+        const result = await autoArrange(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "group_sketches",
+    "Create or update a named group of sketches in the workspace",
+    {
+      groupId: z2.string().describe("Unique group identifier"),
+      label: z2.string().describe("Display label for the group"),
+      sketchIds: z2.array(z2.string()).describe("IDs of sketches to include in the group"),
+      color: z2.string().optional().describe("Optional group color (hex string)")
+    },
+    async (args) => {
+      try {
+        const result = await groupSketches(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+}
+function registerGalleryTools(server, state) {
+  server.tool(
+    "list_sketches",
+    "Scan the workspace directory for all .genart files with metadata summaries",
+    {
+      directory: z2.string().optional().describe("Directory to scan (default: workspace directory)"),
+      recursive: z2.boolean().optional().describe("Scan subdirectories (default: false)"),
+      includeUnreferenced: z2.boolean().optional().describe(
+        "Include files not in the active workspace (default: true)"
+      )
+    },
+    async (args) => {
+      try {
+        const result = await listSketches(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "search_sketches",
+    "Search loaded sketches by title, renderer, parameters, canvas size, or skills",
+    {
+      query: z2.string().optional().describe("Substring match against sketch title (case-insensitive)"),
+      renderer: z2.enum(["p5", "three", "glsl", "canvas2d", "svg"]).optional().describe("Filter by renderer type"),
+      minParameters: z2.number().optional().describe("Minimum number of parameters"),
+      maxParameters: z2.number().optional().describe("Maximum number of parameters"),
+      canvasWidth: z2.number().optional().describe("Exact canvas width match"),
+      canvasHeight: z2.number().optional().describe("Exact canvas height match"),
+      hasPhilosophy: z2.boolean().optional().describe("Filter by presence of philosophy text"),
+      skills: z2.array(z2.string()).optional().describe("Filter by sketches that use any of these skills")
+    },
+    async (args) => {
+      try {
+        const result = await searchSketches(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+}
+function registerMergeTools(server, state) {
+  server.tool(
+    "merge_sketches",
+    "Combine parameters, colors, and algorithm from 2+ source sketches into a new sketch",
+    {
+      sourceIds: z2.array(z2.string()).describe("IDs of 2+ source sketches to merge"),
+      newId: z2.string().describe("URL-safe kebab-case ID for the merged sketch"),
+      title: z2.string().describe("Title for the merged sketch"),
+      strategy: z2.enum(["blend", "layer", "alternate"]).optional().describe("Merge strategy (default: blend)"),
+      renderer: z2.enum(["p5", "three", "glsl", "canvas2d", "svg"]).optional().describe("Renderer for merged sketch (default: first source's renderer)"),
+      canvas: z2.object({
+        width: z2.number().optional().describe("Canvas width"),
+        height: z2.number().optional().describe("Canvas height")
+      }).optional().describe("Canvas size (default: largest source dimensions)")
+    },
+    async (args) => {
+      try {
+        const result = await mergeSketches(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+}
+function registerSnapshotTools(server, state) {
+  server.tool(
+    "snapshot_layout",
+    "Return a structural summary of the workspace layout for AI spatial reasoning",
+    {
+      includeGroups: z2.boolean().optional().describe("Include group information (default: true)"),
+      includeState: z2.boolean().optional().describe("Include current seed and param values (default: false)")
+    },
+    async (args) => {
+      try {
+        const result = await snapshotLayout(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+}
+function registerCaptureTools(server, state) {
+  server.tool(
+    "capture_screenshot",
+    "Capture a screenshot of a sketch. Returns metadata as text + a small inline JPEG image for visual review. In remote mode, metadata includes previewFileContent (base64 PNG) to Write locally.",
+    {
+      target: z2.enum(["selected", "sketch"]).optional().describe("What to capture (default: selected)"),
+      sketchId: z2.string().optional().describe("Required when target is 'sketch'"),
+      width: z2.number().optional().describe("Output width in pixels (default: sketch canvas width)"),
+      height: z2.number().optional().describe("Output height in pixels (default: sketch canvas height)"),
+      seed: z2.number().optional().describe("Override seed for this capture only"),
+      params: z2.record(z2.number()).optional().describe("Override params for this capture only"),
+      previewSize: z2.number().optional().describe("Max dimension for inline preview JPEG (default: 400)")
+    },
+    async (args) => {
+      try {
+        const result = await captureScreenshot(state, args);
+        return {
+          content: [
+            { type: "text", text: JSON.stringify(result.metadata, null, 2) },
+            { type: "image", data: result.previewJpegBase64, mimeType: "image/jpeg" }
+          ]
+        };
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "capture_batch",
+    "Capture screenshots of multiple sketches in parallel. Returns metadata as text + inline JPEG images for visual review.",
+    {
+      sketchIds: z2.array(z2.string()).optional().describe("IDs of sketches to capture (default: all)"),
+      width: z2.number().optional().describe("Override width for all captures"),
+      height: z2.number().optional().describe("Override height for all captures"),
+      seed: z2.number().optional().describe("Override seed for all captures"),
+      previewSize: z2.number().optional().describe("Max dimension for inline preview JPEGs (default: 200 for batch)")
+    },
+    async (args) => {
+      try {
+        const result = await captureBatch(state, args);
+        const content = [
+          { type: "text", text: JSON.stringify(result.metadata, null, 2) }
+        ];
+        for (const item of result.items) {
+          content.push({
+            type: "text",
+            text: JSON.stringify(item.metadata, null, 2)
+          });
+          content.push({
+            type: "image",
+            data: item.inlineJpegBase64,
+            mimeType: "image/jpeg"
+          });
+        }
+        return { content };
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+}
+function registerExportTools(server, state) {
+  server.tool(
+    "export_sketch",
+    "Export a sketch as standalone HTML, PNG, SVG, raw algorithm, or bundled ZIP",
+    {
+      sketchId: z2.string().describe("ID of the sketch to export"),
+      format: z2.enum(["html", "png", "svg", "algorithm", "zip"]).describe("Export format"),
+      outputPath: z2.string().describe("File path to write the export"),
+      width: z2.number().optional().describe("Override width for PNG/SVG export"),
+      height: z2.number().optional().describe("Override height for PNG/SVG export"),
+      seed: z2.number().optional().describe("Override seed for this export"),
+      params: z2.record(z2.number()).optional().describe("Override params for this export")
+    },
+    async (args) => {
+      try {
+        const result = await exportSketch(state, args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+}
+function registerKnowledgeTools(server, _state) {
+  server.tool(
+    "list_skills",
+    "List all available design knowledge skills (Phase 5)",
+    {
+      category: z2.string().optional().describe("Filter by skill category")
+    },
+    async (args) => {
+      try {
+        const result = await listSkills(args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "load_skill",
+    "Load a specific design knowledge skill with full content (Phase 5)",
+    {
+      skillId: z2.string().describe("ID of the skill to load"),
+      renderer: z2.enum(["p5", "three", "glsl", "canvas2d", "svg"]).optional().describe("Renderer-specific examples (default: p5)")
+    },
+    async (args) => {
+      try {
+        const result = await loadSkill(args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+  server.tool(
+    "get_guidelines",
+    "Return design guidelines and best practices for a topic (Phase 5)",
+    {
+      topic: z2.enum(["composition", "color", "parameters", "animation", "performance"]).describe("Guideline topic"),
+      renderer: z2.enum(["p5", "three", "glsl", "canvas2d", "svg"]).optional().describe("Renderer-specific guidance")
+    },
+    async (args) => {
+      try {
+        const result = await getGuidelines(args);
+        return jsonResult(result);
+      } catch (e) {
+        return toolError(e instanceof Error ? e.message : String(e));
+      }
+    }
+  );
+}
+
+// src/state.ts
+import { EventEmitter } from "events";
+import { readFile as readFile4 } from "fs/promises";
+import { dirname as dirname6, isAbsolute, resolve as resolve2 } from "path";
+
+// src/sidecar.ts
+function isSidecarMode() {
+  const modeIdx = process.argv.indexOf("--mode");
+  if (modeIdx !== -1 && process.argv[modeIdx + 1] === "sidecar") return true;
+  return process.env.GENART_SIDECAR === "1";
+}
+function notifyMutation(type, payload) {
+  if (isSidecarMode() && typeof process.send === "function") {
+    process.send({ type, payload });
+  }
+}
+
+// src/state.ts
+import {
+  parseGenart as parseGenart4,
+  parseWorkspace as parseWorkspace2,
+  serializeGenart as serializeGenart4,
+  serializeWorkspace as serializeWorkspace3
+} from "@genart-dev/core";
+import { writeFile as writeFile6 } from "fs/promises";
+var EditorState = class extends EventEmitter {
+  /** Absolute path to the active .genart-workspace file, or null. */
+  workspacePath = null;
+  /** Parsed workspace definition, or null if no workspace is open. */
+  workspace = null;
+  /** Loaded sketches keyed by sketch ID. */
+  sketches = /* @__PURE__ */ new Map();
+  /** Currently selected sketch IDs. */
+  selection = /* @__PURE__ */ new Set();
+  /**
+   * Base directory for all file operations. When set, all paths are
+   * resolved relative to this directory and constrained within it.
+   * Used by mcp-host for per-session sandboxing.
+   */
+  basePath = null;
+  /**
+   * When true, the server is running remotely and cannot access the
+   * user's local filesystem. Tools return file content in responses
+   * instead of writing to disk. Set by mcp-host for HTTP-based sessions.
+   */
+  remoteMode = false;
+  constructor(options) {
+    super();
+    if (options?.basePath) {
+      this.basePath = options.basePath;
+    }
+    if (options?.remoteMode) {
+      this.remoteMode = true;
+    }
+  }
+  /** Update the working directory / sandbox base path. */
+  setBasePath(dir) {
+    this.basePath = dir;
+  }
+  /** Resolve a file path, respecting the sandbox basePath when set. */
+  resolvePath(file) {
+    if (isAbsolute(file)) {
+      if (this.basePath && !file.startsWith(this.basePath)) {
+        throw new Error(`Path escapes sandbox: ${file}`);
+      }
+      return file;
+    }
+    if ((file.startsWith("~/") || file === "~") && !this.basePath) {
+      const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+      return resolve2(home, file.slice(2));
+    }
+    const base = this.basePath ?? process.cwd();
+    const resolved = resolve2(base, file);
+    if (this.basePath && !resolved.startsWith(this.basePath)) {
+      throw new Error(`Path escapes sandbox: ${resolved}`);
+    }
+    return resolved;
+  }
+  /** Resolve a sketch file reference (relative to workspace dir) to an absolute path. */
+  resolveSketchPath(file) {
+    if (isAbsolute(file)) {
+      if (this.basePath && !file.startsWith(this.basePath)) {
+        throw new Error(`Path escapes sandbox: ${file}`);
+      }
+      return file;
+    }
+    if (!this.workspacePath) {
+      if (this.basePath) {
+        return resolve2(this.basePath, file);
+      }
+      throw new Error("No workspace is currently open");
+    }
+    const resolved = resolve2(dirname6(this.workspacePath), file);
+    if (this.basePath && !resolved.startsWith(this.basePath)) {
+      throw new Error(`Path escapes sandbox: ${resolved}`);
+    }
+    return resolved;
+  }
+  /** Load a workspace from disk and all its referenced sketches. */
+  async loadWorkspace(absPath) {
+    if (this.basePath && !absPath.startsWith(this.basePath)) {
+      throw new Error(`Path escapes sandbox: ${absPath}`);
+    }
+    const raw = await readFile4(absPath, "utf-8");
+    const json = JSON.parse(raw);
+    const ws = parseWorkspace2(json);
+    this.workspacePath = absPath;
+    this.workspace = ws;
+    this.sketches.clear();
+    this.selection.clear();
+    for (const ref of ws.sketches) {
+      const sketchPath = this.resolveSketchPath(ref.file);
+      await this.loadSketch(sketchPath);
+    }
+    this.emitMutation("workspace:loaded", { path: absPath, title: ws.title });
+  }
+  /** Load a single sketch from disk and add it to the cache. */
+  async loadSketch(absPath) {
+    if (this.basePath && !absPath.startsWith(this.basePath)) {
+      throw new Error(`Path escapes sandbox: ${absPath}`);
+    }
+    const raw = await readFile4(absPath, "utf-8");
+    const json = JSON.parse(raw);
+    const definition = parseGenart4(json);
+    this.sketches.set(definition.id, { definition, path: absPath });
+    this.emitMutation("sketch:loaded", { id: definition.id, path: absPath });
+    return definition;
+  }
+  /** Get a loaded sketch by ID. */
+  getSketch(id) {
+    return this.sketches.get(id);
+  }
+  /** Require a loaded sketch by ID, throwing if not found. */
+  requireSketch(id) {
+    const sketch = this.sketches.get(id);
+    if (!sketch) {
+      throw new Error(`Sketch not found: '${id}'`);
+    }
+    return sketch;
+  }
+  /** Require an open workspace, throwing if none is open. */
+  requireWorkspace() {
+    if (!this.workspace) {
+      throw new Error("No workspace is currently open");
+    }
+    return this.workspace;
+  }
+  /** Remove a sketch from the in-memory cache. */
+  removeSketch(id) {
+    this.sketches.delete(id);
+    this.selection.delete(id);
+    this.emitMutation("sketch:removed", { id });
+  }
+  /** Save the active workspace to disk. */
+  async saveWorkspace() {
+    if (!this.workspace || !this.workspacePath) {
+      throw new Error("No workspace is currently open");
+    }
+    const json = serializeWorkspace3(this.workspace);
+    if (!this.remoteMode) {
+      await writeFile6(this.workspacePath, json, "utf-8");
+    }
+    this.emitMutation("workspace:saved", { path: this.workspacePath });
+  }
+  /** Save a sketch to disk. */
+  async saveSketch(id) {
+    const loaded = this.requireSketch(id);
+    const json = serializeGenart4(loaded.definition);
+    if (!this.remoteMode) {
+      await writeFile6(loaded.path, json, "utf-8");
+    }
+    this.emitMutation("sketch:saved", { id, path: loaded.path });
+  }
+  /** Update the selection and return the new set. */
+  setSelection(ids) {
+    this.selection.clear();
+    for (const id of ids) {
+      this.selection.add(id);
+    }
+    this.emitMutation("selection:changed", { ids });
+  }
+  /** Get a serializable snapshot of the full editor state. */
+  getSnapshot() {
+    const sketches = [];
+    for (const [id, loaded] of this.sketches) {
+      sketches.push({ id, definition: loaded.definition, path: loaded.path });
+    }
+    return {
+      workspacePath: this.workspacePath,
+      workspace: this.workspace,
+      sketches,
+      selection: Array.from(this.selection)
+    };
+  }
+  /** Emit a mutation event for external listeners (WebSocket broadcast, sidecar IPC). */
+  emitMutation(type, payload) {
+    this.emit("mutation", { type, payload });
+    notifyMutation(type, payload);
+  }
+};
+export {
+  EditorState,
+  createServer
+};
+//# sourceMappingURL=lib.js.map