beplus-mcp 0.25.0 → 0.26.0

package/dist/index.js

@@ -13050,6 +13050,7 @@ function loadConfig() {
   return {
     baseUrl,
     apiBase: `${baseUrl}/api/v1/mcp`,
+    canvasBase: `${baseUrl}/api/v1/canvas`,
     token,
     inlineImages,
     inlineImageMax: 4,
@@ -21200,8 +21201,9 @@ var BeplusClient = class {
     this.cfg = cfg;
   }
   cfg;
+  /** Público para os módulos de rota própria (ex.: Canvas) reaproveitarem auth, timeout e erros. */
   async request(method, path, opts = {}) {
-    const url = new URL(`${this.cfg.apiBase}${path}`);
+    const url = new URL(`${opts.base ?? this.cfg.apiBase}${path}`);
     if (opts.query) {
       for (const [k, v] of Object.entries(opts.query)) {
         if (v !== void 0 && v !== null && v !== "") url.searchParams.set(k, String(v));
@@ -23466,11 +23468,1052 @@ ${calls.map(callLine).join("\n\n")}`);
   );
 }
 
+// src/canvas/api.ts
+var PINNED_CORE_VERSION = "ca7b3b406184c7f679f555c3a008013197182b23";
+function errorRaw(err) {
+  if (!(err instanceof ApiError)) return void 0;
+  const raw = err.body?.error?.raw;
+  return raw && typeof raw === "object" ? raw : void 0;
+}
+var CanvasApi = class {
+  constructor(client, cfg) {
+    this.client = client;
+    this.cfg = cfg;
+  }
+  client;
+  cfg;
+  coreVersion = PINNED_CORE_VERSION;
+  userId = null;
+  req(method, path, opts = {}) {
+    return this.client.request(method, path, { ...opts, base: this.cfg.canvasBase });
+  }
+  /** Token do `beplus-mcp login` (OAuth) não abre `/api/v1/canvas`: só PAT. */
+  get usesPat() {
+    return this.cfg.token.startsWith("pat_");
+  }
+  /** `createdBy` dos nós que o MCP cria. Nulo seria "motor de execução" no Canvas. */
+  async me() {
+    if (!this.userId) this.userId = (await this.client.me()).userId;
+    return this.userId;
+  }
+  listBoards(kind = "board") {
+    return this.req("GET", "/boards", { query: { kind } });
+  }
+  createBoard(body) {
+    return this.req("POST", "/boards", { body });
+  }
+  snapshot(boardId2) {
+    return this.req("GET", `/boards/${boardId2}`);
+  }
+  /** Replay depois de `after`. `null` quando o servidor manda reler a foto (410). */
+  async opsAfter(boardId2, after) {
+    try {
+      const { envelopes } = await this.req("GET", `/boards/${boardId2}/ops`, {
+        query: { after }
+      });
+      return envelopes;
+    } catch (e) {
+      if (e instanceof ApiError && e.httpStatus === 410) return null;
+      throw e;
+    }
+  }
+  async commit(boardId2, ops) {
+    const send = () => this.req("POST", `/boards/${boardId2}/ops`, {
+      body: { coreVersion: this.coreVersion, ops }
+    });
+    try {
+      return await send();
+    } catch (e) {
+      const raw = errorRaw(e);
+      if (!(e instanceof ApiError) || e.httpStatus !== 409 || raw?.reason !== "core-mismatch") throw e;
+      const serverVersion = typeof raw.coreVersion === "string" ? raw.coreVersion : "";
+      if (!serverVersion || serverVersion === this.coreVersion) throw new CoreMismatchError(serverVersion);
+      this.coreVersion = serverVersion;
+      try {
+        return await send();
+      } catch (again) {
+        if (again instanceof ApiError && again.httpStatus === 409 && errorRaw(again)?.reason === "core-mismatch") {
+          throw new CoreMismatchError(String(errorRaw(again)?.coreVersion ?? ""));
+        }
+        throw again;
+      }
+    }
+  }
+  members(boardId2) {
+    return this.req("GET", `/boards/${boardId2}/members`);
+  }
+  putMember(boardId2, userId, role) {
+    return this.req("PUT", `/boards/${boardId2}/members/${userId}`, { body: { role } });
+  }
+  removeMember(boardId2, userId) {
+    return this.req("DELETE", `/boards/${boardId2}/members/${userId}`);
+  }
+  /** Só para os testes conferirem o aprendizado. */
+  get currentCoreVersion() {
+    return this.coreVersion;
+  }
+};
+var CoreMismatchError = class extends Error {
+  constructor(serverVersion) {
+    super(
+      "O servidor do Canvas recusou a vers\xE3o do canvas-core deste MCP (409 core-mismatch)" + (serverVersion ? ` e segue exigindo ${serverVersion.slice(0, 12)}` : " sem informar a vers\xE3o esperada") + ". Nada foi aplicado. Atualize o beplus-mcp (npx -y beplus-mcp@latest) ou avise o time."
+    );
+    this.serverVersion = serverVersion;
+    this.name = "CoreMismatchError";
+  }
+  serverVersion;
+};
+
+// src/canvas/catalog.ts
+var WORKFLOW_NODE_TYPE = "workflow";
+var KIND_FIELD = "kind";
+var KINDS = {
+  text: { title: "Texto", size: { w: 300, h: 160 }, data: { text: "" }, inputs: [], outputs: ["text"], main: "text" },
+  block: { title: "Bloco", size: { w: 260, h: 140 }, data: { text: "" }, inputs: [], outputs: ["text"], main: "text" },
+  prompt: {
+    title: "Prompt",
+    size: { w: 340, h: 200 },
+    data: { template: "" },
+    inputs: ["refs"],
+    outputs: ["text", "refs"],
+    dynamic: "uma entrada de texto por {{var}} do template",
+    main: "template"
+  },
+  llm: {
+    title: "Redator",
+    size: { w: 340, h: 300 },
+    data: { model: "gemini-flash", system: "", instruction: "", outputMode: "text" },
+    inputs: ["instruction", "media"],
+    outputs: ["text"],
+    main: "instruction"
+  },
+  brief: {
+    title: "Diretor",
+    size: { w: 420, h: 360 },
+    data: {
+      model: "gemini-flash",
+      sceneCount: 4,
+      aspect_ratio: "16:9",
+      secondsPerScene: 5,
+      tone: "Natural e pr\xF3ximo, como quem conta para um amigo",
+      language: "pt-BR"
+    },
+    inputs: ["briefing", "refs"],
+    outputs: ["script", "narration", "music", "scenes", "motion"]
+  },
+  narration: { title: "Narra\xE7\xE3o", size: { w: 360, h: 360 }, data: { blocks: [] }, inputs: [], outputs: ["text", "blocks"], main: "blocks" },
+  shotlist: {
+    title: "Roteiro",
+    size: { w: 780, h: 410 },
+    data: { rows: [], orphanedRows: [] },
+    inputs: ["blocks"],
+    outputs: ["shotlist"],
+    dynamic: "uma sa\xEDda shot:<ideaId> por ideia",
+    main: "rows"
+  },
+  context: { title: "Contexto", size: { w: 320, h: 220 }, data: { kitId: null }, inputs: [], outputs: ["context"] },
+  copy: {
+    title: "Textos da pe\xE7a",
+    size: { w: 340, h: 320 },
+    data: { title: "", body: "", cta: "", legal: "" },
+    inputs: [],
+    outputs: ["title", "body", "cta", "legal"],
+    main: "title"
+  },
+  media: { title: "M\xEDdia", size: { w: 320, h: 280 }, data: { items: [] }, inputs: [], outputs: ["image"], dynamic: "sa\xEDda por tipo de item (image, video, audio, file)", main: "items" },
+  image: {
+    title: "Gerador de imagem",
+    size: { w: 320, h: 380 },
+    data: { model: "google/nano-banana-2", aspect_ratio: "1:1", count: 1 },
+    inputs: ["prompt"],
+    outputs: ["image"],
+    dynamic: "refs e negative conforme o modelo"
+  },
+  video: {
+    title: "Gerador de v\xEDdeo",
+    size: { w: 360, h: 320 },
+    data: { model: "bytedance/seedance-2.0-mini", aspect_ratio: "16:9", duration: 5, generateAudio: true },
+    inputs: ["prompt"],
+    outputs: ["video"],
+    dynamic: "frame, refs e negative conforme o modelo"
+  },
+  tts: {
+    title: "Locu\xE7\xE3o",
+    size: { w: 320, h: 212 },
+    data: { model: "gemini-3.1-flash-tts-preview", voice: "Algieba", speed: "normal" },
+    inputs: ["text"],
+    outputs: ["audio", "approved"],
+    dynamic: "style conforme o modelo"
+  },
+  music: {
+    title: "Trilha",
+    size: { w: 320, h: 212 },
+    data: { model: "suno/v5-5", instrumental: true, negativeTags: ["vocals", "choir", "whistling", "marching band", "epic orchestral"] },
+    inputs: ["prompt", "negative"],
+    outputs: ["audio", "approved"],
+    dynamic: "lyrics quando n\xE3o \xE9 instrumental"
+  },
+  review: {
+    title: "Revisor",
+    size: { w: 400, h: 420 },
+    data: {
+      model: "gemini-flash",
+      strictness: "normal",
+      criteria: "",
+      checks: { inventedText: true, inventedLogo: true, productFidelity: true, composition: true, artifacts: true }
+    },
+    inputs: ["items", "prompt", "refs"],
+    outputs: ["reviewed"],
+    main: "criteria"
+  },
+  approval: { title: "Aprova\xE7\xE3o", size: { w: 660, h: 580 }, data: {}, inputs: ["items"], outputs: ["approved"] },
+  "audio-demo": { title: "Demo de \xE1udio", size: { w: 460, h: 500 }, data: { chosenKey: null }, inputs: ["voice", "music"], outputs: ["voice", "music"] },
+  compose: {
+    title: "Composi\xE7\xE3o",
+    size: { w: 440, h: 320 },
+    data: { formatIds: [], imageType: "jpg", jpgQuality: 0.92 },
+    inputs: ["background", "title", "body", "cta", "legal", "logo"],
+    outputs: ["pieces"]
+  },
+  montage: {
+    title: "Montagem",
+    size: { w: 460, h: 560 },
+    data: {
+      order: "chegada",
+      musicGainDb: -14,
+      duckingDb: -8,
+      fadeMs: 1500,
+      title: "",
+      renderFilm: true,
+      filmFps: 30,
+      clipAudioGainDb: -12
+    },
+    inputs: ["clips", "voice", "music"],
+    outputs: ["film", "cut", "clips", "voice", "music"],
+    main: "title"
+  },
+  export: {
+    title: "Exporta\xE7\xE3o",
+    size: { w: 380, h: 420 },
+    data: { client: "", campaign: "", version: 1, imageType: "png", jpgQuality: 90, manifest: true, flat: false },
+    inputs: ["items"],
+    outputs: ["package"]
+  },
+  note: { title: "Nota", size: { w: 220, h: 220 }, data: { text: "", color: "yellow", fontSize: "auto" }, inputs: [], outputs: [], annotation: true, main: "text" },
+  label: {
+    title: "Texto livre",
+    size: { w: 320, h: 56 },
+    data: { text: "", size: "titulo", weight: "bold", color: "neutral", align: "left" },
+    inputs: [],
+    outputs: [],
+    annotation: true,
+    main: "text"
+  },
+  section: { title: "Se\xE7\xE3o", size: { w: 880, h: 560 }, data: { title: "Se\xE7\xE3o", color: "violet" }, inputs: [], outputs: [], annotation: true, main: "title" },
+  shape: {
+    title: "Forma",
+    size: { w: 200, h: 140 },
+    data: { shape: "rounded", fill: "blue", stroke: "blue", strokeWidth: 2, text: "" },
+    inputs: [],
+    outputs: [],
+    annotation: true,
+    main: "text"
+  }
+};
+function kindList() {
+  return Object.entries(KINDS).map(([k, s]) => `${k} (${s.title})`).join(", ");
+}
+function knownPort(kind, side, port) {
+  const spec = kind ? KINDS[kind] : void 0;
+  if (!spec) return void 0;
+  const list = side === "in" ? spec.inputs : spec.outputs;
+  if (list.includes(port)) return true;
+  if (spec.dynamic) {
+    return void 0;
+  }
+  return false;
+}
+
+// src/canvas/core.ts
+import { randomBytes, randomUUID } from "crypto";
+var SCHEMA_VERSION = 1;
+var MAX_OP_BYTES = 64 * 1024;
+var MAX_DATA_URL_BYTES = 8 * 1024;
+var CLIENT_ID = `mcp-${randomBytes(6).toString("hex")}`;
+var NODE_KEYS = ["id", "type", "position", "size", "zIndex", "parentId", "data", "createdBy", "createdAt", "updatedAt"];
+var EDGE_KEYS = ["id", "source", "sourcePort", "target", "targetPort", "data", "createdBy", "createdAt"];
+var FORBIDDEN_SEGMENTS = ["__proto__", "constructor", "prototype"];
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var isFiniteNumber = (v) => typeof v === "number" && Number.isFinite(v);
+var isStringOrNull = (v) => v === null || typeof v === "string";
+var hasOnlyKeys = (r, keys) => Object.keys(r).every((k) => keys.includes(k));
+function isJson(value) {
+  if (value === null) return true;
+  const kind = typeof value;
+  if (kind === "boolean" || kind === "string") return true;
+  if (kind === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every(isJson);
+  if (isRecord(value)) return Object.values(value).every(isJson);
+  return false;
+}
+var isJsonBag = (v) => isRecord(v) && Object.values(v).every(isJson);
+var isPoint = (v) => isRecord(v) && hasOnlyKeys(v, ["x", "y"]) && isFiniteNumber(v.x) && isFiniteNumber(v.y);
+var isSize = (v) => isRecord(v) && hasOnlyKeys(v, ["w", "h"]) && isFiniteNumber(v.w) && isFiniteNumber(v.h);
+function isValidNode(key, v) {
+  return isRecord(v) && hasOnlyKeys(v, NODE_KEYS) && v.id === key && typeof v.type === "string" && isPoint(v.position) && isSize(v.size) && isFiniteNumber(v.zIndex) && isStringOrNull(v.parentId) && isJsonBag(v.data) && isStringOrNull(v.createdBy) && isFiniteNumber(v.createdAt) && isFiniteNumber(v.updatedAt);
+}
+function isValidEdge(key, v) {
+  return isRecord(v) && hasOnlyKeys(v, EDGE_KEYS) && v.id === key && typeof v.source === "string" && typeof v.sourcePort === "string" && typeof v.target === "string" && typeof v.targetPort === "string" && isJsonBag(v.data) && isStringOrNull(v.createdBy) && isFiniteNumber(v.createdAt);
+}
+function checkNodePath(path) {
+  const segments = path.split(".");
+  if (segments.some((s) => s.length === 0)) return `caminho inv\xE1lido "${path}"`;
+  if (segments.some((s) => FORBIDDEN_SEGMENTS.includes(s))) return `segmento proibido em "${path}"`;
+  const [root, ...rest] = segments;
+  if (root === "data" && rest.length >= 1) return null;
+  if (root === "position" && rest.length === 1 && ["x", "y"].includes(rest[0]) || root === "size" && rest.length === 1 && ["w", "h"].includes(rest[0])) return null;
+  return `s\xF3 d\xE1 para editar data.*, position.x/y e size.w/h (recebido "${path}")`;
+}
+function hasLargeDataUrl(value) {
+  const stack = [value];
+  while (stack.length) {
+    const cur = stack.pop();
+    if (typeof cur === "string") {
+      if (cur.length > MAX_DATA_URL_BYTES && cur.startsWith("data:")) return true;
+    } else if (Array.isArray(cur)) stack.push(...cur);
+    else if (isRecord(cur)) stack.push(...Object.values(cur));
+  }
+  return false;
+}
+function checkOp(op) {
+  switch (op.type) {
+    case "node.add":
+      if (op.node.id !== op.nodeId || !isValidNode(op.nodeId, op.node)) return `n\xF3 ${op.nodeId} fora do formato do Canvas`;
+      return null;
+    case "edge.add":
+      if (op.edge.id !== op.edgeId || !isValidEdge(op.edgeId, op.edge)) return `liga\xE7\xE3o ${op.edgeId} fora do formato do Canvas`;
+      return null;
+    case "node.set": {
+      const bad = checkNodePath(op.path);
+      if (bad) return bad;
+      if (op.value.kind === "value") {
+        if (!isJson(op.value.value)) return `valor de ${op.path} n\xE3o \xE9 JSON`;
+        if (!op.path.startsWith("data.") && !isFiniteNumber(op.value.value)) return `${op.path} precisa ser n\xFAmero`;
+      } else if (!op.path.startsWith("data.")) return `${op.path} n\xE3o pode ser apagado`;
+      return null;
+    }
+    case "board.set":
+      if (op.field === "title" && (op.value.kind !== "value" || typeof op.value.value !== "string" || !op.value.value.trim()))
+        return "t\xEDtulo vazio";
+      return null;
+    case "batch":
+      for (const inner of op.ops) {
+        const bad = checkOp(inner);
+        if (bad) return bad;
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+function envelope(boardId2, op, actorId) {
+  return { id: randomUUID(), boardId: boardId2, clientId: CLIENT_ID, actorId, seq: null, ts: Date.now(), op };
+}
+function checkEnvelope(env) {
+  const bad = checkOp(env.op);
+  if (bad) return bad;
+  if (Buffer.byteLength(JSON.stringify(env)) > MAX_OP_BYTES)
+    return "opera\xE7\xE3o maior que 64 KB: divida em partes menores";
+  if (hasLargeDataUrl(env.op)) return "m\xEDdia embutida (data:) no board: suba o arquivo e use a URL";
+  return null;
+}
+function emptyBoard(title, now = Date.now()) {
+  return {
+    id: randomUUID(),
+    schemaVersion: SCHEMA_VERSION,
+    title,
+    ownerId: "",
+    folderId: null,
+    version: 0,
+    nodes: {},
+    edges: {},
+    results: {},
+    nodeHistory: {},
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function makeNode(init) {
+  const now = init.now ?? Date.now();
+  return {
+    id: init.id ?? randomUUID(),
+    type: init.type,
+    position: { x: init.position.x, y: init.position.y },
+    size: { w: init.size.w, h: init.size.h },
+    zIndex: init.zIndex,
+    parentId: null,
+    data: init.data,
+    createdBy: init.createdBy,
+    createdAt: now,
+    updatedAt: now
+  };
+}
+function makeEdge(init) {
+  return {
+    id: randomUUID(),
+    source: init.source,
+    sourcePort: init.sourcePort,
+    target: init.target,
+    targetPort: init.targetPort,
+    data: {},
+    createdBy: init.createdBy,
+    createdAt: init.now ?? Date.now()
+  };
+}
+var setValue = (value) => ({ kind: "value", value });
+var unsetValue = () => ({ kind: "unset" });
+function removeNodeOps(doc, nodeId) {
+  const ops = [];
+  const edgeIds = Object.keys(doc.edges).filter((id) => doc.edges[id].source === nodeId || doc.edges[id].target === nodeId).sort();
+  for (const edgeId of edgeIds) ops.push({ type: "edge.remove", edgeId });
+  const history = Object.hasOwn(doc.nodeHistory, nodeId) ? doc.nodeHistory[nodeId] : void 0;
+  if (history) for (const resultId of [...history].reverse()) ops.push({ type: "history.remove", nodeId, resultId });
+  ops.push({ type: "node.remove", nodeId });
+  return ops;
+}
+function batchOf(ops) {
+  return ops.length === 1 ? ops[0] : { type: "batch", ops };
+}
+
+// src/canvas/summary.ts
+var MAX_TEXT = 160;
+var MAX_BLOCKS = 40;
+var HEAVY_KEYS = /* @__PURE__ */ new Set([
+  "history",
+  "pinned",
+  "main",
+  "lastFrame",
+  "sequence",
+  "points",
+  "extra",
+  "mentions",
+  "mediaMentions",
+  "refs",
+  "fields",
+  "orphanedRows",
+  "holds",
+  "appearance",
+  "settings",
+  "enabledKeys",
+  "checks",
+  "versions"
+]);
+var NAME_KEYS = /* @__PURE__ */ new Set([KIND_FIELD, "label", "nodeTitle"]);
+function oneLine(text, max = MAX_TEXT) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+function nodeKind(node) {
+  const k = node.data[KIND_FIELD];
+  return typeof k === "string" && k ? k : null;
+}
+function nodeName(node) {
+  const { label, nodeTitle } = node.data;
+  if (typeof label === "string" && label.trim()) return label.trim();
+  if (typeof nodeTitle === "string" && nodeTitle.trim()) return nodeTitle.trim();
+  const kind = nodeKind(node);
+  return kind && KINDS[kind]?.title || kind || node.type;
+}
+function scalar(v) {
+  if (typeof v === "string") {
+    if (v.startsWith("data:")) return "[data-url]";
+    if (/^https?:\/\//.test(v)) return "[url]";
+    return JSON.stringify(oneLine(v, 60));
+  }
+  if (typeof v === "number" || typeof v === "boolean" || v === null) return String(v);
+  return null;
+}
+function blocksLines(blocks) {
+  if (!Array.isArray(blocks)) return [];
+  const out = blocks.slice(0, MAX_BLOCKS).map((b) => {
+    const rec = b ?? {};
+    return `    \xB7 ${String(rec.id ?? "?")}: ${oneLine(String(rec.text ?? ""), 120)}`;
+  });
+  if (blocks.length > MAX_BLOCKS) out.push(`    \xB7 \u2026 +${blocks.length - MAX_BLOCKS} blocos`);
+  return out;
+}
+function rowsLines(rows) {
+  if (!Array.isArray(rows)) return [];
+  const out = [];
+  for (const r of rows.slice(0, MAX_BLOCKS)) {
+    const rec = r ?? {};
+    const ideas = Array.isArray(rec.ideas) ? rec.ideas : [];
+    const ideaText = ideas.slice(0, 6).map((i) => {
+      const idea = i ?? {};
+      return `${String(idea.id ?? "?")}="${oneLine(String(idea.text ?? ""), 60)}"`;
+    }).join("; ");
+    out.push(`    \xB7 linha ${String(rec.id ?? "?")} (bloco ${String(rec.narrationBlockId ?? "?")}): ${ideas.length} ideia(s) ${ideaText}`);
+  }
+  if (rows.length > MAX_BLOCKS) out.push(`    \xB7 \u2026 +${rows.length - MAX_BLOCKS} linhas`);
+  return out;
+}
+function nodeLines(node, run) {
+  const kind = nodeKind(node);
+  const spec = kind ? KINDS[kind] : void 0;
+  const head = `- ${node.id} \xB7 ${kind ?? node.type} \xB7 "${oneLine(nodeName(node), 60)}" @(${Math.round(node.position.x)},${Math.round(node.position.y)})`;
+  const facts = [];
+  const extra = [];
+  const d = node.data;
+  if (d.archived) facts.push("ARQUIVADO");
+  const approval = d.approval?.state;
+  if (typeof approval === "string") facts.push(`aprova\xE7\xE3o: ${approval}`);
+  if (Array.isArray(d.history)) facts.push(`${d.history.length} gera\xE7\xE3o(\xF5es)`);
+  if (Array.isArray(d.items)) {
+    const names = d.items.slice(0, 5).map((i) => String(i?.name ?? "?"));
+    facts.push(`${d.items.length} arquivo(s)${names.length ? `: ${names.join(", ")}` : ""}`);
+  }
+  if (Array.isArray(d.blocks)) {
+    facts.push(`${d.blocks.length} bloco(s)`);
+    extra.push(...blocksLines(d.blocks));
+  }
+  if (Array.isArray(d.rows)) {
+    facts.push(`${d.rows.length} linha(s)`);
+    extra.push(...rowsLines(d.rows));
+  }
+  const main2 = spec?.main;
+  if (main2 && typeof d[main2] === "string" && d[main2]) facts.push(`${main2}: "${oneLine(d[main2])}"`);
+  for (const [key, value] of Object.entries(d)) {
+    if (NAME_KEYS.has(key) || HEAVY_KEYS.has(key) || key === main2) continue;
+    if (["blocks", "rows", "items", "archived", "approval"].includes(key)) continue;
+    const s = scalar(value);
+    if (s !== null) facts.push(`${key}=${s}`);
+    else if (Array.isArray(value)) facts.push(`${key}=[${value.length}]`);
+    else if (value && typeof value === "object") facts.push(`${key}={\u2026}`);
+    if (facts.length > 12) break;
+  }
+  if (run?.claimedBy) facts.push("rodando agora");
+  return [facts.length ? `${head} \xB7 ${facts.join(" \xB7 ")}` : head, ...extra];
+}
+function boardSummary(snap) {
+  const doc = snap.doc;
+  const nodes = Object.values(doc.nodes).sort((a, b) => a.position.x - b.position.x || a.position.y - b.position.y);
+  const edges = Object.values(doc.edges);
+  const runs = new Map(snap.runs.map((r) => [r.nodeId, r]));
+  const lines = [
+    `Board "${snap.title}" \xB7 id ${snap.id} \xB7 seq ${snap.seq} \xB7 seu papel: ${snap.role} \xB7 ${nodes.length} n\xF3(s) \xB7 ${edges.length} liga\xE7\xE3o(\xF5es)`
+  ];
+  const ialab = doc.meta?.ialab;
+  if (ialab === null) lines.push("IA Lab: sem v\xEDnculo (gera\xE7\xF5es saem dos diamantes de quem roda).");
+  else if (ialab && typeof ialab === "object") {
+    const label = ["code", "name", "projectCode", "projectName"].map((k) => ialab[k]).find((v) => typeof v === "string");
+    lines.push(`IA Lab: vinculado${label ? ` a ${String(label)}` : ""}.`);
+  }
+  if (doc.meta?.guide) lines.push(`Guia: ${oneLine(doc.meta.guide)}`);
+  lines.push("", "N\xF3s:");
+  if (!nodes.length) lines.push("(vazio)");
+  for (const n of nodes) lines.push(...nodeLines(n, runs.get(n.id)));
+  lines.push("", "Liga\xE7\xF5es:");
+  if (!edges.length) lines.push("(nenhuma)");
+  for (const e of edges) lines.push(`- ${e.id}: ${e.source}.${e.sourcePort} \u2192 ${e.target}.${e.targetPort}`);
+  return lines.join("\n");
+}
+function nodeDetail(node) {
+  const strip = (v, depth) => {
+    if (typeof v === "string") {
+      if (v.startsWith("data:")) return `[data-url ${v.length}b]`;
+      return v.length > 2e3 ? `${v.slice(0, 2e3)}\u2026 [+${v.length - 2e3}]` : v;
+    }
+    if (Array.isArray(v)) {
+      if (depth > 4) return `[${v.length} itens]`;
+      const head = v.slice(0, 60).map((x) => strip(x, depth + 1));
+      return v.length > 60 ? [...head, `\u2026 +${v.length - 60}`] : head;
+    }
+    if (v && typeof v === "object") {
+      if (depth > 4) return "{\u2026}";
+      const out = {};
+      for (const [k, x] of Object.entries(v)) {
+        out[k] = k === "points" || k === "sequence" ? "[omitido]" : strip(x, depth + 1);
+      }
+      return out;
+    }
+    return v;
+  };
+  return `${node.id} \xB7 ${nodeKind(node) ?? node.type} \xB7 "${nodeName(node)}"
+${JSON.stringify(strip(node.data, 0))}`;
+}
+function changesSince(envelopes, doc) {
+  const count = /* @__PURE__ */ new Map();
+  for (const e of envelopes) {
+    const key = e.op.type;
+    count.set(key, (count.get(key) ?? 0) + 1);
+  }
+  const parts = [...count].map(([t, n]) => `${n}\xD7 ${t}`);
+  const names = [...touchedNodes(envelopes)].map((id) => doc.nodes[id] ? `"${oneLine(nodeName(doc.nodes[id]), 40)}"` : `${id} (apagado)`).slice(0, 8);
+  return `${envelopes.length} opera\xE7\xE3o(\xF5es) de outras pessoas desde a sua leitura (${parts.join(", ")})` + (names.length ? `; n\xF3s tocados: ${names.join(", ")}` : "");
+}
+function touchedNodes(envelopes) {
+  const out = /* @__PURE__ */ new Set();
+  const visit = (op) => {
+    if (op.type === "batch" && Array.isArray(op.ops)) {
+      for (const inner of op.ops) visit(inner);
+      return;
+    }
+    if (typeof op.nodeId === "string") out.add(op.nodeId);
+    const edge = op.edge;
+    if (edge && typeof edge.source === "string") out.add(edge.source);
+    if (edge && typeof edge.target === "string") out.add(edge.target);
+  };
+  for (const e of envelopes) visit(e.op);
+  return out;
+}
+
+// src/tools/canvas.ts
+var REJECT_TEXT = {
+  "node-missing": "o n\xF3 n\xE3o existe mais (algu\xE9m apagou)",
+  "edge-endpoint-missing": "uma ponta da liga\xE7\xE3o n\xE3o existe mais",
+  "invalid-op": "opera\xE7\xE3o inv\xE1lida ou repetida",
+  "too-large": "opera\xE7\xE3o grande demais (64 KB) ou com m\xEDdia embutida"
+};
+var SECTION_Z = -1e3;
+var GAP = 80;
+var CanvasToolError = class extends Error {
+};
+var boardId = external_exports.string().uuid().describe("Id (uuid) do board, como sai em canvas_list_boards.");
+var nodeIdArg = external_exports.string().min(1).max(128);
+var point = external_exports.object({ x: external_exports.number().finite(), y: external_exports.number().finite() });
+function registerCanvasTools(server, client, cfg) {
+  const api = new CanvasApi(client, cfg);
+  const seen = /* @__PURE__ */ new Map();
+  function fail(e) {
+    if (e instanceof CanvasToolError || e instanceof CoreMismatchError) return errorResult(e.message);
+    if (e instanceof ApiError && e.httpStatus === 401 && !api.usesPat) {
+      return errorResult(
+        "O acesso pelo navegador expirou ou foi revogado. Rode `beplus-mcp login` de novo e autorize."
+      );
+    }
+    if (e instanceof ApiError && e.httpStatus === 404) {
+      return errorResult("Board n\xE3o encontrado, ou voc\xEA n\xE3o \xE9 membro dele. Confira o id em canvas_list_boards.");
+    }
+    return errorResult(apiErrorToUserMessage(e));
+  }
+  async function run(fn) {
+    try {
+      return textResult(await fn());
+    } catch (e) {
+      return fail(e);
+    }
+  }
+  async function edit(id, build) {
+    const last = seen.get(id);
+    if (last === void 0) {
+      throw new CanvasToolError("Leia o board com canvas_read_board antes de editar (a leitura vale para a sess\xE3o).");
+    }
+    const snap = await api.snapshot(id);
+    if (snap.role === "viewer") throw new CanvasToolError("Voc\xEA \xE9 s\xF3 leitor neste board: pe\xE7a ao dono para te dar papel de editor.");
+    const doc = snap.doc;
+    const { ops, done, targets } = await build(doc, snap);
+    if (!ops.length) return `Nada a mudar. ${done}`;
+    let note = "";
+    if (snap.seq > last) {
+      const since = await api.opsAfter(id, last);
+      const theirs = since?.filter((e) => e.clientId !== CLIENT_ID) ?? null;
+      if (theirs === null) {
+        seen.delete(id);
+        throw new CanvasToolError(
+          `O board mudou muito desde a sua leitura (seq ${last} \u2192 ${snap.seq}). Releia com canvas_read_board antes de editar.`
+        );
+      }
+      const clash = [...touchedNodes(theirs)].filter((n) => targets.includes(n));
+      if (clash.length) {
+        seen.delete(id);
+        const names = clash.map((n) => doc.nodes[n] ? `"${oneLine(nodeName(doc.nodes[n]), 40)}"` : n).join(", ");
+        throw new CanvasToolError(
+          `Outra pessoa mexeu em ${names} depois da sua leitura (seq ${last} \u2192 ${snap.seq}). Nada foi aplicado: releia com canvas_read_board e refa\xE7a a edi\xE7\xE3o em cima do estado atual.`
+        );
+      }
+      if (theirs.length) note = `
+Aviso: ${changesSince(theirs, doc)}.`;
+    }
+    const env = envelope(id, batchOf(ops), await api.me());
+    const bad = checkEnvelope(env);
+    if (bad) throw new CanvasToolError(`Edi\xE7\xE3o recusada antes de enviar: ${bad}.`);
+    const res = await api.commit(id, [env]);
+    const outcome = res.outcomes.find((o) => o.opId === env.id);
+    if (!outcome || "rejected" in outcome) {
+      seen.delete(id);
+      const why = outcome && "rejected" in outcome ? REJECT_TEXT[outcome.rejected] ?? outcome.rejected : "sem resposta do servidor";
+      throw new CanvasToolError(`O servidor recusou a edi\xE7\xE3o: ${why}. Nada foi aplicado. Releia com canvas_read_board.`);
+    }
+    seen.set(id, res.seq);
+    return `\u2705 ${done} (seq ${res.seq}).${note}`;
+  }
+  function needNode(doc, nodeId) {
+    const node = doc.nodes[nodeId];
+    if (!node) throw new CanvasToolError(`N\xF3 ${nodeId} n\xE3o existe no board. Releia com canvas_read_board.`);
+    return node;
+  }
+  function portWarning(doc, source, sourcePort, target, targetPort) {
+    const warn = [];
+    const s = knownPort(nodeKind(doc.nodes[source]), "out", sourcePort);
+    const t = knownPort(nodeKind(doc.nodes[target]), "in", targetPort);
+    if (s === false) warn.push(`sa\xEDda "${sourcePort}" n\xE3o \xE9 porta conhecida de ${nodeKind(doc.nodes[source])}`);
+    if (t === false) warn.push(`entrada "${targetPort}" n\xE3o \xE9 porta conhecida de ${nodeKind(doc.nodes[target])}`);
+    return warn.length ? ` Aten\xE7\xE3o: ${warn.join("; ")}.` : "";
+  }
+  function edgeOps(doc, links, createdBy, pending) {
+    const ops = [];
+    let warn = "";
+    for (const l of links) {
+      for (const end of [l.source, l.target]) {
+        if (!doc.nodes[end] && !pending.has(end)) throw new CanvasToolError(`N\xF3 ${end} n\xE3o existe no board. Releia com canvas_read_board.`);
+      }
+      const dup = Object.values(doc.edges).some(
+        (e) => e.source === l.source && e.sourcePort === l.sourcePort && e.target === l.target && e.targetPort === l.targetPort
+      );
+      if (dup) continue;
+      if (doc.nodes[l.source] && doc.nodes[l.target]) warn += portWarning(doc, l.source, l.sourcePort, l.target, l.targetPort);
+      const edge = makeEdge({ ...l, createdBy });
+      ops.push({ type: "edge.add", edgeId: edge.id, edge });
+    }
+    return { ops, warn };
+  }
+  function placeFor(doc, size, near, side = "right") {
+    if (near) {
+      const x = side === "right" ? near.position.x + near.size.w + GAP : near.position.x - size.w - GAP;
+      let y = near.position.y;
+      const nodes2 = Object.values(doc.nodes);
+      const hits = (yy) => nodes2.some((n) => x < n.position.x + n.size.w && x + size.w > n.position.x && yy < n.position.y + n.size.h && yy + size.h > n.position.y);
+      for (let i = 0; i < 50 && hits(y); i++) y += GAP;
+      return { x, y };
+    }
+    const nodes = Object.values(doc.nodes).filter((n) => nodeKind(n) !== "section");
+    if (!nodes.length) return { x: 0, y: 0 };
+    return {
+      x: Math.max(...nodes.map((n) => n.position.x + n.size.w)) + GAP,
+      y: Math.min(...nodes.map((n) => n.position.y))
+    };
+  }
+  function parseData(raw) {
+    const out = {};
+    for (const [k, v] of Object.entries(raw ?? {})) {
+      if (k === KIND_FIELD) throw new CanvasToolError("data.kind n\xE3o muda: apague o n\xF3 e crie outro do tipo certo.");
+      if (!isJson(v)) throw new CanvasToolError(`data.${k} n\xE3o \xE9 JSON v\xE1lido.`);
+      out[k] = v;
+    }
+    return out;
+  }
+  server.registerTool(
+    "canvas_list_boards",
+    {
+      title: "Canvas: listar boards",
+      description: "Lista os boards do Canvas online de que voc\xEA \xE9 membro (id, t\xEDtulo, seu papel, seq, \xFAltima mudan\xE7a). S\xF3 leitura.",
+      inputSchema: { kind: external_exports.enum(["board", "template"]).optional().describe("board (padr\xE3o) ou template (moldes).") },
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    },
+    async ({ kind }) => run(async () => {
+      const boards = await api.listBoards(kind ?? "board");
+      if (!boards.length) return "Nenhum board. Crie um com canvas_create_board.";
+      return boards.map((b) => `- ${b.id} \xB7 "${b.title}" \xB7 ${b.role} \xB7 seq ${b.seq} \xB7 ${String(b.updatedAt).slice(0, 16).replace("T", " ")}`).join("\n");
+    })
+  );
+  server.registerTool(
+    "canvas_read_board",
+    {
+      title: "Canvas: ler board",
+      description: "L\xEA um board: n\xF3s (id, tipo, nome, campos principais), liga\xE7\xF5es e v\xEDnculo com o IA Lab, sem m\xEDdia. Obrigat\xF3rio antes de editar (vale para a sess\xE3o). node_ids devolve o data completo desses n\xF3s.",
+      inputSchema: {
+        board_id: boardId,
+        node_ids: external_exports.array(nodeIdArg).max(20).optional().describe("N\xF3s para ver o data inteiro (sem blobs).")
+      },
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    },
+    async ({ board_id, node_ids }) => run(async () => {
+      const snap = await api.snapshot(board_id);
+      seen.set(board_id, snap.seq);
+      const parts = [boardSummary(snap)];
+      if (node_ids?.length) {
+        parts.push("", "Detalhe:");
+        for (const n of node_ids) parts.push(snap.doc.nodes[n] ? nodeDetail(snap.doc.nodes[n]) : `${n}: n\xE3o existe`);
+      }
+      return parts.join("\n");
+    })
+  );
+  server.registerTool(
+    "canvas_create_board",
+    {
+      title: "Canvas: criar board",
+      description: 'Cria um board online (voc\xEA vira dono). template "narration" j\xE1 cria Contexto, Narra\xE7\xE3o, Roteiro e Locu\xE7\xE3o ligados (Narra\xE7\xE3o.blocks \u2192 Roteiro.blocks, Narra\xE7\xE3o.text \u2192 Locu\xE7\xE3o.text). O kit do Contexto a pessoa escolhe no Canvas. N\xE3o gera m\xEDdia.',
+      inputSchema: {
+        title: external_exports.string().trim().min(1).max(200),
+        template: external_exports.enum(["blank", "narration"]).optional().describe("blank (padr\xE3o) ou narration.")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    async ({ title, template }) => run(async () => {
+      const doc = emptyBoard(title);
+      const ids = {};
+      if (template === "narration") {
+        const me = await api.me();
+        let zIndex = 1;
+        const add = (kind, x, y) => {
+          const spec = KINDS[kind];
+          const node = makeNode({
+            type: WORKFLOW_NODE_TYPE,
+            data: { ...spec.data, [KIND_FIELD]: kind },
+            position: { x, y },
+            size: spec.size,
+            zIndex: zIndex++,
+            createdBy: me
+          });
+          doc.nodes[node.id] = node;
+          ids[kind] = node.id;
+          return node.id;
+        };
+        add("context", 200, 200);
+        const narration = add("narration", 650, 200);
+        const shotlist = add("shotlist", 1150, 200);
+        const tts = add("tts", 650, 750);
+        for (const l of [
+          { source: narration, sourcePort: "blocks", target: shotlist, targetPort: "blocks" },
+          { source: narration, sourcePort: "text", target: tts, targetPort: "text" }
+        ]) {
+          const edge = makeEdge({ ...l, createdBy: me });
+          doc.edges[edge.id] = edge;
+        }
+      }
+      const created = await api.createBoard({ title, kind: "board", doc });
+      seen.set(created.id, created.seq);
+      const idLine = Object.keys(ids).length ? `
+N\xF3s: ${Object.entries(ids).map(([k, v]) => `${k}=${v}`).join(" \xB7 ")}` : "";
+      return `\u2705 Board criado: "${created.title}" \xB7 id ${created.id} \xB7 seq ${created.seq}.${idLine}`;
+    })
+  );
+  server.registerTool(
+    "canvas_add_node",
+    {
+      title: "Canvas: adicionar n\xF3",
+      description: `Adiciona um n\xF3 (n\xE3o executa). kind: ${kindList()}. data completa o padr\xE3o do tipo; label d\xE1 o nome. Sem position, nasce ao lado do n\xF3 ligado ou \xE0 direita do board. inputs/outputs j\xE1 ligam o n\xF3 no mesmo passo.`,
+      inputSchema: {
+        board_id: boardId,
+        kind: external_exports.string().min(1).max(40),
+        label: external_exports.string().trim().min(1).max(120).optional().describe("Nome do cart\xE3o (data.label)."),
+        data: external_exports.record(external_exports.unknown()).optional().describe("Campos do data. Ex.: narration {blocks:[{id,text}]}, text {text}, prompt {template}."),
+        position: point.optional(),
+        inputs: external_exports.array(external_exports.object({ from: nodeIdArg, from_port: external_exports.string().min(1), to_port: external_exports.string().min(1) })).max(20).optional().describe("Liga\xE7\xF5es que CHEGAM no n\xF3 novo: from.from_port \u2192 novo.to_port."),
+        outputs: external_exports.array(external_exports.object({ from_port: external_exports.string().min(1), to: nodeIdArg, to_port: external_exports.string().min(1) })).max(20).optional().describe("Liga\xE7\xF5es que SAEM do n\xF3 novo: novo.from_port \u2192 to.to_port.")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    async (args) => run(
+      () => edit(args.board_id, async (doc) => {
+        const spec = KINDS[args.kind];
+        if (!spec) throw new CanvasToolError(`Tipo "${args.kind}" desconhecido. Tipos: ${kindList()}.`);
+        const me = await api.me();
+        const data = { ...spec.data, ...parseData(args.data), [KIND_FIELD]: args.kind };
+        if (args.label) data.label = args.label;
+        const near = args.inputs?.[0] ? doc.nodes[args.inputs[0].from] : args.outputs?.[0] ? doc.nodes[args.outputs[0].to] : void 0;
+        const position = args.position ?? placeFor(doc, spec.size, near, args.inputs?.[0] ? "right" : "left");
+        const zIndex = args.kind === "section" ? SECTION_Z : Object.values(doc.nodes).reduce((t, n) => Math.max(t, n.zIndex), 0) + 1;
+        const node = makeNode({ type: WORKFLOW_NODE_TYPE, data, position, size: spec.size, zIndex, createdBy: me });
+        const links = [
+          ...(args.inputs ?? []).map((l) => ({ source: l.from, sourcePort: l.from_port, target: node.id, targetPort: l.to_port })),
+          ...(args.outputs ?? []).map((l) => ({ source: node.id, sourcePort: l.from_port, target: l.to, targetPort: l.to_port }))
+        ];
+        for (const l of links) {
+          const warn = knownPort(args.kind, l.source === node.id ? "out" : "in", l.source === node.id ? l.sourcePort : l.targetPort);
+          if (warn === false) {
+            throw new CanvasToolError(
+              `Porta "${l.source === node.id ? l.sourcePort : l.targetPort}" n\xE3o existe em ${args.kind}. Entradas: ${spec.inputs.join(", ") || "\u2014"}; sa\xEDdas: ${spec.outputs.join(", ") || "\u2014"}.`
+            );
+          }
+        }
+        const edges = edgeOps(doc, links, me, /* @__PURE__ */ new Set([node.id]));
+        return {
+          ops: [{ type: "node.add", nodeId: node.id, node }, ...edges.ops],
+          targets: links.map((l) => l.source === node.id ? l.target : l.source),
+          done: `N\xF3 ${args.kind} "${nodeName(node)}" criado: ${node.id}${edges.ops.length ? ` com ${edges.ops.length} liga\xE7\xE3o(\xF5es)` : ""}.${edges.warn}`
+        };
+      })
+    )
+  );
+  server.registerTool(
+    "canvas_update_node",
+    {
+      title: "Canvas: editar n\xF3",
+      description: "Muda campos do data de um n\xF3, chave a chave (null apaga a chave), sem executar. label renomeia. N\xE3o troca o tipo. Leia o n\xF3 com node_ids antes para n\xE3o sobrescrever o que outra pessoa escreveu.",
+      inputSchema: {
+        board_id: boardId,
+        node_id: nodeIdArg,
+        data: external_exports.record(external_exports.unknown()).optional().describe("Chaves de data a gravar. Valor null apaga a chave."),
+        label: external_exports.string().trim().min(1).max(120).optional(),
+        position: point.optional()
+      },
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false }
+    },
+    async (args) => run(
+      () => edit(args.board_id, async (doc) => {
+        const node = needNode(doc, args.node_id);
+        const ops = [];
+        const patch = parseData(args.data);
+        if (args.label) patch.label = args.label;
+        for (const [k, v] of Object.entries(patch)) {
+          const path = `data.${k}`;
+          if (v === null) {
+            if (Object.hasOwn(node.data, k)) ops.push({ type: "node.set", nodeId: node.id, path, value: unsetValue() });
+          } else if (JSON.stringify(node.data[k]) !== JSON.stringify(v)) {
+            ops.push({ type: "node.set", nodeId: node.id, path, value: setValue(v) });
+          }
+        }
+        if (args.position) {
+          ops.push({ type: "node.set", nodeId: node.id, path: "position.x", value: setValue(args.position.x) });
+          ops.push({ type: "node.set", nodeId: node.id, path: "position.y", value: setValue(args.position.y) });
+        }
+        const keys = ops.map((o) => o.type === "node.set" ? o.path.replace(/^data\./, "") : "").join(", ");
+        return { ops, targets: [node.id], done: `N\xF3 "${nodeName(node)}" atualizado: ${keys || "nada mudou"}` };
+      })
+    )
+  );
+  server.registerTool(
+    "canvas_connect",
+    {
+      title: "Canvas: ligar portas",
+      description: "Liga a sa\xEDda de um n\xF3 \xE0 entrada de outro (ids e portas de canvas_read_board). Liga\xE7\xE3o repetida \xE9 ignorada.",
+      inputSchema: {
+        board_id: boardId,
+        source: nodeIdArg,
+        source_port: external_exports.string().min(1).max(80),
+        target: nodeIdArg,
+        target_port: external_exports.string().min(1).max(80)
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    async (args) => run(
+      () => edit(args.board_id, async (doc) => {
+        if (args.source === args.target) throw new CanvasToolError("Um n\xF3 n\xE3o se liga nele mesmo.");
+        const link = { source: args.source, sourcePort: args.source_port, target: args.target, targetPort: args.target_port };
+        const { ops, warn } = edgeOps(doc, [link], await api.me(), /* @__PURE__ */ new Set());
+        return {
+          ops,
+          targets: [args.source, args.target],
+          done: ops.length ? `Ligado ${nodeName(doc.nodes[args.source])}.${args.source_port} \u2192 ${nodeName(doc.nodes[args.target])}.${args.target_port}.${warn}` : "A liga\xE7\xE3o j\xE1 existia."
+        };
+      })
+    )
+  );
+  server.registerTool(
+    "canvas_delete",
+    {
+      title: "Canvas: apagar n\xF3s/liga\xE7\xF5es",
+      description: "Apaga n\xF3s (com as liga\xE7\xF5es e varia\xE7\xF5es deles) e/ou liga\xE7\xF5es, num passo s\xF3. Irrevers\xEDvel pelo MCP: confirme com o usu\xE1rio antes. N\xE3o apaga o board.",
+      inputSchema: {
+        board_id: boardId,
+        node_ids: external_exports.array(nodeIdArg).max(200).optional(),
+        edge_ids: external_exports.array(nodeIdArg).max(200).optional()
+      },
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false }
+    },
+    async (args) => run(
+      () => edit(args.board_id, async (doc) => {
+        const nodeIds = [...new Set(args.node_ids ?? [])];
+        const edgeIds = [...new Set(args.edge_ids ?? [])];
+        if (!nodeIds.length && !edgeIds.length) throw new CanvasToolError("Informe node_ids e/ou edge_ids.");
+        const missing = [...nodeIds.filter((n) => !doc.nodes[n]), ...edgeIds.filter((e) => !doc.edges[e])];
+        if (missing.length) throw new CanvasToolError(`N\xE3o existem no board: ${missing.join(", ")}. Releia com canvas_read_board.`);
+        const ops = [];
+        const gone = /* @__PURE__ */ new Set();
+        for (const e of edgeIds) {
+          const edge = doc.edges[e];
+          if (nodeIds.includes(edge.source) || nodeIds.includes(edge.target)) continue;
+          ops.push({ type: "edge.remove", edgeId: e });
+          gone.add(e);
+        }
+        for (const n of nodeIds) {
+          for (const op of removeNodeOps(doc, n)) {
+            if (op.type === "edge.remove") {
+              if (gone.has(op.edgeId)) continue;
+              gone.add(op.edgeId);
+            }
+            ops.push(op);
+          }
+        }
+        const names = nodeIds.map((n) => `"${oneLine(nodeName(doc.nodes[n]), 40)}"`);
+        return {
+          ops,
+          targets: nodeIds,
+          done: `Apagado: ${nodeIds.length} n\xF3(s)${names.length ? ` (${names.join(", ")})` : ""} e ${gone.size} liga\xE7\xE3o(\xF5es)`
+        };
+      })
+    )
+  );
+  server.registerTool(
+    "canvas_rename_board",
+    {
+      title: "Canvas: renomear board",
+      description: "Troca o t\xEDtulo do board (board.set). Precisa de papel de editor ou dono.",
+      inputSchema: { board_id: boardId, title: external_exports.string().trim().min(1).max(200) },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    async ({ board_id, title }) => run(
+      () => edit(board_id, async (doc) => ({
+        ops: doc.title === title ? [] : [{ type: "board.set", field: "title", value: setValue(title) }],
+        targets: [],
+        done: `Board renomeado: "${doc.title}" \u2192 "${title}"`
+      }))
+    )
+  );
+  server.registerTool(
+    "canvas_list_members",
+    {
+      title: "Canvas: membros do board",
+      description: "Lista quem tem acesso ao board (userId, nome, papel). S\xF3 leitura.",
+      inputSchema: { board_id: boardId },
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    },
+    async ({ board_id }) => run(async () => {
+      const members = await api.members(board_id);
+      return members.map((m) => {
+        const name = [m.firstName, m.lastName].filter(Boolean).join(" ") || m.nickname || "(sem nome)";
+        return `- ${m.userId} \xB7 ${name} \xB7 ${m.role}`;
+      }).join("\n");
+    })
+  );
+  server.registerTool(
+    "canvas_set_member",
+    {
+      title: "Canvas: adicionar membro",
+      description: "D\xE1 acesso ao board (ou troca o papel) para um usu\xE1rio pelo userId (uuid). S\xF3 o dono pode. Ainda n\xE3o h\xE1 busca por e-mail: pe\xE7a o userId ou copie de canvas_list_members de outro board.",
+      inputSchema: {
+        board_id: boardId,
+        user_id: external_exports.string().uuid(),
+        role: external_exports.enum(["editor", "viewer"]).describe("editor edita; viewer s\xF3 v\xEA.")
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    async ({ board_id, user_id, role }) => run(async () => {
+      const r = await api.putMember(board_id, user_id, role);
+      return `\u2705 ${r.userId} agora \xE9 ${r.role} no board.`;
+    })
+  );
+  server.registerTool(
+    "canvas_remove_member",
+    {
+      title: "Canvas: remover membro",
+      description: "Tira o acesso de algu\xE9m ao board (o dono tira qualquer um; quem n\xE3o \xE9 dono s\xF3 sai sozinho). O dono n\xE3o sai.",
+      inputSchema: { board_id: boardId, user_id: external_exports.string().uuid() },
+      annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: false }
+    },
+    async ({ board_id, user_id }) => run(async () => {
+      await api.removeMember(board_id, user_id);
+      return `\u2705 ${user_id} n\xE3o tem mais acesso ao board.`;
+    })
+  );
+}
+
 // src/version.ts
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
 function readVersion() {
-  if ("0.25.0") return "0.25.0";
+  if ("0.26.0") return "0.26.0";
   try {
     const pkg = require2("../package.json");
     return pkg.version ?? "0.0.0-unknown";
@@ -23481,8 +24524,14 @@ function readVersion() {
 var VERSION = readVersion();
 
 // src/server.ts
+var SERVER_INSTRUCTIONS = [
+  "BePlus: tudo roda pela conta do usu\xE1rio (diamantes, limites e hist\xF3rico na plataforma).",
+  'M\xEDdia: generate_* gasta diamantes; confira com estimate_cost antes de lotes grandes. Sem project, a gera\xE7\xE3o cai no projeto ativo; billing:"personal" cobra do usu\xE1rio.',
+  "Calls: search_calls acha, get_call traz a transcri\xE7\xE3o.",
+  "Canvas online (canvas_*): leia com canvas_read_board antes de editar e siga o estado lido. Cada edi\xE7\xE3o vai num passo s\xF3; se outra pessoa mexeu nos mesmos n\xF3s, a ferramenta recusa e pede releitura. As ferramentas canvas_* n\xE3o geram m\xEDdia nem gastam diamantes: quem roda os n\xF3s \xE9 o usu\xE1rio no Canvas. D\xEA nome (label) aos n\xF3s, n\xE3o invente tipos nem portas, e confirme antes de canvas_delete."
+].join("\n");
 function buildServer(cfg) {
-  const server = new McpServer({ name: "beplus", version: VERSION });
+  const server = new McpServer({ name: "beplus", version: VERSION }, { instructions: SERVER_INSTRUCTIONS });
   const client = new BeplusClient(cfg);
   registerGenerationTools(server, client, cfg);
   registerUpscaleTools(server, client, cfg);
@@ -23493,6 +24542,7 @@ function buildServer(cfg) {
   registerProjectTools(server, client, cfg);
   registerClientTools(server, client, cfg);
   registerCallTools(server, client, cfg);
+  registerCanvasTools(server, client, cfg);
   return { server, client };
 }