beplus-mcp 0.25.0 → 0.27.0

package/dist/index.js

@@ -916,10 +916,10 @@ var require_codegen = __commonJS({
         return this._leafNode(new Throw(error2));
       }
       // start self-balancing block
-      block(body, nodeCount) {
+      block(body2, nodeCount) {
         this._blockStarts.push(this._nodes.length);
-        if (body)
-          this.code(body).endBlock(nodeCount);
+        if (body2)
+          this.code(body2).endBlock(nodeCount);
         return this;
       }
       // end the current self-balancing block
@@ -2344,15 +2344,15 @@ var require_validate = __commonJS({
       validateFunction(it, () => (0, boolSchema_1.topBoolOrEmptySchema)(it));
     }
     exports.validateFunctionCode = validateFunctionCode;
-    function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body) {
+    function validateFunction({ gen, validateName, schema, schemaEnv, opts }, body2) {
       if (opts.code.es5) {
         gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${names_1.default.valCxt}`, schemaEnv.$async, () => {
           gen.code((0, codegen_1._)`"use strict"; ${funcSourceUrl(schema, opts)}`);
           destructureValCxtES5(gen, opts);
-          gen.code(body);
+          gen.code(body2);
         });
       } else {
-        gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body));
+        gen.func(validateName, (0, codegen_1._)`${names_1.default.data}, ${destructureValCxt(opts)}`, schemaEnv.$async, () => gen.code(funcSourceUrl(schema, opts)).code(body2));
       }
     }
     function destructureValCxt(opts) {
@@ -13050,6 +13050,7 @@ function loadConfig() {
   return {
     baseUrl,
     apiBase: `${baseUrl}/api/v1/mcp`,
+    canvasBase: `${baseUrl}/api/v1/canvas`,
     token,
     inlineImages,
     inlineImageMax: 4,
@@ -21155,11 +21156,11 @@ var EMPTY_COMPLETION_RESULT = {
 var ApiError = class extends Error {
   httpStatus;
   body;
-  constructor(httpStatus, message, body) {
+  constructor(httpStatus, message, body2) {
     super(message);
     this.name = "ApiError";
     this.httpStatus = httpStatus;
-    this.body = body;
+    this.body = body2;
   }
 };
 function apiErrorToUserMessage(err) {
@@ -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));
@@ -21242,14 +21244,14 @@ var BeplusClient = class {
     }
     return json2 && typeof json2 === "object" && "result" in json2 ? json2.result : json2;
   }
-  startGeneration(body) {
-    return this.request("POST", "/generations", { body });
+  startGeneration(body2) {
+    return this.request("POST", "/generations", { body: body2 });
   }
   listProjects() {
     return this.request("GET", "/projects");
   }
-  createProject(body) {
-    return this.request("POST", "/projects", { body });
+  createProject(body2) {
+    return this.request("POST", "/projects", { body: body2 });
   }
   getActiveProject() {
     return this.request("GET", "/projects/active");
@@ -21261,8 +21263,8 @@ var BeplusClient = class {
   listClients() {
     return this.request("GET", "/clients");
   }
-  createClient(body) {
-    return this.request("POST", "/clients", { body });
+  createClient(body2) {
+    return this.request("POST", "/clients", { body: body2 });
   }
   setActiveClient(client) {
     return this.request("PUT", "/clients/active", { body: { client } });
@@ -21284,8 +21286,8 @@ var BeplusClient = class {
       }
     });
   }
-  tts(body) {
-    return this.request("POST", "/tts", { body, timeoutMs: 9e4 });
+  tts(body2) {
+    return this.request("POST", "/tts", { body: body2, timeoutMs: 9e4 });
   }
   models() {
     return this.request("GET", "/models");
@@ -21300,11 +21302,11 @@ var BeplusClient = class {
   me(billing) {
     return this.request("GET", "/me", { query: { billing } });
   }
-  readProvenance(body) {
-    return this.request("POST", "/read-provenance", { body, timeoutMs: 3e4 });
+  readProvenance(body2) {
+    return this.request("POST", "/read-provenance", { body: body2, timeoutMs: 3e4 });
   }
-  analyzeMedia(body) {
-    return this.request("POST", "/analyze-media", { body, timeoutMs: 3e5 });
+  analyzeMedia(body2) {
+    return this.request("POST", "/analyze-media", { body: body2, timeoutMs: 3e5 });
   }
   searchCalls(query) {
     return this.request("GET", "/calls", {
@@ -22872,7 +22874,7 @@ function registerAudioTools(server, client, cfg) {
     },
     async (args) => {
       try {
-        const body = compact({
+        const body2 = compact({
           text: args.text,
           voice: args.voice,
           model: args.model,
@@ -22880,7 +22882,7 @@ function registerAudioTools(server, client, cfg) {
           multiSpeaker: args.multi_speaker,
           project: args.project ?? cfg.activeProject ?? void 0
         });
-        const res = await client.tts(body);
+        const res = await client.tts(body2);
         const parts = [`Custo: ${res.diamond_cost} \u{1F48E}`];
         if (res.diamonds_refunded) parts.push(`Estorno: ${res.diamonds_refunded} \u{1F48E}`);
         const projLine = res.project_code ? `
@@ -23376,11 +23378,11 @@ function fmtDate(iso) {
 function callLine(c) {
   const company = c.company_name ? ` \xB7 ${c.company_name}` : "";
   const proj = c.project_name ? ` \xB7 ${c.client_name ? c.client_name + " / " : ""}${c.project_name}` : "";
-  const who = c.speakers.length ? ` \xB7 ${c.speakers.join(", ")}` : c.participant_count ? ` \xB7 ${c.participant_count} falantes` : "";
+  const who2 = c.speakers.length ? ` \xB7 ${c.speakers.join(", ")}` : c.participant_count ? ` \xB7 ${c.participant_count} falantes` : "";
   const vis = VIS_LABEL[c.visibility] ?? c.visibility;
   const flag = c.status !== "ready" ? ` [${c.status}]` : "";
   return `\u2022 ${c.title ?? "(sem t\xEDtulo)"}${flag}
-  ${fmtDate(c.date)} \xB7 ${fmtDuration(c.duration_sec)} \xB7 ${vis}${company}${proj}${who}
+  ${fmtDate(c.date)} \xB7 ${fmtDuration(c.duration_sec)} \xB7 ${vis}${company}${proj}${who2}
   id: ${c.id}`;
 }
 function renderCall(c) {
@@ -23466,11 +23468,1381 @@ ${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 commentPacing = {
+  perMinute: 50,
+  retryWaitsMs: [5e3, 15e3, 45e3],
+  now: () => Date.now(),
+  sleep: (ms) => new Promise((r) => setTimeout(r, Math.max(0, ms)))
+};
+var CanvasApi = class {
+  constructor(client, cfg) {
+    this.client = client;
+    this.cfg = cfg;
+  }
+  client;
+  cfg;
+  coreVersion = PINNED_CORE_VERSION;
+  userId = null;
+  /** Instantes das escritas de comentário no último minuto. */
+  writes = [];
+  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(body2) {
+    return this.req("POST", "/boards", { body: body2 });
+  }
+  snapshot(boardId3) {
+    return this.req("GET", `/boards/${boardId3}`);
+  }
+  /** Replay depois de `after`. `null` quando o servidor manda reler a foto (410). */
+  async opsAfter(boardId3, after) {
+    try {
+      const { envelopes } = await this.req("GET", `/boards/${boardId3}/ops`, {
+        query: { after }
+      });
+      return envelopes;
+    } catch (e) {
+      if (e instanceof ApiError && e.httpStatus === 410) return null;
+      throw e;
+    }
+  }
+  async commit(boardId3, ops) {
+    const send = () => this.req("POST", `/boards/${boardId3}/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(boardId3) {
+    return this.req("GET", `/boards/${boardId3}/members`);
+  }
+  putMember(boardId3, userId, role) {
+    return this.req("PUT", `/boards/${boardId3}/members/${userId}`, { body: { role } });
+  }
+  removeMember(boardId3, userId) {
+    return this.req("DELETE", `/boards/${boardId3}/members/${userId}`);
+  }
+  // ── comentários (academy-backend #313) ────────────────────────────────────
+  listComments(boardId3, status = "open") {
+    return this.req("GET", `/boards/${boardId3}/comments`, { query: { status } });
+  }
+  /**
+   * Escrita de comentário passa por aqui: o back limita a 60 por minuto por pessoa
+   * (balde fixo, sem Retry-After). O MCP se espaça abaixo do teto e, se ainda
+   * assim vier 429 (a pessoa também comentando no Canvas), espera e tenta de novo.
+   */
+  async write(method, path, body2) {
+    const p = commentPacing;
+    const now = p.now();
+    this.writes = this.writes.filter((t) => now - t < 6e4);
+    if (this.writes.length >= p.perMinute) {
+      await p.sleep(this.writes[0] + 6e4 - now);
+      this.writes.shift();
+    }
+    for (let attempt = 0; ; attempt++) {
+      this.writes.push(p.now());
+      try {
+        return await this.req(method, path, body2 === void 0 ? {} : { body: body2 });
+      } catch (e) {
+        if (!(e instanceof ApiError) || e.httpStatus !== 429 || attempt >= p.retryWaitsMs.length) throw e;
+        await p.sleep(p.retryWaitsMs[attempt]);
+      }
+    }
+  }
+  /** Raiz ou resposta. O back devolve sempre a THREAD DA RAIZ (resposta nova = última de `replies`). */
+  createComment(boardId3, body2) {
+    return this.write("POST", `/boards/${boardId3}/comments`, body2);
+  }
+  resolveComment(boardId3, commentId2) {
+    return this.write("POST", `/boards/${boardId3}/comments/${commentId2}/resolve`);
+  }
+  reopenComment(boardId3, commentId2) {
+    return this.write("POST", `/boards/${boardId3}/comments/${commentId2}/reopen`);
+  }
+  /** 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;
+};
+var CanvasToolError = class extends Error {
+};
+
+// 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(boardId3, op, actorId) {
+  return { id: randomUUID(), boardId: boardId3, 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/canvas/comments.ts
+function mmss(t) {
+  const total = Math.max(0, Math.floor(t));
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = total % 60;
+  const pad = (n) => String(n).padStart(2, "0");
+  return h ? `${h}:${pad(m)}:${pad(s)}` : `${pad(m)}:${pad(s)}`;
+}
+function nodeRef(doc, nodeId) {
+  const node = doc.nodes[nodeId];
+  const kind = nodeKind(node) ?? node.type;
+  return `"${oneLine(nodeName(node), 60)}" (${kind}, ${node.id})`;
+}
+function hashString(text) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  const hex = (n) => (n >>> 0).toString(16).padStart(8, "0");
+  return hex(h2) + hex(h1);
+}
+function outputKeyOf(entry) {
+  for (const field of [entry.resultId, entry.id, entry.generationId]) {
+    if (typeof field === "string" && field !== "" && field.length <= 128) return field;
+  }
+  if (typeof entry.url === "string" && entry.url !== "") return `url-${hashString(entry.url)}`;
+  return null;
+}
+function versionOf(doc, nodeId, outputKey) {
+  const ids = doc.nodeHistory?.[nodeId];
+  if (Array.isArray(ids)) {
+    const i = ids.indexOf(outputKey);
+    if (i >= 0) return i + 1;
+  }
+  const history = doc.nodes[nodeId]?.data.history;
+  if (Array.isArray(history)) {
+    const i = history.findIndex(
+      (h) => typeof h === "object" && h !== null && !Array.isArray(h) && outputKeyOf(h) === outputKey
+    );
+    if (i >= 0) return history.length - i;
+  }
+  return null;
+}
+function describeAnchor(anchor, doc) {
+  if (!anchor || anchor.kind === "point") return { text: "no board" };
+  const exists = !!doc.nodes[anchor.nodeId];
+  if (!exists) {
+    return { text: `no n\xF3 ${anchor.nodeId}`, gone: "o n\xF3 foi apagado" };
+  }
+  const ref = nodeRef(doc, anchor.nodeId);
+  switch (anchor.kind) {
+    case "node":
+      return { text: `no n\xF3 ${ref}`, nodeId: anchor.nodeId };
+    case "output": {
+      const v = versionOf(doc, anchor.nodeId, anchor.outputKey);
+      return v === null ? { text: `numa vers\xE3o de ${ref} (${anchor.outputKey})`, nodeId: anchor.nodeId, gone: "essa vers\xE3o n\xE3o est\xE1 mais no hist\xF3rico do n\xF3" } : { text: `na vers\xE3o ${v} de ${ref}`, nodeId: anchor.nodeId };
+    }
+    case "timecode": {
+      const node = doc.nodes[anchor.nodeId];
+      const kind = nodeKind(node);
+      const t = mmss(Number(anchor.t) || 0);
+      if (kind === "montage") {
+        const name = nodeName(node);
+        const title = name === KINDS.montage.title ? "" : ` "${oneLine(name, 60)}"`;
+        return { text: `em ${t} da Montagem${title} (${node.id})`, nodeId: anchor.nodeId };
+      }
+      return { text: `em ${t} de ${ref}`, nodeId: anchor.nodeId };
+    }
+    default:
+      return { text: "no board" };
+  }
+}
+function who(c) {
+  return c.author?.name?.trim() || "algu\xE9m";
+}
+function reactionsText(r) {
+  if (Array.isArray(r)) {
+    const parts = r.map((x) => {
+      const rec = x ?? {};
+      const emoji2 = typeof rec.emoji === "string" ? rec.emoji : null;
+      const n = typeof rec.count === "number" ? rec.count : Array.isArray(rec.userIds) ? rec.userIds.length : Array.isArray(rec.users) ? rec.users.length : 1;
+      return emoji2 ? `${emoji2}${n > 1 ? `\xD7${n}` : ""}` : null;
+    }).filter(Boolean);
+    return parts.join(" ");
+  }
+  if (r && typeof r === "object") {
+    return Object.entries(r).map(([emoji2, v]) => {
+      const n = Array.isArray(v) ? v.length : typeof v === "number" ? v : 1;
+      return `${emoji2}${n > 1 ? `\xD7${n}` : ""}`;
+    }).join(" ");
+  }
+  return "";
+}
+var MAX_REPLIES = 5;
+function threadLines(t, doc) {
+  const where = describeAnchor(t.anchor, doc);
+  const state = t.resolvedAt ? " \xB7 RESOLVIDO" : "";
+  const reacts = reactionsText(t.reactions);
+  const lines = t.deleted ? [`- ${t.id} \xB7 ${where.text}${state}`, "  (coment\xE1rio raiz apagado: n\xE3o d\xE1 para responder nem resolver)"] : [`- ${t.id} \xB7 ${where.text} \xB7 ${who(t)}${state}${reacts ? ` \xB7 ${reacts}` : ""}`, `  pedido: ${oneLine(t.body ?? "", 400)}`];
+  if (where.gone && !t.deleted) lines.push(`  \u26A0 ALVO SUMIU: ${where.gone}. Responda com pergunta, n\xE3o resolva.`);
+  const replies = Array.isArray(t.replies) ? t.replies : [];
+  for (const r of replies.slice(-MAX_REPLIES)) {
+    lines.push(r.deleted ? "  \u21B3 (resposta apagada)" : `  \u21B3 ${who(r)}: ${oneLine(r.body ?? "", 140)}`);
+  }
+  if (replies.length > MAX_REPLIES) lines.splice(lines.length - MAX_REPLIES, 0, `  \u21B3 \u2026 ${replies.length - MAX_REPLIES} resposta(s) antes`);
+  return lines;
+}
+function commentsSummary(threads, doc, status) {
+  const label = status === "resolved" ? "resolvido(s)" : status === "all" ? "no total" : "aberto(s)";
+  if (!threads.length) return `Nenhum coment\xE1rio ${label === "no total" ? "no board" : label}.`;
+  const out = [`${threads.length} coment\xE1rio(s) ${label}:`];
+  for (const t of threads) out.push(...threadLines(t, doc));
+  return out.join("\n");
+}
+
+// src/tools/canvas-comments.ts
+var boardId = external_exports.string().uuid().describe("Id (uuid) do board.");
+var commentId = external_exports.string().min(1).max(128).describe("Id do coment\xE1rio raiz, como sai em canvas_list_comments.");
+var body = external_exports.string().trim().min(1).max(4e3);
+var mentions = external_exports.array(external_exports.string().uuid()).max(50).optional().describe("userIds a marcar (opcional; quem n\xE3o \xE9 membro \xE9 ignorado).");
+function registerCanvasCommentTools(server, api, run) {
+  async function onComment(fn) {
+    try {
+      return await fn();
+    } catch (e) {
+      if (!(e instanceof ApiError)) throw e;
+      if (e.httpStatus === 404) {
+        throw new CanvasToolError("Coment\xE1rio (ou board) n\xE3o encontrado ou apagado. Liste de novo com canvas_list_comments.");
+      }
+      if (e.httpStatus === 400) throw new CanvasToolError(`O servidor recusou o coment\xE1rio: ${e.message}.`);
+      if (e.httpStatus === 403 && (!api.usesPat || /ialab:/.test(e.message))) {
+        throw new CanvasToolError(
+          "O login pelo navegador deste MCP n\xE3o tem a permiss\xE3o ialab:spend, que toda escrita de coment\xE1rio exige. Rode `beplus-mcp login` de novo e autorize a permiss\xE3o de gastar/editar."
+        );
+      }
+      if (e.httpStatus === 403) throw new CanvasToolError(`Sem permiss\xE3o: ${e.message}.`);
+      if (e.httpStatus === 429) {
+        throw new CanvasToolError(
+          "Limite de escrita em coment\xE1rios (60 por minuto por pessoa) mesmo depois de esperar. Pare o lote, diga \xE0 pessoa quais j\xE1 foram fechados e siga daqui a 1 minuto a partir do pr\xF3ximo."
+        );
+      }
+      throw e;
+    }
+  }
+  const newReplyId = (thread) => {
+    const last = thread?.replies?.at(-1);
+    return last?.id ?? "?";
+  };
+  server.registerTool(
+    "canvas_list_comments",
+    {
+      title: "Canvas: listar coment\xE1rios",
+      description: "Lista os coment\xE1rios de um board (padr\xE3o: abertos): id, onde est\xE1 (n\xF3, vers\xE3o, minutagem da Montagem ou board), autor, pedido e respostas. Avisa quando o alvo sumiu. S\xF3 leitura.",
+      inputSchema: {
+        board_id: boardId,
+        status: external_exports.enum(["open", "resolved", "all"]).optional().describe("open (padr\xE3o), resolved ou all.")
+      },
+      annotations: { readOnlyHint: true, openWorldHint: false }
+    },
+    async ({ board_id, status }) => run(async () => {
+      const st = status ?? "open";
+      const [snap, threads] = await Promise.all([api.snapshot(board_id), api.listComments(board_id, st)]);
+      const text = commentsSummary(threads, snap.doc, st);
+      const open2 = threads.some((t) => !t.resolvedAt);
+      return open2 ? `${text}
+
+Para aplicar: leia o n\xF3 com canvas_read_board (node_ids), edite pelas canvas_* e feche com canvas_resolve_comment dizendo o que fez.` : text;
+    })
+  );
+  server.registerTool(
+    "canvas_reply_comment",
+    {
+      title: "Canvas: responder coment\xE1rio",
+      description: "Responde numa thread de coment\xE1rio sem resolver. Use para perguntar quando o pedido \xE9 amb\xEDguo ou o alvo sumiu.",
+      inputSchema: { board_id: boardId, comment_id: commentId, body, mentions },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    async ({ board_id, comment_id, body: text, mentions: m }) => run(async () => {
+      const thread = await onComment(
+        () => api.createComment(board_id, { body: text, parentId: comment_id, ...m?.length ? { mentions: m } : {} })
+      );
+      const open2 = thread?.resolvedAt ? "A thread est\xE1 resolvida; reabra com canvas_reopen_comment se precisar." : "A thread segue aberta.";
+      return `\u2705 Resposta ${newReplyId(thread)} em ${comment_id}: "${oneLine(text, 120)}". ${open2}`;
+    })
+  );
+  server.registerTool(
+    "canvas_resolve_comment",
+    {
+      title: "Canvas: resolver coment\xE1rio",
+      description: "Fecha um coment\xE1rio depois de aplicar o ajuste. done \xE9 obrigat\xF3rio: uma frase curta dizendo o que foi feito (vira resposta na thread antes de resolver). N\xE3o resolva pedido amb\xEDguo nem com alvo sumido: responda com pergunta.",
+      inputSchema: {
+        board_id: boardId,
+        comment_id: commentId,
+        done: external_exports.string().trim().min(3).max(500).describe('O que foi feito, ex.: "troquei a fala do b2 e encurtei o b3".')
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    async ({ board_id, comment_id, done }) => run(async () => {
+      const thread = await onComment(() => api.createComment(board_id, { body: done, parentId: comment_id }));
+      const replyId = newReplyId(thread);
+      try {
+        await onComment(() => api.resolveComment(board_id, comment_id));
+      } catch (e) {
+        const why = e instanceof Error ? e.message : String(e);
+        throw new CanvasToolError(
+          `A resposta "${oneLine(done, 80)}" (${replyId}) foi postada em ${comment_id}, mas resolver falhou: ${why} N\xE3o repita canvas_resolve_comment (postaria a resposta de novo): avise a pessoa para resolver no Canvas.`
+        );
+      }
+      return `\u2705 Resolvido ${comment_id}: "${oneLine(done, 120)}" (resposta ${replyId}).`;
+    })
+  );
+  server.registerTool(
+    "canvas_reopen_comment",
+    {
+      title: "Canvas: reabrir coment\xE1rio",
+      description: "Reabre um coment\xE1rio resolvido. why (opcional) vira resposta na thread explicando o motivo.",
+      inputSchema: { board_id: boardId, comment_id: commentId, why: external_exports.string().trim().min(1).max(1e3).optional() },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    async ({ board_id, comment_id, why }) => run(async () => {
+      await onComment(() => api.reopenComment(board_id, comment_id));
+      if (why) await onComment(() => api.createComment(board_id, { body: why, parentId: comment_id }));
+      return `\u2705 Reaberto ${comment_id}${why ? ` com a resposta "${oneLine(why, 120)}"` : ""}.`;
+    })
+  );
+  server.registerTool(
+    "canvas_comment",
+    {
+      title: "Canvas: comentar",
+      description: "Cria um coment\xE1rio novo (raiz), ancorado para aparecer no lugar certo do Canvas. Use para deixar uma pergunta ou observa\xE7\xE3o para a pessoa. \xC2ncora: node_id (no n\xF3); node_id + output_key (numa vers\xE3o gerada); node_id + t em segundos (minutagem da Montagem ou do v\xEDdeo); x,y (ponto do board); nada = acima do conte\xFAdo do board.",
+      inputSchema: {
+        board_id: boardId,
+        body,
+        node_id: external_exports.string().min(1).max(64).optional(),
+        output_key: external_exports.string().min(1).max(128).optional().describe("Id da vers\xE3o (resultado) do n\xF3."),
+        t: external_exports.number().finite().min(0).optional().describe("Segundos desde o in\xEDcio."),
+        x: external_exports.number().finite().optional(),
+        y: external_exports.number().finite().optional(),
+        mentions
+      },
+      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+    },
+    async (args) => run(async () => {
+      if (!args.node_id && (args.output_key !== void 0 || args.t !== void 0)) {
+        throw new CanvasToolError("output_key e t precisam de node_id.");
+      }
+      if (args.output_key !== void 0 && args.t !== void 0) throw new CanvasToolError("Use output_key ou t, n\xE3o os dois.");
+      if (args.x === void 0 !== (args.y === void 0)) throw new CanvasToolError("Informe x e y juntos.");
+      const snap = await api.snapshot(args.board_id);
+      let anchor;
+      if (args.node_id) {
+        if (!snap.doc.nodes[args.node_id]) {
+          throw new CanvasToolError(`N\xF3 ${args.node_id} n\xE3o existe no board. Releia com canvas_read_board.`);
+        }
+        if (args.output_key !== void 0) anchor = { kind: "output", nodeId: args.node_id, outputKey: args.output_key };
+        else if (args.t !== void 0) anchor = { kind: "timecode", nodeId: args.node_id, t: args.t };
+        else anchor = { kind: "node", nodeId: args.node_id, dx: 0, dy: 0 };
+      } else if (args.x !== void 0 && args.y !== void 0) {
+        anchor = { kind: "point", x: args.x, y: args.y };
+      } else {
+        const nodes = Object.values(snap.doc.nodes);
+        anchor = nodes.length ? { kind: "point", x: Math.min(...nodes.map((n) => n.position.x)), y: Math.min(...nodes.map((n) => n.position.y)) - 80 } : { kind: "point", x: 0, y: 0 };
+      }
+      const created = await onComment(
+        () => api.createComment(args.board_id, {
+          body: args.body,
+          anchor,
+          ...args.mentions?.length ? { mentions: args.mentions } : {}
+        })
+      );
+      const where = describeAnchor(anchor, snap.doc).text;
+      const at = anchor.kind === "point" && args.x !== void 0 ? ` em (${args.x}, ${args.y})` : "";
+      return `\u2705 Coment\xE1rio ${created?.id ?? ""} criado ${where}${at}.`.replace("  ", " ");
+    })
+  );
+}
+
+// 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 boardId2 = 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: boardId2,
+        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: boardId2,
+        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: boardId2,
+        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: boardId2,
+        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: boardId2,
+        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: boardId2, 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: boardId2 },
+      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: boardId2,
+        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: boardId2, 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.`;
+    })
+  );
+  registerCanvasCommentTools(server, api, run);
+}
+
 // 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.27.0") return "0.27.0";
   try {
     const pkg = require2("../package.json");
     return pkg.version ?? "0.0.0-unknown";
@@ -23481,8 +24853,15 @@ 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.",
+  '"Aplica os coment\xE1rios" do board: canvas_list_comments (abertos) \u2192 para cada um, leia o n\xF3 ancorado com canvas_read_board (node_ids), aplique a edi\xE7\xE3o pelas canvas_* e feche com canvas_resolve_comment dizendo em uma frase o que fez. Coment\xE1rio amb\xEDguo ou com alvo sumido: responda com pergunta (canvas_reply_comment) e n\xE3o resolva. D\xFAvida sua sobre um n\xF3: canvas_comment ancorado nele. As escritas j\xE1 saem espa\xE7adas (60/min); se ainda vier limite, pare e diga de onde seguir.'
+].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 +24872,7 @@ function buildServer(cfg) {
   registerProjectTools(server, client, cfg);
   registerClientTools(server, client, cfg);
   registerCallTools(server, client, cfg);
+  registerCanvasTools(server, client, cfg);
   return { server, client };
 }
 
@@ -23732,16 +25112,16 @@ async function json(url, init) {
     throw new Error(`Nao consegui falar com ${new URL(url).origin}. Confira a rede e o BEPLUS_API_URL.`);
   }
   const text = await res.text();
-  let body;
+  let body2;
   try {
-    body = text ? JSON.parse(text) : void 0;
+    body2 = text ? JSON.parse(text) : void 0;
   } catch {
   }
   if (!res.ok) {
-    const msg = body?.message ?? body?.error_description ?? body?.error ?? `HTTP ${res.status}`;
+    const msg = body2?.message ?? body2?.error_description ?? body2?.error ?? `HTTP ${res.status}`;
     throw new Error(`${msg} (${url})`);
   }
-  return body;
+  return body2;
 }
 async function discover(apiUrl2) {
   const meta = await json(`${apiUrl2}/.well-known/oauth-authorization-server`);