aicrm-mcp 0.3.0 → 0.6.0

package/dist/cli.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
 import { homedir as homedir3, hostname } from "os";
-import path3 from "path";
+import path4 from "path";
 
 // src/client.ts
 var ApiError = class extends Error {
@@ -16,8 +16,8 @@ var ApiError = class extends Error {
 function normalizeUrl(url) {
   return url.replace(/\/+$/, "").replace(/\/api$/, "");
 }
-async function call(base, method, path4, body, token) {
-  const res = await fetch(`${normalizeUrl(base)}/api${path4}`, {
+async function call(base, method, path5, body, token) {
+  const res = await fetch(`${normalizeUrl(base)}/api${path5}`, {
     method,
     headers: {
       ...body !== void 0 ? { "content-type": "application/json" } : {},
@@ -125,12 +125,13 @@ function askHidden(question) {
 }
 
 // src/server.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import path2 from "path";
+import path3 from "path";
 
 // ../shared/src/constants.ts
-var ROLES = ["admin", "member"];
+var ROLES = ["admin", "manager", "member", "developer"];
+var LEAD_CHANNELS = ["web", "import", "api"];
 var LEAD_STATUSES = ["open", "won", "lost"];
 var LOST_REASONS = ["price", "timing", "competitor", "no_response", "no_fit", "other"];
 var LEAD_SOURCES = ["inbound", "outbound", "referral", "event", "partner", "other"];
@@ -169,6 +170,9 @@ var FUNNEL_TEMPLATES = {
     ]
   }
 };
+var DEFAULT_STAGE_LIMIT_DAYS = 14;
+var DONE_EVENT_TYPES = ["note", "updated", "stage_changed", "status_changed"];
+var ACTIVITY_EVENT_TYPES = [...DONE_EVENT_TYPES, "created", "handed_off"];
 var CUSTOM_FIELD_TYPES = ["text", "number", "money", "date", "select", "boolean", "url"];
 var CUSTOM_FIELD_TYPE_LABEL = {
   text: "Texto",
@@ -307,6 +311,11 @@ var updateUserSchema = z.object({
   active: z.boolean().optional(),
   workspaceIds: z.array(id).optional()
 });
+var imageDataUrl = z.string().regex(/^data:image\/(png|jpeg|webp);base64,[A-Za-z0-9+/=]+$/, "Envie uma imagem PNG, JPG ou WebP").max(4e5, "Imagem muito grande (m\xE1x. ~300 KB)");
+var profileUpdateSchema = z.object({
+  /** Photo as a data URL, or null to go back to the initials. */
+  avatar: imageDataUrl.nullable()
+});
 var workspaceSchema = z.object({
   name: z.string().trim().min(1, "Informe um nome").max(80),
   visibility: z.enum(VISIBILITIES).default("all")
@@ -315,19 +324,23 @@ var workspaceUpdateSchema = z.object({
   name: z.string().trim().min(1, "Informe um nome").max(80).optional(),
   visibility: z.enum(VISIBILITIES).optional(),
   hiddenFields: z.array(z.enum(HIDEABLE_FIELDS)).transform((a) => [...new Set(a)]).optional(),
-  /** Raster data URL (PNG/JPEG/WebP), or null to remove. SVG is rejected: the browser rasterizes it first. */
-  logo: z.string().regex(/^data:image\/(png|jpeg|webp);base64,[A-Za-z0-9+/=]+$/, "Envie uma imagem PNG, JPG ou WebP").max(4e5, "Imagem muito grande (m\xE1x. ~300 KB)").nullable().optional()
+  /** Standard fields every new lead must fill. */
+  requiredFields: z.array(z.enum(HIDEABLE_FIELDS)).transform((a) => [...new Set(a)]).optional(),
+  /** Raster data URL, or null to remove. */
+  logo: imageDataUrl.nullable().optional()
 });
 var fieldOptions = z.array(z.string().trim().min(1).max(60)).max(100, "No m\xE1ximo 100 op\xE7\xF5es").transform((o) => [...new Set(o)]);
 var leadFieldSchema = z.object({
   label: z.string().trim().min(1, "D\xEA um nome ao campo").max(60),
   type: z.enum(CUSTOM_FIELD_TYPES),
-  options: fieldOptions.default([])
+  options: fieldOptions.default([]),
+  required: z.boolean().default(false)
 }).refine((f) => f.type !== "select" || f.options.length > 0, { message: "Adicione pelo menos uma op\xE7\xE3o", path: ["options"] });
 var leadFieldUpdateSchema = z.object({
   label: z.string().trim().min(1).max(60).optional(),
   options: fieldOptions.optional(),
-  position: z.number().optional()
+  position: z.number().optional(),
+  required: z.boolean().optional()
 });
 var customInput = z.record(z.string().uuid(), z.union([z.string().max(2e3), z.number(), z.boolean(), z.null()]));
 var importTargetSchema = z.custom(
@@ -338,7 +351,9 @@ var importTemplateUpdateSchema = z.object({ name: z.string().trim().min(1).max(8
 var stageInputSchema = z.object({
   id: id.optional(),
   name: z.string().trim().min(1).max(60),
-  probability: z.number().int().min(0).max(100)
+  probability: z.number().int().min(0).max(100),
+  /** "Prazo da etapa" in business days; null = default. Omitted on update = keep the current one. */
+  limitDays: z.number().int().min(1).max(365).nullish()
 });
 var funnelSchema = z.object({
   workspaceId: id,
@@ -347,7 +362,8 @@ var funnelSchema = z.object({
   goalStageIndex: z.number().int().min(0).optional(),
   template: z.enum(Object.keys(FUNNEL_TEMPLATES)).optional(),
   stages: z.array(stageInputSchema).min(1).max(20).optional(),
-  nextFunnelId: id.nullish()
+  nextFunnelId: id.nullish(),
+  autoAssign: z.boolean().optional()
 });
 var funnelUpdateSchema = z.object({
   name: z.string().trim().min(1).max(80).optional(),
@@ -355,6 +371,7 @@ var funnelUpdateSchema = z.object({
   goalStageId: id.nullable().optional(),
   stages: z.array(stageInputSchema).min(1).max(20).optional(),
   nextFunnelId: id.nullable().optional(),
+  autoAssign: z.boolean().optional(),
   archived: z.boolean().optional()
 });
 var optionalText = (max) => z.string().trim().max(max).nullish().transform((v) => v ? v : null);
@@ -374,7 +391,7 @@ var leadInputSchema = z.object({
   expectedCloseAt: dateStr.nullish(),
   custom: customInput.optional()
 });
-var leadUpdateSchema = leadInputSchema.omit({ funnelId: true, stageId: true }).partial();
+var leadUpdateSchema = leadInputSchema.omit({ funnelId: true, stageId: true }).extend({ valueCents: z.number().int().min(0).max(1e13) }).partial();
 var moveLeadSchema = z.object({
   funnelId: id.optional(),
   stageId: id
@@ -400,6 +417,8 @@ var leadQuerySchema = z.object({
   status: z.enum(LEAD_STATUSES).optional(),
   q: z.string().max(120).optional(),
   filter: z.enum(["mine", "stale", "no_next_step"]).optional(),
+  /** How leads got in: typed, imported or through the API. */
+  createdVia: z.enum(LEAD_CHANNELS).optional(),
   limit: z.coerce.number().int().min(1).max(1e3).default(500)
 });
 var bulkLeadSchema = z.object({
@@ -408,10 +427,13 @@ var bulkLeadSchema = z.object({
   stageId: id.optional(),
   funnelId: id.optional()
 });
+var bulkDeleteSchema = z.object({
+  leadIds: z.array(id).min(1).max(1e3)
+});
 var importSchema = z.object({
   funnelId: id,
   stageId: id,
-  ownerMode: z.enum(["fixed", "column", "round_robin"]),
+  ownerMode: z.enum(["fixed", "column", "round_robin", "auto"]),
   ownerId: id.optional(),
   duplicate: z.enum(["skip", "update"]).default("skip"),
   rows: z.array(
@@ -433,6 +455,11 @@ var importSchema = z.object({
     id: id.optional(),
     name: z.string().trim().min(1).max(80),
     columns: z.record(z.string().max(200), importTargetSchema)
+  }).optional(),
+  /** Where the data came from, kept in the lead's history so people can see e.g. which column filled "Valor". */
+  origin: z.object({
+    fileName: z.string().max(200).optional(),
+    valueColumn: z.string().max(200).optional()
   }).optional()
 });
 var commissionTierSchema = z.object({
@@ -464,6 +491,68 @@ var tvLinkSchema = z.object({
   funnelId: id,
   name: z.string().trim().min(1).max(80)
 });
+var API_KEY_KINDS = ["secret", "publishable"];
+var API_KEY_MODES = ["live", "test"];
+var origin = z.string().trim().min(1).max(200).transform((v, ctx2) => {
+  try {
+    return new URL(/^[a-z]+:\/\//i.test(v) ? v : `https://${v}`).origin;
+  } catch {
+    ctx2.addIssue({ code: "custom", message: `Dom\xEDnio inv\xE1lido: ${v}` });
+    return z.NEVER;
+  }
+});
+var apiKeyCreateSchema = z.object({
+  name: z.string().trim().min(1, "D\xEA um nome para a chave").max(60),
+  kind: z.enum(API_KEY_KINDS),
+  mode: z.enum(API_KEY_MODES),
+  /** Workspaces the key reaches (secret keys). Empty = every workspace the creator reaches. */
+  workspaceIds: z.array(id).default([]),
+  /** The only funnel a publishable key creates leads in. */
+  funnelId: id.optional(),
+  /** Sites allowed to use a publishable key. Empty = any site. */
+  allowedOrigins: z.array(origin).max(20).default([])
+}).refine((k) => k.kind !== "publishable" || k.funnelId, { message: "Escolha o funil onde a chave do site cria leads", path: ["funnelId"] });
+var apiScalar = z.union([z.string().max(2e3), z.number(), z.boolean(), z.null()]);
+var apiText = (max) => z.string().trim().max(max).nullish();
+var apiLeadFields = {
+  name: z.string().trim().min(1, "Informe o nome").max(160),
+  email: z.string().trim().toLowerCase().email("Email inv\xE1lido").max(200).nullish().or(z.literal("").transform(() => null)),
+  phone: apiText(40),
+  company: apiText(160),
+  title: apiText(120),
+  value: z.union([z.number().min(0).max(1e11), z.string().max(40)]).nullish(),
+  source: z.enum(LEAD_SOURCES).nullish(),
+  owner: z.string().trim().toLowerCase().email("Use o email de quem vai cuidar do lead").nullish(),
+  nextStep: apiText(200),
+  nextStepAt: dateStr.nullish(),
+  expectedCloseAt: dateStr.nullish(),
+  /** Custom fields by label ("Cidade") or id. */
+  fields: z.record(z.string().max(100), apiScalar).optional(),
+  /** Free extra data (UTMs, landing page…), at most ~8 KB. */
+  metadata: z.record(z.string().max(100), z.unknown()).refine((m) => JSON.stringify(m).length <= 8e3, "metadata muito grande (m\xE1x. 8 KB)").optional()
+};
+var apiLeadCreateSchema = z.object({
+  /** Funnel by name or id. Publishable keys may leave it out: they always use their own funnel. */
+  funnel: z.string().trim().min(1).max(120).optional(),
+  /** Stage by name or id; defaults to the first stage. */
+  stage: z.string().trim().max(120).optional(),
+  /** Only needed when two workspaces have a funnel with the same name. */
+  workspace: z.string().trim().max(120).optional(),
+  /** Id of the lead in your system: sending it again updates the same lead. */
+  externalId: z.string().trim().min(1).max(200).optional(),
+  ...apiLeadFields
+});
+var apiLeadUpdateSchema = z.object({
+  ...apiLeadFields,
+  name: apiLeadFields.name.optional(),
+  stage: z.string().trim().max(120).optional(),
+  status: z.enum(LEAD_STATUSES).optional(),
+  lostReason: z.enum(LOST_REASONS).optional()
+}).refine((u) => u.status !== "lost" || u.lostReason, { message: "Informe lostReason ao marcar como perdido", path: ["lostReason"] });
+var distributionPauseSchema = z.object({
+  funnelId: id,
+  userId: id
+});
 
 // ../shared/src/format.ts
 var brl = new Intl.NumberFormat("pt-BR", { style: "currency", currency: "BRL", maximumFractionDigits: 0 });
@@ -621,6 +710,98 @@ function guessFieldType(samples) {
   return { type: "text", options: [] };
 }
 
+// ../shared/src/api-errors.ts
+var API_ERROR_HELP = {
+  missing_api_key: 'Mande a chave no cabe\xE7alho: Authorization: Bearer aicrm_sk_\u2026. Com o SDK, basta new AICRM("sua-chave").',
+  invalid_api_key: "A chave est\xE1 errada ou foi revogada. Copie de novo ou gere uma nova em Chaves de API.",
+  secret_key_in_browser: "Chaves secretas n\xE3o podem ir para o site, porque qualquer visitante veria a chave. Crie uma chave do tipo \u201CNo site\u201D (aicrm_pk_) e use ela no navegador.",
+  origin_not_allowed: "Inclua este dom\xEDnio na chave do site, ou crie uma chave nova com o dom\xEDnio certo (ex.: https://seusite.com.br).",
+  publishable_key_not_allowed: "Chaves do site s\xF3 criam leads. Para ler ou alterar, use uma chave secreta no seu servidor.",
+  funnel_required: 'Diga em qual funil o lead entra: { funnel: "Vendas" }. Os nomes est\xE3o em Funis e campos.',
+  funnel_not_found: "Confira o nome do funil em Funis e campos. Mai\xFAsculas e acentos n\xE3o importam. Se o funil \xE9 de outro workspace, a chave precisa ter acesso a ele.",
+  funnel_not_allowed: "A chave do site s\xF3 cria leads no funil dela. Tire o campo funnel ou use a chave certa.",
+  ambiguous_funnel: 'H\xE1 dois funis com esse nome em workspaces diferentes. Mande tamb\xE9m workspace: "Nome do workspace", ou use o id do funil.',
+  workspace_not_found: "Confira o nome do workspace em Funis e campos.",
+  stage_not_found: "Use um dos nomes de etapa listados na mensagem, ou tire o campo stage para cair na primeira etapa.",
+  field_not_found: "Use o nome do campo exatamente como aparece em Funis e campos (mai\xFAsculas e acentos n\xE3o importam).",
+  required_field_missing: "O admin marcou este campo como obrigat\xF3rio. Mande o valor dele no lead.",
+  invalid_field: "O valor n\xE3o combina com o tipo do campo. Veja o exemplo na mensagem.",
+  invalid_value: 'Mande o valor em reais, como n\xFAmero (1500) ou texto ("R$ 1.500,00").',
+  invalid_request: "Algum dado veio no formato errado. A mensagem diz qual.",
+  owner_not_found: "Use o email de algu\xE9m do time que trabalha nesse workspace, ou tire o owner para a distribui\xE7\xE3o decidir.",
+  lead_not_found: "A API s\xF3 enxerga leads criados pela API, e com uma chave do mesmo modo (teste ou produ\xE7\xE3o).",
+  rate_limited: "Muitas requisi\xE7\xF5es em pouco tempo. Espere um minuto. Para cargas grandes, importe uma planilha.",
+  not_found: "Essa rota n\xE3o existe. Veja as rotas em Documenta\xE7\xE3o.",
+  internal_error: "Erro do nosso lado. Tente de novo em instantes."
+};
+
+// ../shared/src/stats/calendar.ts
+function toDateStr(d) {
+  return d.toISOString().slice(0, 10);
+}
+function parseDate(s) {
+  return /* @__PURE__ */ new Date(`${s}T00:00:00Z`);
+}
+function addDays(s, n) {
+  const d = parseDate(s);
+  d.setUTCDate(d.getUTCDate() + n);
+  return toDateStr(d);
+}
+function localDate(instant, timeZone) {
+  const d = instant instanceof Date ? instant : new Date(instant);
+  return new Intl.DateTimeFormat("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit" }).format(d);
+}
+function easterSunday(year) {
+  const a = year % 19;
+  const b = Math.floor(year / 100);
+  const c = year % 100;
+  const d = Math.floor(b / 4);
+  const e = b % 4;
+  const f = Math.floor((b + 8) / 25);
+  const g = Math.floor((b - f + 1) / 3);
+  const h = (19 * a + b - d - g + 15) % 30;
+  const i = Math.floor(c / 4);
+  const k = c % 4;
+  const l = (32 + 2 * e + 2 * i - h - k) % 7;
+  const m = Math.floor((a + 11 * h + 22 * l) / 451);
+  const month = Math.floor((h + l - 7 * m + 114) / 31);
+  const day = (h + l - 7 * m + 114) % 31 + 1;
+  return `${year}-${String(month).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+}
+var holidayCache = /* @__PURE__ */ new Map();
+function brazilianHolidays(year) {
+  const cached = holidayCache.get(year);
+  if (cached) return cached;
+  const easter = easterSunday(year);
+  const fixed = ["01-01", "04-21", "05-01", "09-07", "10-12", "11-02", "11-15", "11-20", "12-25"].map(
+    (md) => `${year}-${md}`
+  );
+  const set = /* @__PURE__ */ new Set([
+    ...fixed,
+    addDays(easter, -48),
+    // Carnaval (segunda)
+    addDays(easter, -47),
+    // Carnaval (terça)
+    addDays(easter, -2),
+    // Sexta-feira Santa
+    addDays(easter, 60)
+    // Corpus Christi
+  ]);
+  holidayCache.set(year, set);
+  return set;
+}
+function isBusinessDay(s) {
+  const dow = parseDate(s).getUTCDay();
+  if (dow === 0 || dow === 6) return false;
+  return !brazilianHolidays(Number(s.slice(0, 4))).has(s);
+}
+function businessDaysBetween(start, end) {
+  if (start > end) return 0;
+  let n = 0;
+  for (let d = start; d <= end; d = addDays(d, 1)) if (isBusinessDay(d)) n++;
+  return n;
+}
+
 // ../shared/src/stats/forecast.ts
 var FORECAST_STATUS_LABEL = {
   achieved: "Meta batida",
@@ -629,11 +810,36 @@ var FORECAST_STATUS_LABEL = {
   off_track: "Improv\xE1vel"
 };
 
+// ../shared/src/stats/stage-age.ts
+function stagesWithoutLimit(funnels) {
+  const out = /* @__PURE__ */ new Set();
+  for (const f of funnels) {
+    if (f.goalKpi !== "stage_reached" || !f.goalStageId) continue;
+    const goal = f.stages.find((s) => s.id === f.goalStageId);
+    if (!goal) continue;
+    for (const s of f.stages) if (s.position >= goal.position) out.add(s.id);
+  }
+  return out;
+}
+function businessDaysSince(enteredOn, today) {
+  return businessDaysBetween(addDays(enteredOn, 1), today);
+}
+function stageLevel(days, limit) {
+  if (days > 2 * limit) return "critical";
+  if (days > limit) return "late";
+  return "ok";
+}
+function stageAge(stageEnteredAt, limitDays, today, timeZone) {
+  const days = businessDaysSince(localDate(stageEnteredAt, timeZone), today);
+  const limit = limitDays ?? DEFAULT_STAGE_LIMIT_DAYS;
+  return { days, limit, level: stageLevel(days, limit) };
+}
+
 // src/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import Papa from "papaparse";
-import { z as z7 } from "zod";
+import { z as z10 } from "zod";
 
 // src/lib.ts
 var norm = (s) => s.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().trim();
@@ -646,14 +852,20 @@ function resolve(items, ref, what) {
 }
 var text = (data) => ({ content: [{ type: "text", text: typeof data === "string" ? data : JSON.stringify(data, null, 1) }] });
 async function ctx(api) {
-  const [workspaces, users] = await Promise.all([api.get("/workspaces"), api.get("/users")]);
+  const [workspaces, users, me] = await Promise.all([
+    api.get("/workspaces"),
+    api.get("/users"),
+    api.get("/auth/me")
+  ]);
   const stages = /* @__PURE__ */ new Map();
   const funnels = /* @__PURE__ */ new Map();
   for (const w of workspaces) for (const f of w.funnels) {
     funnels.set(f.id, f);
     for (const s of f.stages) stages.set(s.id, s);
   }
-  return { workspaces, users, stages, funnels, userName: (id2) => users.find((u) => u.id === id2)?.name ?? null };
+  const timezone = me.org.timezone;
+  const noLimit = stagesWithoutLimit([...funnels.values()]);
+  return { workspaces, users, stages, funnels, noLimit, timezone, today: localDate(/* @__PURE__ */ new Date(), timezone), userName: (id2) => users.find((u) => u.id === id2)?.name ?? null };
 }
 function pickWorkspace(c, ref) {
   const ws = resolve(c.workspaces, ref, "Workspace") ?? c.workspaces[0];
@@ -703,10 +915,16 @@ function leadSummary(c, l, fields) {
     value: formatMoney(l.valueCents),
     owner: c.userName(l.ownerId),
     next_step: l.nextStep ? `${l.nextStep}${l.nextStepAt ? ` (${l.nextStepAt})` : ""}` : null,
-    days_in_stage: Math.floor((Date.now() - Date.parse(l.stageEnteredAt)) / 864e5),
+    ...stageAgeSummary(c, l),
     ...Object.keys(custom).length ? { fields: custom } : {}
   };
 }
+var RISK_LEVEL_LABEL = { ok: "no prazo", late: "passou do prazo", critical: "passou do dobro do prazo" };
+function stageAgeSummary(c, l) {
+  if (l.status !== "open" || c.noLimit.has(l.stageId)) return {};
+  const age = stageAge(l.stageEnteredAt, c.stages.get(l.stageId)?.limitDays, c.today, c.timezone);
+  return { business_days_in_stage: age.days, stage_limit_days: age.limit, stage_deadline: RISK_LEVEL_LABEL[age.level] };
+}
 function describeForecast(kpi, f) {
   return {
     status: FORECAST_STATUS_LABEL[f.status],
@@ -728,7 +946,7 @@ var withApi = (fn) => async (args) => {
   try {
     return await fn(apiFor(creds), args);
   } catch (e) {
-    const msg = e instanceof ApiError && e.status === 401 ? "Sess\xE3o expirada ou revogada. Rode: npx -y aicrm-mcp login" : e instanceof ApiError && e.status === 403 ? `${e.message} (seu usu\xE1rio n\xE3o tem permiss\xE3o para isso \u2014 pe\xE7a a um admin)` : e.message;
+    const msg = e instanceof ApiError && e.status === 401 ? "Sess\xE3o expirada ou revogada. Rode: npx -y aicrm-mcp login" : e instanceof ApiError && e.status === 403 ? `${e.message} (seu usu\xE1rio n\xE3o tem permiss\xE3o para isso \u2014 pe\xE7a a um admin ou Master)` : e.message;
     return { ...text(`Erro: ${msg}`), isError: true };
   }
 };
@@ -767,8 +985,301 @@ function handoffBody(c, source, a) {
 }
 var MONTH = /^\d{4}-\d{2}$/;
 
-// src/tools/admin.ts
+// src/tools/integrate.ts
 import { z as z2 } from "zod";
+
+// src/env-file.ts
+import { appendFile, readFile as readFile2, stat, writeFile as writeFile2 } from "fs/promises";
+import path2 from "path";
+function isEnvFileName(file) {
+  const base = path2.basename(file);
+  return /^\.env(\.[\w.-]+)?$/.test(base) || /\.env$/.test(base);
+}
+var escapeRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function upsertEnv(content, vars) {
+  let out = content;
+  const replaced = [];
+  for (const [key, value] of Object.entries(vars)) {
+    const line = new RegExp(`^[ \\t]*(export[ \\t]+)?${escapeRe(key)}[ \\t]*=.*$`, "m");
+    if (line.test(out)) {
+      out = out.replace(line, `${key}=${value}`);
+      replaced.push(key);
+    } else {
+      out = `${out}${out && !out.endsWith("\n") ? "\n" : ""}${key}=${value}
+`;
+    }
+  }
+  return { content: out, replaced };
+}
+function gitignoreCovers(gitignore, fileName) {
+  return gitignore.split(/\r?\n/).map((l) => l.trim()).filter((l) => l && !l.startsWith("#") && !l.startsWith("!")).some((l) => {
+    const p = l.replace(/^\//, "").replace(/\/$/, "");
+    if (p === fileName) return true;
+    if (!p.includes("*")) return false;
+    return new RegExp(`^${p.split("*").map(escapeRe).join(".*")}$`).test(fileName);
+  });
+}
+var exists = (p) => stat(p).then(() => true, () => false);
+async function gitRoot(dir2) {
+  let d = dir2;
+  for (; ; ) {
+    if (await exists(path2.join(d, ".git"))) return d;
+    const up = path2.dirname(d);
+    if (up === d) return null;
+    d = up;
+  }
+}
+async function writeEnvVars(file, vars, cwd = process.cwd()) {
+  const target = path2.resolve(cwd, file);
+  if (!isEnvFileName(target)) throw new Error(`"${file}" n\xE3o parece um arquivo .env. Use algo como .env ou .env.local.`);
+  if (!await exists(path2.dirname(target))) throw new Error(`A pasta ${path2.dirname(target)} n\xE3o existe.`);
+  const created = !await exists(target);
+  const current = created ? "" : await readFile2(target, "utf8");
+  const { content, replaced } = upsertEnv(current, vars);
+  await writeFile2(target, content, created ? { mode: 384 } : void 0);
+  const name = path2.basename(target);
+  const root = await gitRoot(path2.dirname(target));
+  let gitignore = "Fora de um reposit\xF3rio git: nada a ignorar.";
+  if (root) {
+    const candidates = [path2.join(path2.dirname(target), ".gitignore"), path2.join(root, ".gitignore")];
+    let covered = false;
+    for (const g of candidates) if (await exists(g)) covered ||= gitignoreCovers(await readFile2(g, "utf8"), name);
+    if (covered) gitignore = `${name} j\xE1 est\xE1 no .gitignore.`;
+    else {
+      const g = path2.join(path2.dirname(target), ".gitignore");
+      const before = await exists(g) ? await readFile2(g, "utf8") : "";
+      await appendFile(g, `${before && !before.endsWith("\n") ? "\n" : ""}${name}
+`);
+      gitignore = `Adicionei ${name} ao ${path2.relative(cwd, g) || ".gitignore"} para a chave n\xE3o ir para o git.`;
+    }
+  }
+  return { path: target, created, replaced, gitignore };
+}
+
+// src/tools/integrate.ts
+var SDK_DEFAULT_URL = "https://api.aicrm.dev";
+var schema = (api) => api.get("/integrations/schema");
+function pickFunnel2(workspaces, ref, workspaceRef) {
+  const wss = workspaceRef ? [resolve(workspaces, workspaceRef, "Workspace")] : workspaces;
+  const funnels = wss.flatMap((w) => w.funnels);
+  if (!funnels.length) throw new Error("Voc\xEA n\xE3o tem acesso a nenhum funil. Pe\xE7a a um admin para incluir voc\xEA em um workspace com funil.");
+  return ref ? resolve(funnels, ref, "Funil") : funnels[0];
+}
+var describe = (f) => ({
+  funnel: f.name,
+  funnel_id: f.id,
+  workspace: f.workspace.name,
+  stages: f.stages.map((s) => s.name),
+  default_stage: f.stages[0]?.name ?? null,
+  standard_fields: f.fields.standard.map((x) => ({ key: x.key, label: x.label, type: x.type, required: x.required, ...x.options?.length ? { options: x.options } : {} })),
+  custom_fields: f.fields.custom.map((x) => ({ key: `fields.${x.key}`, label: x.label, type: x.type, required: x.required, ...x.options?.length ? { options: x.options } : {} })),
+  example_payload: { ...f.example, funnel: f.name }
+});
+var help = (code) => code ? API_ERROR_HELP[code] ?? null : null;
+var logOut = (l) => ({
+  id: l.id,
+  when: l.createdAt,
+  request: `${l.method} ${l.path}`,
+  status: l.status,
+  key: l.keyName ? `${l.keyName} (${l.keyMode === "test" ? "teste" : "produ\xE7\xE3o"})` : null,
+  ms: l.durationMs,
+  ...l.errorCode ? { error_code: l.errorCode, how_to_fix: help(l.errorCode) } : {}
+});
+async function createKeyIntoEnv(api, a, cwd = process.cwd()) {
+  const kind = a.kind ?? "secret";
+  const mode = a.mode ?? "test";
+  const envFile = a.env_file ?? ".env";
+  if (mode === "live" && !a.confirm_live)
+    throw new Error("Chave de produ\xE7\xE3o cria leads de verdade para o time. Confirme com a pessoa e chame de novo com confirm_live: true.");
+  if (!isEnvFileName(envFile)) throw new Error(`"${envFile}" n\xE3o parece um arquivo .env. Use algo como .env ou .env.local.`);
+  const envVar = a.env_var ?? (kind === "secret" ? "AICRM_API_KEY" : "AICRM_PUBLISHABLE_KEY");
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(envVar)) throw new Error(`Nome de vari\xE1vel inv\xE1lido: ${envVar}`);
+  const [workspaces, config] = await Promise.all([schema(api), api.get("/integrations/config")]);
+  const body = { name: a.name ?? (kind === "secret" ? "Servidor" : "Site"), kind, mode };
+  if (kind === "publishable") {
+    body.funnelId = pickFunnel2(workspaces, a.funnel).id;
+    body.allowedOrigins = a.allowed_origins ?? [];
+  } else if (a.workspaces?.length) body.workspaceIds = a.workspaces.map((w) => resolve(workspaces, w, "Workspace").id);
+  const key = await api.post("/integrations/keys", body);
+  const vars = { [envVar]: key.token };
+  const url = config.apiUrl !== SDK_DEFAULT_URL ? config.apiUrl : null;
+  if (url && kind === "secret") vars.AICRM_API_URL = url;
+  try {
+    const written = await writeEnvVars(envFile, vars, cwd);
+    return {
+      key: { name: key.name, kind, mode, prefix: `${key.prefix}\u2026` },
+      env_file: written.path,
+      variables: Object.keys(vars),
+      ...written.replaced.length ? { replaced: written.replaced } : {},
+      gitignore: written.gitignore,
+      ...url && kind === "publishable" ? { api_url: url } : {},
+      how_to_use: kind === "secret" ? `No servidor: new AICRM(${envVar === "AICRM_API_KEY" ? "" : `process.env.${envVar}`}) \u2014 o SDK l\xEA ${envVar === "AICRM_API_KEY" ? "AICRM_API_KEY" : "a chave do argumento"}${url ? " e AICRM_API_URL" : ""} sozinho. Nunca leve esta chave para o c\xF3digo do navegador.` : `No site: new AICRM(<${envVar}>${url ? `, { baseUrl: "${url}" }` : ""}). Em Vite use o prefixo VITE_, em Next.js NEXT_PUBLIC_ (passe env_var). A chave p\xFAblica s\xF3 cria leads no funil dela.`,
+      note: "A chave completa foi gravada s\xF3 no arquivo; ela n\xE3o aparece nesta conversa."
+    };
+  } catch (e) {
+    await api.del(`/integrations/keys/${key.id}`).catch(() => {
+    });
+    throw e;
+  }
+}
+function registerIntegrationTools(server) {
+  server.registerTool(
+    "get_integration_schema",
+    {
+      title: "Funis, etapas e campos para integrar",
+      description: "Mostra para onde os leads podem ir: workspaces, funis, etapas e os campos de cada lead (padr\xE3o e personalizados), com quais s\xE3o obrigat\xF3rios e um payload de exemplo pronto para leads.create(). Use antes de escrever o c\xF3digo da integra\xE7\xE3o.",
+      inputSchema: { funnel: z2.string().optional().describe("Nome ou id do funil (sem ele, lista todos)"), workspace: z2.string().optional() },
+      annotations: { readOnlyHint: true }
+    },
+    withApi(async (api, a) => {
+      const wss = await schema(api);
+      if (a.funnel) return text(describe(pickFunnel2(wss, a.funnel, a.workspace)));
+      return text({
+        workspaces: wss.map((w) => ({ workspace: w.name, funnels: w.funnels.map(describe) })),
+        tips: [
+          "Funil, etapa e campos aceitam nome ou id; mai\xFAsculas e acentos n\xE3o importam.",
+          'Campos personalizados v\xE3o em fields, pelo nome: fields: { Cidade: "Recife" }. Dinheiro em reais.',
+          "Use externalId com o id do lead no sistema da pessoa: reenvios atualizam em vez de duplicar."
+        ]
+      });
+    })
+  );
+  server.registerTool(
+    "create_api_key",
+    {
+      title: "Criar chave de API no .env",
+      description: "Cria uma chave da API p\xFAblica e grava direto no arquivo .env do projeto (e garante que o .env est\xE1 no .gitignore). A chave completa nunca volta para voc\xEA: s\xF3 o prefixo. secret (aicrm_sk_) \xE9 para o servidor; publishable (aicrm_pk_) \xE9 para o navegador e s\xF3 cria leads num funil. Comece com mode test. Chave de produ\xE7\xE3o (mode live) s\xF3 com o ok expl\xEDcito da pessoa e confirm_live: true.",
+      inputSchema: {
+        name: z2.string().max(60).optional().describe("Ex.: Checkout, Site institucional"),
+        kind: z2.enum(["secret", "publishable"]).optional().describe("secret (padr\xE3o) no servidor; publishable no navegador"),
+        mode: z2.enum(["test", "live"]).optional().describe("test (padr\xE3o): leads com selo Teste, fora das metas"),
+        funnel: z2.string().optional().describe("Obrigat\xF3rio para publishable: o \xFAnico funil onde a chave cria leads"),
+        workspaces: z2.array(z2.string()).optional().describe("Workspaces que a chave secreta alcan\xE7a (padr\xE3o: todos os seus)"),
+        allowed_origins: z2.array(z2.string()).optional().describe('Dom\xEDnios que podem usar a chave publishable, ex.: ["seusite.com.br"]'),
+        env_file: z2.string().optional().describe("Arquivo .env relativo \xE0 pasta do projeto (padr\xE3o .env)"),
+        env_var: z2.string().optional().describe("Nome da vari\xE1vel (padr\xE3o AICRM_API_KEY ou AICRM_PUBLISHABLE_KEY)"),
+        confirm_live: z2.boolean().optional().describe("true s\xF3 depois que a pessoa confirmou que quer uma chave de produ\xE7\xE3o")
+      }
+    },
+    withApi(async (api, a) => text(await createKeyIntoEnv(api, a)))
+  );
+  server.registerTool(
+    "send_test_lead",
+    {
+      title: "Mandar um lead de teste",
+      description: "Manda o payload de exemplo do funil com a sua chave de teste mais recente, como o c\xF3digo faria, e mostra em que etapa o lead caiu (ou o erro e como corrigir). \xDAtil para conferir a estrutura antes e depois de escrever o c\xF3digo.",
+      inputSchema: { funnel: z2.string().optional(), workspace: z2.string().optional() }
+    },
+    withApi(async (api, a) => {
+      const funnel = pickFunnel2(await schema(api), a.funnel, a.workspace);
+      const r = await api.post(
+        "/integrations/test-event",
+        { funnelId: funnel.id }
+      );
+      if (r.status >= 300) return text({ ok: false, status: r.status, error: r.response.error, how_to_fix: help(r.response.error?.code ?? null) });
+      return text({ ok: true, landed_in: `${r.response.funnel?.name} \u203A ${r.response.stage?.name}`, sent: r.request, lead: r.response });
+    })
+  );
+  server.registerTool(
+    "list_api_logs",
+    {
+      title: "Logs da API",
+      description: "\xDAltimas chamadas \xE0 API feitas com as suas chaves: status, rota e, nos erros, o c\xF3digo e como corrigir. Rode depois de testar o c\xF3digo para ver se o lead entrou ou por que falhou.",
+      inputSchema: { errors_only: z2.boolean().optional(), limit: z2.number().int().min(1).max(100).optional() },
+      annotations: { readOnlyHint: true }
+    },
+    withApi(async (api, a) => {
+      const logs = await api.get(`/integrations/logs?limit=${a.limit ?? 20}${a.errors_only ? "&errors=1" : ""}`);
+      return text(logs.length ? logs.map(logOut) : "Nenhuma chamada ainda. Rode o c\xF3digo (ou send_test_lead) e veja de novo.");
+    })
+  );
+  server.registerTool(
+    "get_api_log",
+    {
+      title: "Detalhe de uma chamada",
+      description: "O que foi enviado e o que a API respondeu numa chamada (id vem de list_api_logs).",
+      inputSchema: { id: z2.string() },
+      annotations: { readOnlyHint: true }
+    },
+    withApi(async (api, a) => {
+      const l = await api.get(`/integrations/logs/${a.id}`);
+      return text({ ...logOut(l), sent: l.requestBody, response: l.responseBody });
+    })
+  );
+  server.registerTool(
+    "get_integration_status",
+    {
+      title: "Onde est\xE1 a integra\xE7\xE3o",
+      description: "Mostra o que j\xE1 foi feito (chave de teste, primeiro lead, chave de produ\xE7\xE3o) e o pr\xF3ximo passo.",
+      inputSchema: {},
+      annotations: { readOnlyHint: true }
+    },
+    withApi(async (api) => {
+      const s = await api.get("/integrations/status");
+      const next = !s.hasTestKey ? "Crie uma chave de teste com create_api_key." : !s.firstLead ? "Escreva o c\xF3digo com o SDK @aicrm/sdk e rode; confira em list_api_logs." : !s.hasLiveKey ? "Quando a pessoa aprovar, crie a chave de produ\xE7\xE3o (create_api_key mode live) e troque no ambiente de produ\xE7\xE3o." : "Integra\xE7\xE3o completa. Se quiser, limpe os leads de teste com clear_test_leads.";
+      return text({
+        test_key: s.hasTestKey,
+        first_lead: s.firstLead ? `${s.firstLead.name} em ${s.firstLead.funnelName} \u203A ${s.firstLead.stageName}${s.firstLead.isTest ? " (teste)" : ""}` : null,
+        live_key: s.hasLiveKey,
+        last_request: s.lastRequest ? logOut(s.lastRequest) : null,
+        next_step: next
+      });
+    })
+  );
+  server.registerTool(
+    "list_api_keys",
+    {
+      title: "Chaves de API",
+      description: "Suas chaves ativas (o admin v\xEA as da empresa), com tipo, modo e \xFAltimo uso. S\xF3 o prefixo: a chave completa s\xF3 aparece ao criar.",
+      inputSchema: {},
+      annotations: { readOnlyHint: true }
+    },
+    withApi(
+      async (api) => text(
+        (await api.get("/integrations/keys")).map((k) => ({
+          name: k.name,
+          kind: k.kind,
+          mode: k.mode,
+          prefix: `${k.prefix}\u2026`,
+          last_used: k.lastUsedAt,
+          ...k.kind === "publishable" ? { allowed_origins: k.allowedOrigins.length ? k.allowedOrigins : "qualquer site" } : {},
+          ...k.createdByName ? { created_by: k.createdByName } : {}
+        }))
+      )
+    )
+  );
+  server.registerTool(
+    "revoke_api_key",
+    {
+      title: "Revogar chave de API",
+      description: "Desativa uma chave na hora: o sistema que a usa para de mandar leads. Pe\xE7a confirma\xE7\xE3o antes.",
+      inputSchema: { key: z2.string().describe("Nome ou prefixo da chave") },
+      annotations: { destructiveHint: true }
+    },
+    withApi(async (api, a) => {
+      const keys = await api.get("/integrations/keys");
+      const k = keys.find((x) => norm(x.prefix).startsWith(norm(a.key.replace(/…$/, "")))) ?? resolve(keys, a.key, "Chave");
+      await api.del(`/integrations/keys/${k.id}`);
+      return text(`Chave ${k.name} (${k.prefix}\u2026) revogada.`);
+    })
+  );
+  server.registerTool(
+    "clear_test_leads",
+    {
+      title: "Apagar leads de teste",
+      description: "Tira do funil os leads criados com as suas chaves de teste. Leads reais n\xE3o s\xE3o afetados. Pe\xE7a confirma\xE7\xE3o antes.",
+      inputSchema: {},
+      annotations: { destructiveHint: true }
+    },
+    withApi(async (api) => {
+      const r = await api.del("/integrations/test-leads");
+      return text(r.deleted ? `${r.deleted} lead(s) de teste apagados.` : "N\xE3o havia leads de teste.");
+    })
+  );
+}
+
+// src/tools/admin.ts
+import { z as z3 } from "zod";
 function registerAdminTools(server) {
   server.registerTool(
     "get_setup_status",
@@ -794,7 +1305,7 @@ function registerAdminTools(server) {
     "list_tv_links",
     {
       title: "Links do modo TV",
-      description: "Lista os links ativos do modo TV (dashboard ao vivo sem login), s\xF3 admins.",
+      description: "Lista os links ativos do modo TV (dashboard ao vivo sem login), s\xF3 admins e Masters (dos funis deles).",
       inputSchema: {},
       annotations: { readOnlyHint: true }
     },
@@ -806,8 +1317,8 @@ function registerAdminTools(server) {
     "create_tv_link",
     {
       title: "Criar link do modo TV",
-      description: "Cria um link do dashboard ao vivo de um funil para abrir numa TV, sem login (s\xF3 admins). Quem tiver o link v\xEA o dashboard \u2014 trate como senha.",
-      inputSchema: { name: z2.string().min(1).max(80).describe("Ex.: TV da sala de vendas"), funnel: z2.string().optional(), workspace: z2.string().optional() }
+      description: "Cria um link do dashboard ao vivo de um funil para abrir numa TV, sem login (admins e Masters). Quem tiver o link v\xEA o dashboard \u2014 trate como senha.",
+      inputSchema: { name: z3.string().min(1).max(80).describe("Ex.: TV da sala de vendas"), funnel: z3.string().optional(), workspace: z3.string().optional() }
     },
     withApi(async (api, a) => {
       const funnel = pickFunnel(await ctx(api), a.funnel, a.workspace);
@@ -819,8 +1330,8 @@ function registerAdminTools(server) {
     "revoke_tv_link",
     {
       title: "Revogar link do modo TV",
-      description: "Desativa um link do modo TV (s\xF3 admins); a TV que usava o link para de mostrar o dashboard.",
-      inputSchema: { link: z2.string().describe("Nome do link") },
+      description: "Desativa um link do modo TV (admins e Masters); a TV que usava o link para de mostrar o dashboard.",
+      inputSchema: { link: z3.string().describe("Nome do link") },
       annotations: { destructiveHint: true }
     },
     withApi(async (api, a) => {
@@ -853,7 +1364,7 @@ function registerAdminTools(server) {
     {
       title: "Revogar token de API",
       description: "Revoga um token de API seu. Se for o token que este MCP est\xE1 usando, a conex\xE3o para de funcionar at\xE9 um novo login.",
-      inputSchema: { token_id: z2.string().uuid() },
+      inputSchema: { token_id: z3.string().uuid() },
       annotations: { destructiveHint: true }
     },
     withApi(async (api, a) => {
@@ -863,9 +1374,91 @@ function registerAdminTools(server) {
   );
 }
 
+// src/tools/distribution.ts
+import { z as z4 } from "zod";
+var br = (d) => `${d.slice(8, 10)}/${d.slice(5, 7)}`;
+var why = (b) => b.reason === "manual" ? "pausado pelo Master ou admin" : `sem nenhuma a\xE7\xE3o no funil em ${b.day ? br(b.day) : "um dia \xFAtil"}`;
+var describePlan = (funnel, p) => ({
+  funnel,
+  automatic_distribution: p.enabled ? "ligada" : "desligada (ligue com update_funnel auto_assign=true)",
+  next_leads_go_to: p.sellers.map((s) => ({
+    seller: s.name,
+    share: formatPct(s.share),
+    why: s.why,
+    received_last_7_days: s.receivedRecently
+  })),
+  not_receiving: p.blocked.map((b) => ({ seller: b.name, why: why(b) })),
+  leads_without_owner: p.unowned
+});
+var funnelArgs = { funnel: z4.string().optional(), workspace: z4.string().optional() };
+function registerDistributionTools(server) {
+  server.registerTool(
+    "get_distribution",
+    {
+      title: "Distribui\xE7\xE3o de leads",
+      description: "Mostra para quem v\xE3o os pr\xF3ximos leads sem vendedor do funil, a parte de cada um e o motivo (quem fecha mais recebe mais; todos recebem um m\xEDnimo), quem n\xE3o est\xE1 recebendo (pausado por Master/admin ou um dia \xFAtil sem nenhuma a\xE7\xE3o no funil) e quantos leads esperam vendedor. Sem funil, lista os bloqueios de todos os funis. S\xF3 admins e Masters.",
+      inputSchema: funnelArgs,
+      annotations: { readOnlyHint: true }
+    },
+    withApi(async (api, a) => {
+      if (!a.funnel && !a.workspace) {
+        const alerts = await api.get("/distribution/alerts");
+        return text(
+          alerts.length ? { not_receiving: alerts.map((x) => ({ seller: x.name, funnel: x.funnelName, why: why(x) })) } : "Todos os vendedores est\xE3o recebendo leads em todos os funis."
+        );
+      }
+      const funnel = pickFunnel(await ctx(api), a.funnel, a.workspace);
+      return text(describePlan(funnel.name, await api.get(`/distribution?funnelId=${funnel.id}`)));
+    })
+  );
+  server.registerTool(
+    "release_seller",
+    {
+      title: "Liberar vendedor",
+      description: "Volta a mandar leads novos para um vendedor que foi bloqueado (dia sem a\xE7\xE3o) ou pausado no funil. S\xF3 admins e Masters.",
+      inputSchema: { seller: z4.string().describe("Nome ou email"), ...funnelArgs }
+    },
+    withApi(async (api, a) => {
+      const c = await ctx(api);
+      const funnel = pickFunnel(c, a.funnel, a.workspace);
+      const user = findUser(c, a.seller);
+      const plan = await api.post("/distribution/release", { funnelId: funnel.id, userId: user.id });
+      return text({ released: user.name, ...describePlan(funnel.name, plan) });
+    })
+  );
+  server.registerTool(
+    "pause_seller",
+    {
+      title: "Pausar vendedor",
+      description: "Para de mandar leads novos para um vendedor no funil (ex.: f\xE9rias), at\xE9 release_seller. Os leads que ele j\xE1 tem continuam com ele. S\xF3 admins e Masters. Confirme com a pessoa antes.",
+      inputSchema: { seller: z4.string().describe("Nome ou email"), ...funnelArgs }
+    },
+    withApi(async (api, a) => {
+      const c = await ctx(api);
+      const funnel = pickFunnel(c, a.funnel, a.workspace);
+      const user = findUser(c, a.seller);
+      const plan = await api.post("/distribution/pause", { funnelId: funnel.id, userId: user.id });
+      return text({ paused: user.name, ...describePlan(funnel.name, plan) });
+    })
+  );
+  server.registerTool(
+    "assign_unowned_leads",
+    {
+      title: "Distribuir leads sem vendedor",
+      description: "Entrega os leads abertos sem vendedor do funil para o time, na propor\xE7\xE3o da distribui\xE7\xE3o por desempenho (get_distribution). S\xF3 admins e Masters. Admins e Masters nunca recebem.",
+      inputSchema: funnelArgs
+    },
+    withApi(async (api, a) => {
+      const funnel = pickFunnel(await ctx(api), a.funnel, a.workspace);
+      const r = await api.post("/distribution/assign-unowned", { funnelId: funnel.id });
+      return text({ assigned: r.assigned, ...describePlan(funnel.name, r.plan) });
+    })
+  );
+}
+
 // src/tools/goals.ts
-import { z as z3 } from "zod";
-var describePlan = (p) => ({
+import { z as z5 } from "zod";
+var describePlan2 = (p) => ({
   name: p.name,
   kind: p.kind === "percent" ? "% sobre a receita (metas de receita)" : "R$ por unidade (metas de quantidade)",
   tiers: p.tiers.map((t) => `a partir de ${t.minAttainmentPct}% da meta: ${p.kind === "percent" ? `${t.rate}%` : `${formatMoney(t.rate)} por unidade`}`)
@@ -879,7 +1472,7 @@ function registerGoalTools(server) {
       inputSchema: {},
       annotations: { readOnlyHint: true }
     },
-    withApi(async (api) => text((await api.get("/commission-plans")).map(describePlan)))
+    withApi(async (api) => text((await api.get("/commission-plans")).map(describePlan2)))
   );
   server.registerTool(
     "save_commission_plan",
@@ -887,9 +1480,9 @@ function registerGoalTools(server) {
       title: "Criar ou alterar plano de comiss\xE3o",
       description: "Cria um plano de comiss\xE3o ou, se j\xE1 existir um com o mesmo nome, substitui as faixas (s\xF3 admins). Cada faixa vale a partir de um % de atingimento da meta e a taxa da faixa alcan\xE7ada vale para tudo (acelerador). kind percent: rate em % da receita (para funis com meta de receita). kind per_unit: rate em reais por unidade (para metas de quantidade).",
       inputSchema: {
-        name: z3.string().min(1).max(80),
-        kind: z3.enum(["percent", "per_unit"]),
-        tiers: z3.array(z3.object({ from_attainment_pct: z3.number().min(0).max(1e3), rate: z3.number().min(0) })).min(1).max(10).describe("Ex.: [{from_attainment_pct: 0, rate: 3}, {from_attainment_pct: 100, rate: 6}]")
+        name: z5.string().min(1).max(80),
+        kind: z5.enum(["percent", "per_unit"]),
+        tiers: z5.array(z5.object({ from_attainment_pct: z5.number().min(0).max(1e3), rate: z5.number().min(0) })).min(1).max(10).describe("Ex.: [{from_attainment_pct: 0, rate: 3}, {from_attainment_pct: 100, rate: 6}]")
       }
     },
     withApi(async (api, a) => {
@@ -900,7 +1493,7 @@ function registerGoalTools(server) {
       };
       const existing = (await api.get("/commission-plans")).find((p) => norm(p.name) === norm(a.name));
       const plan = existing ? await api.patch(`/commission-plans/${existing.id}`, { ...body, name: existing.name }) : await api.post("/commission-plans", body);
-      return text({ [existing ? "updated" : "created"]: describePlan(plan) });
+      return text({ [existing ? "updated" : "created"]: describePlan2(plan) });
     })
   );
   server.registerTool(
@@ -908,7 +1501,7 @@ function registerGoalTools(server) {
     {
       title: "Apagar plano de comiss\xE3o",
       description: "Apaga um plano de comiss\xE3o (s\xF3 admins). As metas que o usavam ficam sem comiss\xE3o.",
-      inputSchema: { plan: z3.string() },
+      inputSchema: { plan: z5.string() },
       annotations: { destructiveHint: true }
     },
     withApi(async (api, a) => {
@@ -922,7 +1515,7 @@ function registerGoalTools(server) {
     {
       title: "Metas do m\xEAs",
       description: "Mostra a meta de cada vendedor num funil e m\xEAs, e o plano de comiss\xE3o ligado. Para o andamento e a proje\xE7\xE3o, use get_dashboard.",
-      inputSchema: { funnel: z3.string().optional(), workspace: z3.string().optional(), month: z3.string().regex(MONTH).optional().describe("YYYY-MM; padr\xE3o: m\xEAs atual") },
+      inputSchema: { funnel: z5.string().optional(), workspace: z5.string().optional(), month: z5.string().regex(MONTH).optional().describe("YYYY-MM; padr\xE3o: m\xEAs atual") },
       annotations: { readOnlyHint: true }
     },
     withApi(async (api, a) => {
@@ -949,13 +1542,13 @@ function registerGoalTools(server) {
     "set_goals",
     {
       title: "Definir metas",
-      description: 'Define ou altera a meta de vendedores num funil e m\xEAs (s\xF3 admins). target em reais para funis de receita, ou em unidades (vendas/leads na etapa) nos demais. target 0 remove a meta. Sem commission_plan, mant\xE9m o plano que o m\xEAs j\xE1 usa; commission_plan="none" tira a comiss\xE3o.',
+      description: 'Define ou altera a meta de vendedores num funil e m\xEAs (admins e Masters; s\xF3 admins escolhem o plano de comiss\xE3o). target em reais para funis de receita, ou em unidades (vendas/leads na etapa) nos demais. target 0 remove a meta. Sem commission_plan, mant\xE9m o plano que o m\xEAs j\xE1 usa; commission_plan="none" tira a comiss\xE3o.',
       inputSchema: {
-        targets: z3.array(z3.object({ seller: z3.string().describe("Nome ou email"), target: z3.number().min(0) })).min(1),
-        funnel: z3.string().optional(),
-        workspace: z3.string().optional(),
-        month: z3.string().regex(MONTH).optional().describe("YYYY-MM; padr\xE3o: m\xEAs atual"),
-        commission_plan: z3.string().optional()
+        targets: z5.array(z5.object({ seller: z5.string().describe("Nome ou email"), target: z5.number().min(0) })).min(1),
+        funnel: z5.string().optional(),
+        workspace: z5.string().optional(),
+        month: z5.string().regex(MONTH).optional().describe("YYYY-MM; padr\xE3o: m\xEAs atual"),
+        commission_plan: z5.string().optional()
       }
     },
     withApi(
@@ -991,14 +1584,14 @@ function registerGoalTools(server) {
 }
 
 // src/tools/leads.ts
-import { z as z4 } from "zod";
+import { z as z6 } from "zod";
 function registerLeadTools(server) {
   server.registerTool(
     "reopen_lead",
     {
       title: "Reabrir lead",
       description: "Volta um lead ganho ou perdido para aberto, na mesma etapa.",
-      inputSchema: { lead_id: z4.string().uuid() }
+      inputSchema: { lead_id: z6.string().uuid() }
     },
     withApi(async (api, a) => {
       const c = await ctx(api);
@@ -1012,12 +1605,12 @@ function registerLeadTools(server) {
       title: "Enviar lead ganho para outro funil",
       description: "Continua um lead GANHO em outro funil (ex.: de Aquisi\xE7\xE3o para Relacionamento/p\xF3s-venda): cria um lead novo, aberto e ligado ao original, na etapa escolhida (padr\xE3o: a primeira). O lead ganho fica onde est\xE1 e continua contando na meta e na comiss\xE3o. O novo lead copia contato e campos, come\xE7a com valor R$ 0 (informe value se j\xE1 houver nova venda prevista) e mant\xE9m o respons\xE1vel (ou use owner). S\xF3 funciona para leads com status won; cada lead s\xF3 pode continuar uma vez em cada funil.",
       inputSchema: {
-        lead_id: z4.string().uuid().describe("Lead ganho"),
-        funnel: z4.string().describe("Funil onde o cliente continua (nome ou id)"),
-        stage: z4.string().optional().describe("Etapa de entrada (padr\xE3o: a primeira)"),
-        workspace: z4.string().optional().describe("Workspace do funil, se for outro (s\xF3 admins)"),
-        owner: z4.string().optional().describe('Respons\xE1vel no novo funil (nome ou email; "none" = sem respons\xE1vel). Padr\xE3o: o mesmo do lead ganho'),
-        value: z4.number().min(0).optional().describe("Valor em reais no novo funil (padr\xE3o: 0)")
+        lead_id: z6.string().uuid().describe("Lead ganho"),
+        funnel: z6.string().describe("Funil onde o cliente continua (nome ou id)"),
+        stage: z6.string().optional().describe("Etapa de entrada (padr\xE3o: a primeira)"),
+        workspace: z6.string().optional().describe("Workspace do funil, se for outro (s\xF3 admins e Masters)"),
+        owner: z6.string().optional().describe('Respons\xE1vel no novo funil (nome ou email; "none" = sem respons\xE1vel). Padr\xE3o: o mesmo do lead ganho'),
+        value: z6.number().min(0).optional().describe("Valor em reais no novo funil (padr\xE3o: 0)")
       }
     },
     withApi(async (api, a) => {
@@ -1032,12 +1625,12 @@ function registerLeadTools(server) {
     "bulk_update_leads",
     {
       title: "Atualizar leads em massa",
-      description: "Reatribui (s\xF3 admins) e/ou move at\xE9 1000 leads de uma vez. Pegue os ids com search_leads. Para mover, informe stage (e funnel, se for outro funil; sem funnel, vale o funil do primeiro lead). Leads que voc\xEA n\xE3o pode editar s\xE3o pulados, assim como leads ganhos numa troca de funil (use handoff_lead para eles).",
+      description: "Reatribui (s\xF3 admins e Masters) e/ou move at\xE9 1000 leads de uma vez. Pegue os ids com search_leads. Para mover, informe stage (e funnel, se for outro funil; sem funnel, vale o funil do primeiro lead). Leads que voc\xEA n\xE3o pode editar s\xE3o pulados, assim como leads ganhos numa troca de funil (use handoff_lead para eles).",
       inputSchema: {
-        lead_ids: z4.array(z4.string().uuid()).min(1).max(1e3),
-        owner: z4.string().optional().describe("Nome ou email do novo respons\xE1vel"),
-        stage: z4.string().optional(),
-        funnel: z4.string().optional()
+        lead_ids: z6.array(z6.string().uuid()).min(1).max(1e3),
+        owner: z6.string().optional().describe("Nome ou email do novo respons\xE1vel"),
+        stage: z6.string().optional(),
+        funnel: z6.string().optional()
       }
     },
     withApi(async (api, a) => {
@@ -1063,8 +1656,8 @@ function registerLeadTools(server) {
     "delete_lead",
     {
       title: "Excluir lead",
-      description: "Apaga um lead e todo o hist\xF3rico dele (s\xF3 admins). N\xE3o d\xE1 para desfazer \u2014 confirme com a pessoa antes. Para tirar do funil sem apagar, prefira mark_lost.",
-      inputSchema: { lead_id: z4.string().uuid() },
+      description: "Apaga um lead e todo o hist\xF3rico dele (s\xF3 admins e Masters). N\xE3o d\xE1 para desfazer \u2014 confirme com a pessoa antes. Para tirar do funil sem apagar, prefira mark_lost.",
+      inputSchema: { lead_id: z6.string().uuid() },
       annotations: { destructiveHint: true }
     },
     withApi(async (api, a) => {
@@ -1075,22 +1668,68 @@ function registerLeadTools(server) {
   );
 }
 
+// src/tools/risks.ts
+import { z as z7 } from "zod";
+function registerRiskTools(server) {
+  server.registerTool(
+    "get_lead_risks",
+    {
+      title: "Leads em risco",
+      description: "Leads abertos parados al\xE9m do prazo da etapa (dias \xFAteis; s\xF3 mudar de etapa zera a contagem). Passou do prazo, o vendedor \xE9 avisado; passou do dobro, \xE9 cr\xEDtico e o Master e o admin s\xE3o avisados. Mostra o valor em risco, onde trava (etapa), com quem (vendedor) e os mais atrasados. Para listar todos os fora do prazo use search_leads com filter=stale. S\xF3 admins e Masters.",
+      inputSchema: { workspace: z7.string().optional() },
+      annotations: { readOnlyHint: true }
+    },
+    withApi(async (api, a) => {
+      const ws = pickWorkspace(await ctx(api), a.workspace);
+      const r = await api.get(`/leads/risks?workspaceId=${ws.id}`);
+      if (!r.critical.count && !r.late)
+        return text(`Nenhum lead fora do prazo no workspace ${ws.name}.`);
+      return text({
+        workspace: ws.name,
+        critical: {
+          leads: r.critical.count,
+          value: formatMoney(r.critical.valueCents),
+          where_it_jams: r.critical.byStage.map((s) => ({ stage: `${s.funnelName} \xB7 ${s.stageName}`, leads: s.count, value: formatMoney(s.valueCents) })),
+          with_whom: r.critical.byOwner.map((o) => ({ seller: o.ownerName ?? "Sem vendedor", leads: o.count, value: formatMoney(o.valueCents) })),
+          worst: r.critical.top.map((l) => ({
+            lead: l.company ? `${l.company} \u2014 ${l.name}` : l.name,
+            stage: `${l.funnelName} \xB7 ${l.stageName}`,
+            seller: l.ownerName ?? "Sem vendedor",
+            business_days_in_stage: l.age.days,
+            stage_limit_days: l.age.limit,
+            stage_deadline: RISK_LEVEL_LABEL[l.age.level],
+            value: formatMoney(l.valueCents)
+          }))
+        },
+        late_only_seller_warned: r.late
+      });
+    })
+  );
+}
+
 // src/tools/structure.ts
-import { z as z5 } from "zod";
+import { z as z8 } from "zod";
 var TEMPLATE_KEYS = Object.keys(FUNNEL_TEMPLATES);
-var stageInput = z5.object({
-  name: z5.string().min(1).max(60),
-  probability: z5.number().int().min(0).max(100).describe("Chance (%) de um lead nesta etapa virar venda"),
-  was: z5.string().optional().describe("Nome atual da etapa, se voc\xEA est\xE1 renomeando uma existente")
+var stageInput = z8.object({
+  name: z8.string().min(1).max(60),
+  probability: z8.number().int().min(0).max(100).describe("Chance (%) de um lead nesta etapa virar venda"),
+  limit_days: z8.number().int().min(1).max(365).nullish().describe(
+    `Prazo da etapa em dias \xFAteis: passou dele, o vendedor \xE9 avisado; passou do dobro, o Master e o admin tamb\xE9m. null volta ao padr\xE3o (${DEFAULT_STAGE_LIMIT_DAYS}); omitido mant\xE9m o atual.`
+  ),
+  was: z8.string().optional().describe("Nome atual da etapa, se voc\xEA est\xE1 renomeando uma existente")
 });
 var describeFunnel = (f, ws) => ({
   name: f.name,
   goal_kpi: `${f.goalKpi} (${GOAL_KPI_LABEL[f.goalKpi]})`,
   ...f.goalKpi === "stage_reached" ? { goal_stage: f.stages.find((s) => s.id === f.goalStageId)?.name ?? null } : {},
   ...f.nextFunnelId ? { after_won_continue_in: ws?.funnels.find((x) => x.id === f.nextFunnelId)?.name ?? f.nextFunnelId } : {},
-  stages: f.stages.map((s) => `${s.name} (${s.probability}%)`)
+  auto_assign: !!f.autoAssign,
+  stages: f.stages.map((s) => `${s.name} (${s.probability}%, prazo ${s.limitDays ?? DEFAULT_STAGE_LIMIT_DAYS} dias \xFAteis${s.limitDays ? "" : " \u2014 padr\xE3o"})`)
 });
-var nextFunnelArg = z5.string().nullable().optional().describe('Funil (do mesmo workspace) onde o cliente continua depois de ganho, ex.: "Relacionamento". Sugerido no app ao marcar ganho. null ou "none" remove.');
+var autoAssignArg = z8.boolean().optional().describe(
+  "Distribui\xE7\xE3o autom\xE1tica: leads cadastrados ou importados por admins/Masters sem vendedor v\xE3o, em maior parte, para quem est\xE1 fechando mais (todo vendedor recebe; admins e Masters nunca). Quem passa um dia \xFAtil sem nenhuma a\xE7\xE3o no funil para de receber at\xE9 um Master ou admin liberar (release_seller)."
+);
+var nextFunnelArg = z8.string().nullable().optional().describe('Funil (do mesmo workspace) onde o cliente continua depois de ganho, ex.: "Relacionamento". Sugerido no app ao marcar ganho. null ou "none" remove.');
 var nextFunnelId = (ws, ref) => ref === void 0 ? void 0 : ref === null || norm(ref) === "none" ? null : resolve(ws.funnels, ref, "Funil").id;
 function registerStructureTools(server) {
   server.registerTool(
@@ -1099,9 +1738,9 @@ function registerStructureTools(server) {
       title: "Criar workspace",
       description: "Cria um workspace (s\xF3 admins) \u2014 ex.: um time, regi\xE3o ou unidade. J\xE1 vem com um funil de vendas, a menos que create_funnel=false.",
       inputSchema: {
-        name: z5.string().min(1).max(80),
-        visibility: z5.enum(["all", "own"]).default("all").describe("all = todos veem todos os leads; own = cada vendedor v\xEA s\xF3 os seus"),
-        create_funnel: z5.boolean().default(true)
+        name: z8.string().min(1).max(80),
+        visibility: z8.enum(["all", "own"]).default("all").describe("all = todos veem todos os leads; own = cada vendedor v\xEA s\xF3 os seus"),
+        create_funnel: z8.boolean().default(true)
       }
     },
     withApi(async (api, a) => {
@@ -1116,9 +1755,9 @@ function registerStructureTools(server) {
       title: "Alterar workspace",
       description: "Renomeia um workspace ou muda quem v\xEA quais leads (s\xF3 admins).",
       inputSchema: {
-        workspace: z5.string(),
-        name: z5.string().min(1).max(80).optional(),
-        visibility: z5.enum(["all", "own"]).optional().describe("all = todos veem todos os leads; own = cada vendedor v\xEA s\xF3 os seus")
+        workspace: z8.string(),
+        name: z8.string().min(1).max(80).optional(),
+        visibility: z8.enum(["all", "own"]).optional().describe("all = todos veem todos os leads; own = cada vendedor v\xEA s\xF3 os seus")
       }
     },
     withApi(async (api, a) => {
@@ -1132,7 +1771,7 @@ function registerStructureTools(server) {
     {
       title: "Excluir workspace",
       description: "Apaga um workspace com TODOS os funis e leads dele (s\xF3 admins). N\xE3o d\xE1 para desfazer \u2014 confirme com a pessoa antes.",
-      inputSchema: { workspace: z5.string() },
+      inputSchema: { workspace: z8.string() },
       annotations: { destructiveHint: true }
     },
     withApi(async (api, a) => {
@@ -1147,13 +1786,14 @@ function registerStructureTools(server) {
       title: "Criar funil",
       description: `Cria um funil num workspace (s\xF3 admins). Use um modelo (${TEMPLATE_KEYS.map((k) => `${k} = ${FUNNEL_TEMPLATES[k].label}`).join("; ")}) ou informe stages. goal_kpi define o que conta como meta: revenue (receita ganha), won_count (n\xBA de vendas) ou stage_reached (n\xBA de leads que chegaram a goal_stage).`,
       inputSchema: {
-        name: z5.string().min(1).max(80),
-        workspace: z5.string().optional(),
-        template: z5.enum(TEMPLATE_KEYS).optional(),
-        stages: z5.array(stageInput.omit({ was: true })).min(1).max(20).optional(),
-        goal_kpi: z5.enum(GOAL_KPIS).default("revenue"),
-        goal_stage: z5.string().optional().describe("Etapa que conta como meta (s\xF3 para stage_reached; padr\xE3o: a \xFAltima)"),
-        next_funnel: nextFunnelArg
+        name: z8.string().min(1).max(80),
+        workspace: z8.string().optional(),
+        template: z8.enum(TEMPLATE_KEYS).optional(),
+        stages: z8.array(stageInput.omit({ was: true })).min(1).max(20).optional(),
+        goal_kpi: z8.enum(GOAL_KPIS).default("revenue"),
+        goal_stage: z8.string().optional().describe("Etapa que conta como meta (s\xF3 para stage_reached; padr\xE3o: a \xFAltima)"),
+        next_funnel: nextFunnelArg,
+        auto_assign: autoAssignArg
       }
     },
     withApi(
@@ -1166,9 +1806,10 @@ function registerStructureTools(server) {
           workspaceId: ws.id,
           name: a.name,
           goalKpi: a.goal_kpi,
-          ...a.stages ? { stages: a.stages } : { template: a.template ?? "sales" },
+          ...a.stages ? { stages: a.stages.map((s) => ({ name: s.name, probability: s.probability, limitDays: s.limit_days ?? null })) } : { template: a.template ?? "sales" },
           ...goalIdx >= 0 ? { goalStageIndex: goalIdx } : {},
-          ...a.next_funnel ? { nextFunnelId: nextFunnelId(ws, a.next_funnel) } : {}
+          ...a.next_funnel ? { nextFunnelId: nextFunnelId(ws, a.next_funnel) } : {},
+          ...a.auto_assign !== void 0 ? { autoAssign: a.auto_assign } : {}
         });
         return text({ workspace: ws.name, created: describeFunnel(f, ws) });
       }
@@ -1178,15 +1819,16 @@ function registerStructureTools(server) {
     "update_funnel",
     {
       title: "Alterar funil",
-      description: "Renomeia o funil, troca o KPI de meta ou redefine as etapas (s\xF3 admins). stages \xE9 a lista completa e na ordem: etapas com o mesmo nome (ou com was) s\xE3o mantidas, as novas s\xE3o criadas e as que ficarem de fora s\xE3o removidas \u2014 o que s\xF3 funciona se n\xE3o tiverem leads (mova antes com bulk_update_leads). next_funnel define para onde o cliente vai depois de ganho (ex.: Aquisi\xE7\xE3o \u2192 Relacionamento).",
+      description: "Renomeia o funil, troca o KPI de meta ou redefine as etapas (s\xF3 admins). stages \xE9 a lista completa e na ordem: etapas com o mesmo nome (ou com was) s\xE3o mantidas, as novas s\xE3o criadas e as que ficarem de fora s\xE3o removidas \u2014 o que s\xF3 funciona se n\xE3o tiverem leads (mova antes com bulk_update_leads). next_funnel define para onde o cliente vai depois de ganho (ex.: Aquisi\xE7\xE3o \u2192 Relacionamento). auto_assign liga ou desliga a distribui\xE7\xE3o autom\xE1tica de leads. limit_days em cada etapa define o prazo (dias \xFAteis) antes de o lead ser considerado parado.",
       inputSchema: {
-        funnel: z5.string(),
-        workspace: z5.string().optional(),
-        name: z5.string().min(1).max(80).optional(),
-        goal_kpi: z5.enum(GOAL_KPIS).optional(),
-        goal_stage: z5.string().optional(),
-        stages: z5.array(stageInput).min(1).max(20).optional(),
-        next_funnel: nextFunnelArg
+        funnel: z8.string(),
+        workspace: z8.string().optional(),
+        name: z8.string().min(1).max(80).optional(),
+        goal_kpi: z8.enum(GOAL_KPIS).optional(),
+        goal_stage: z8.string().optional(),
+        stages: z8.array(stageInput).min(1).max(20).optional(),
+        next_funnel: nextFunnelArg,
+        auto_assign: autoAssignArg
       }
     },
     withApi(async (api, a) => {
@@ -1196,13 +1838,19 @@ function registerStructureTools(server) {
       const next = nextFunnelId(ws, a.next_funnel);
       const stages = a.stages?.map((s) => {
         const existing = funnel.stages.find((x) => norm(x.name) === norm(s.was ?? s.name));
-        return { ...existing ? { id: existing.id } : {}, name: s.name, probability: s.probability };
+        return {
+          ...existing ? { id: existing.id } : {},
+          name: s.name,
+          probability: s.probability,
+          ...s.limit_days !== void 0 ? { limitDays: s.limit_days } : {}
+        };
       });
       let f = await api.patch(`/funnels/${funnel.id}`, {
         ...a.name ? { name: a.name } : {},
         ...a.goal_kpi ? { goalKpi: a.goal_kpi } : {},
         ...stages ? { stages } : {},
-        ...next !== void 0 ? { nextFunnelId: next } : {}
+        ...next !== void 0 ? { nextFunnelId: next } : {},
+        ...a.auto_assign !== void 0 ? { autoAssign: a.auto_assign } : {}
       });
       if (a.goal_stage || a.goal_kpi === "stage_reached" && !f.goalStageId) {
         const goal = a.goal_stage ? resolve(f.stages, a.goal_stage, "Etapa") : f.stages[f.stages.length - 1];
@@ -1216,7 +1864,7 @@ function registerStructureTools(server) {
     {
       title: "Excluir funil",
       description: "Remove um funil (s\xF3 admins). Se ele tiver leads, \xE9 arquivado (some das telas, hist\xF3rico preservado); se estiver vazio, \xE9 apagado. Confirme com a pessoa antes.",
-      inputSchema: { funnel: z5.string(), workspace: z5.string().optional() },
+      inputSchema: { funnel: z8.string(), workspace: z8.string().optional() },
       annotations: { destructiveHint: true }
     },
     withApi(async (api, a) => {
@@ -1228,15 +1876,15 @@ function registerStructureTools(server) {
 }
 
 // src/tools/team.ts
-import { z as z6 } from "zod";
+import { z as z9 } from "zod";
 var wsNames = (c, ids = []) => ids.map((id2) => c.workspaces.find((w) => w.id === id2)?.name ?? id2);
 function registerTeamTools(server) {
   server.registerTool(
     "list_users",
     {
       title: "Listar usu\xE1rios",
-      description: "Lista as pessoas da organiza\xE7\xE3o: papel (admin/member), se est\xE1 ativa, convite pendente e workspaces de cada uma.",
-      inputSchema: { include_inactive: z6.boolean().default(false) },
+      description: "Lista as pessoas da organiza\xE7\xE3o: papel (admin, manager = Master, member = vendedor), se est\xE1 ativa, convite pendente e workspaces de cada uma.",
+      inputSchema: { include_inactive: z9.boolean().default(false) },
       annotations: { readOnlyHint: true }
     },
     withApi(async (api, a) => {
@@ -1257,12 +1905,12 @@ function registerTeamTools(server) {
     "invite_user",
     {
       title: "Convidar usu\xE1rio",
-      description: "Convida uma pessoa para a organiza\xE7\xE3o (s\xF3 admins) e devolve o link de convite (vale 7 dias) para voc\xEA enviar a ela. member = vendedor (v\xEA os workspaces em que est\xE1); admin = v\xEA e configura tudo.",
+      description: "Convida uma pessoa para a organiza\xE7\xE3o (admins; Masters s\xF3 convidam vendedores para os workspaces deles) e devolve o link de convite (vale 7 dias) para voc\xEA enviar a ela. member = vendedor (v\xEA os workspaces em que est\xE1 e recebe leads distribu\xEDdos); manager = Master (lidera o time nos workspaces dele: v\xEA todos os leads, importa e distribui, define metas, convida vendedores; n\xE3o recebe leads automaticamente); admin = v\xEA e configura tudo.",
       inputSchema: {
-        name: z6.string().min(2),
-        email: z6.string().email(),
-        role: z6.enum(["member", "admin"]).default("member"),
-        workspaces: z6.array(z6.string()).optional().describe("Nomes dos workspaces (padr\xE3o: o primeiro)")
+        name: z9.string().min(2),
+        email: z9.string().email(),
+        role: z9.enum(["member", "manager", "admin"]).default("member"),
+        workspaces: z9.array(z9.string()).optional().describe("Nomes dos workspaces (padr\xE3o: o primeiro)")
       }
     },
     withApi(async (api, a) => {
@@ -1281,8 +1929,8 @@ function registerTeamTools(server) {
     "resend_invite",
     {
       title: "Gerar novo link de convite",
-      description: "Gera um novo link de convite para algu\xE9m (s\xF3 admins) \u2014 \xFAtil se o anterior expirou. O link antigo deixa de valer.",
-      inputSchema: { user: z6.string().describe("Nome ou email") }
+      description: "Gera um novo link de convite para algu\xE9m (admins; Masters s\xF3 para vendedores do time) \u2014 \xFAtil se o anterior expirou. O link antigo deixa de valer.",
+      inputSchema: { user: z9.string().describe("Nome ou email") }
     },
     withApi(async (api, a) => {
       const c = await ctx(api);
@@ -1295,13 +1943,13 @@ function registerTeamTools(server) {
     "update_user",
     {
       title: "Alterar usu\xE1rio",
-      description: "Muda nome, papel, workspaces ou desativa/reativa algu\xE9m (s\xF3 admins). Desativar encerra as sess\xF5es e tokens da pessoa; os leads continuam com ela at\xE9 serem reatribu\xEDdos (bulk_update_leads).",
+      description: "Muda nome, papel, workspaces ou desativa/reativa algu\xE9m (admins; Masters s\xF3 ajustam workspaces e ativa\xE7\xE3o de vendedores do time, sem mudar papel). Desativar encerra as sess\xF5es e tokens da pessoa; os leads continuam com ela at\xE9 serem reatribu\xEDdos (bulk_update_leads).",
       inputSchema: {
-        user: z6.string().describe("Nome ou email"),
-        name: z6.string().min(2).optional(),
-        role: z6.enum(["member", "admin"]).optional(),
-        active: z6.boolean().optional(),
-        workspaces: z6.array(z6.string()).optional().describe("Lista completa de workspaces da pessoa (substitui a atual)")
+        user: z9.string().describe("Nome ou email"),
+        name: z9.string().min(2).optional(),
+        role: z9.enum(["member", "manager", "admin"]).optional(),
+        active: z9.boolean().optional(),
+        workspaces: z9.array(z9.string()).optional().describe("Lista completa de workspaces da pessoa (substitui a atual)")
       }
     },
     withApi(async (api, a) => {
@@ -1330,15 +1978,31 @@ function registerManageTools(server) {
   registerTeamTools(server);
   registerStructureTools(server);
   registerGoalTools(server);
+  registerDistributionTools(server);
+  registerRiskTools(server);
   registerAdminTools(server);
 }
 
 // src/server.ts
+var DEVELOPER_INSTRUCTIONS = "Voc\xEA est\xE1 conectado ao AICRM como Desenvolvedor: seu trabalho \xE9 integrar o sistema desta pessoa ao CRM pela API p\xFAblica, com o SDK @aicrm/sdk. Voc\xEA n\xE3o v\xEA leads nem o time, s\xF3 a estrutura (get_integration_schema), suas chaves e os logs. Roteiro: 1) get_integration_schema; 2) ache no c\xF3digo de onde v\xEAm os leads e mostre \xE0 pessoa o mapeamento campo \u2192 campo do CRM (inclusive os obrigat\xF3rios) antes de escrever; 3) create_api_key em modo test, que grava a chave no .env sem mostr\xE1-la; 4) npm i @aicrm/sdk e escreva o c\xF3digo com externalId; 5) rode e confira em list_api_logs, corrigindo pelos how_to_fix; 6) s\xF3 com o ok da pessoa, create_api_key mode live (confirm_live) e clear_test_leads. Chave secreta (aicrm_sk_) nunca vai para o navegador: no site use publishable. Se a skill aicrm-integrate estiver instalada, siga-a.";
+async function currentRole() {
+  const creds = await loadCredentials();
+  if (!creds) return "";
+  if (creds.user.role) return creds.user.role;
+  return apiFor(creds).get("/auth/me").then((m) => m.user.role, () => "");
+}
 async function startServer() {
+  const role = await currentRole();
+  if (role === "developer") {
+    const dev = new McpServer({ name: "aicrm", version: "0.6.0" }, { instructions: DEVELOPER_INSTRUCTIONS });
+    registerIntegrationTools(dev);
+    await dev.connect(new StdioServerTransport());
+    return;
+  }
   const server = new McpServer(
-    { name: "aicrm", version: "0.2.0" },
+    { name: "aicrm", version: "0.6.0" },
     {
-      instructions: "AICRM \xE9 um CRM de vendas. Workspaces cont\xEAm funis; funis cont\xEAm etapas e leads. Status do lead: open, won, lost. Workspaces, funis, etapas e vendedores podem ser referenciados por nome. Valores monet\xE1rios est\xE3o em reais (BRL). Use get_dashboard/get_forecast para metas e proje\xE7\xF5es estat\xEDsticas (Monte Carlo bayesiano). Cada workspace pode ter campos personalizados (ex.: Cidade, Porte) e esconder campos padr\xE3o: veja list_fields. Em create_lead/update_lead, preencha-os em custom_fields usando o nome do campo. Lead ganho n\xE3o troca de funil: para levar o cliente adiante (ex.: Aquisi\xE7\xE3o \u2192 Relacionamento), use handoff_lead ou next_funnel em mark_won, que criam um lead novo ligado ao ganho. Antes de importar um CSV desconhecido, rode import_leads_csv com dry_run=true para revisar o mapeamento de colunas. Admins tamb\xE9m gerenciam time (invite_user, update_user), estrutura (create_workspace, create_funnel, update_funnel), metas e comiss\xF5es (set_goals, save_commission_plan) e modo TV. O servidor aplica as permiss\xF5es do usu\xE1rio logado: se uma a\xE7\xE3o for negada, explique que precisa de um admin. A\xE7\xF5es destrutivas (delete_*, archive_field, revoke_*) exigem confirma\xE7\xE3o expl\xEDcita da pessoa antes."
+      instructions: 'AICRM \xE9 um CRM de vendas. Workspaces cont\xEAm funis; funis cont\xEAm etapas e leads. Status do lead: open, won, lost. Workspaces, funis, etapas e vendedores podem ser referenciados por nome. Valores monet\xE1rios est\xE3o em reais (BRL). Use get_dashboard/get_forecast para metas e proje\xE7\xF5es estat\xEDsticas (Monte Carlo bayesiano). Para "o que eu fa\xE7o hoje?", use get_today_plan: lista os leads que mais ajudam a bater a meta, com motivo e a\xE7\xE3o sugerida. Cada workspace pode ter campos personalizados (ex.: Cidade, Porte) e esconder campos padr\xE3o: veja list_fields. Em create_lead/update_lead, preencha-os em custom_fields usando o nome do campo. Lead ganho n\xE3o troca de funil: para levar o cliente adiante (ex.: Aquisi\xE7\xE3o \u2192 Relacionamento), use handoff_lead ou next_funnel em mark_won, que criam um lead novo ligado ao ganho. Antes de importar um CSV desconhecido, rode import_leads_csv com dry_run=true para revisar o mapeamento de colunas. Pap\xE9is: admin configura tudo (estrutura, campos, comiss\xF5es, pap\xE9is); manager (Master) lidera o time s\xF3 nos workspaces dele: v\xEA todos os leads, importa e distribui, reatribui e exclui leads, define metas (set_goals), pausa/libera vendedores, usa modo TV e convida vendedores; member \xE9 o vendedor. Admins e Masters n\xE3o recebem leads automaticamente (distribui\xE7\xE3o e rod\xEDzio v\xE3o s\xF3 para vendedores), mas podem assumir um lead de prop\xF3sito. Funis com auto_assign distribuem leads sem vendedor por desempenho; quem passa um dia \xFAtil sem nenhuma a\xE7\xE3o no funil para de receber at\xE9 um Master ou admin liberar: veja get_distribution, release_seller e pause_seller. O servidor aplica as permiss\xF5es do usu\xE1rio logado: se uma a\xE7\xE3o for negada, explique que precisa de um admin ou Master. A\xE7\xF5es destrutivas (delete_*, archive_field, revoke_*) exigem confirma\xE7\xE3o expl\xEDcita da pessoa antes.'
     }
   );
   server.registerTool(
@@ -1364,7 +2028,8 @@ async function startServer() {
             goal_kpi: f.goalKpi,
             ...f.goalKpi === "stage_reached" ? { goal_stage: f.stages.find((s) => s.id === f.goalStageId)?.name ?? null } : {},
             ...f.nextFunnelId ? { after_won_continue_in: c.funnels.get(f.nextFunnelId)?.name ?? null } : {},
-            stages: f.stages.map((s) => `${s.name} (${s.probability}%)`)
+            ...f.autoAssign ? { auto_assign: "leads sem vendedor s\xE3o distribu\xEDdos por desempenho" } : {},
+            stages: f.stages.map((s) => `${s.name} (${s.probability}%${s.limitDays ? `, prazo ${s.limitDays} dias \xFAteis` : ""})`)
           }))
         })),
         sellers: c.users.filter((u) => u.active).map((u) => `${u.name} <${u.email}>`)
@@ -1375,17 +2040,17 @@ async function startServer() {
     "search_leads",
     {
       title: "Buscar leads",
-      description: "Busca leads por texto e filtros. filter: mine (meus), stale (parados h\xE1 14+ dias), no_next_step (sem pr\xF3ximo passo).",
+      description: "Busca leads por texto e filtros. filter: mine (meus), stale (passaram do prazo da etapa, em dias \xFAteis), no_next_step (sem pr\xF3ximo passo).",
       inputSchema: {
-        query: z7.string().optional().describe("Texto em nome, empresa ou email"),
-        workspace: z7.string().optional(),
-        funnel: z7.string().optional(),
-        stage: z7.string().optional(),
-        owner: z7.string().optional().describe("Nome ou email do respons\xE1vel"),
-        status: z7.enum(["open", "won", "lost"]).optional(),
-        filter: z7.enum(["mine", "stale", "no_next_step"]).optional(),
-        field_filters: z7.record(z7.string(), z7.string()).optional().describe('Filtra por campos personalizados: { "Cidade": "Recife" }. Texto: cont\xE9m; demais tipos: igual (datas em dd/mm/aaaa, sim/n\xE3o).'),
-        limit: z7.number().int().min(1).max(200).default(25)
+        query: z10.string().optional().describe("Texto em nome, empresa ou email"),
+        workspace: z10.string().optional(),
+        funnel: z10.string().optional(),
+        stage: z10.string().optional(),
+        owner: z10.string().optional().describe("Nome ou email do respons\xE1vel"),
+        status: z10.enum(["open", "won", "lost"]).optional(),
+        filter: z10.enum(["mine", "stale", "no_next_step"]).optional(),
+        field_filters: z10.record(z10.string(), z10.string()).optional().describe('Filtra por campos personalizados: { "Cidade": "Recife" }. Texto: cont\xE9m; demais tipos: igual (datas em dd/mm/aaaa, sim/n\xE3o).'),
+        limit: z10.number().int().min(1).max(200).default(25)
       },
       annotations: { readOnlyHint: true }
     },
@@ -1420,7 +2085,7 @@ async function startServer() {
     {
       title: "Detalhes do lead",
       description: "Retorna todos os campos de um lead e o hist\xF3rico (movimenta\xE7\xF5es e notas).",
-      inputSchema: { lead_id: z7.string().uuid() },
+      inputSchema: { lead_id: z10.string().uuid() },
       annotations: { readOnlyHint: true }
     },
     withApi(async (api, a) => {
@@ -1453,17 +2118,17 @@ async function startServer() {
     })
   );
   const leadFields = {
-    name: z7.string().optional(),
-    company: z7.string().optional(),
-    email: z7.string().optional(),
-    phone: z7.string().optional(),
-    title: z7.string().optional(),
-    value: z7.number().min(0).optional().describe("Valor do neg\xF3cio em reais"),
-    source: z7.enum(LEAD_SOURCES).optional(),
-    next_step: z7.string().optional(),
-    next_step_date: z7.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
-    expected_close: z7.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
-    custom_fields: z7.record(z7.string(), z7.union([z7.string(), z7.number(), z7.boolean(), z7.null()])).optional().describe('Campos personalizados do workspace pelo nome: { "Cidade": "Recife", "Faturamento": 50000 }. Dinheiro em reais; null limpa o campo. Veja list_fields.')
+    name: z10.string().optional(),
+    company: z10.string().optional(),
+    email: z10.string().optional(),
+    phone: z10.string().optional(),
+    title: z10.string().optional(),
+    value: z10.number().min(0).optional().describe("Valor do neg\xF3cio em reais"),
+    source: z10.enum(LEAD_SOURCES).optional(),
+    next_step: z10.string().optional(),
+    next_step_date: z10.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+    expected_close: z10.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+    custom_fields: z10.record(z10.string(), z10.union([z10.string(), z10.number(), z10.boolean(), z10.null()])).optional().describe('Campos personalizados do workspace pelo nome: { "Cidade": "Recife", "Faturamento": 50000 }. Dinheiro em reais; null limpa o campo. Veja list_fields.')
   };
   const toBody = (a) => Object.fromEntries(
     Object.entries({
@@ -1483,8 +2148,8 @@ async function startServer() {
     "create_lead",
     {
       title: "Criar lead",
-      description: "Cria um lead. Sem funil/etapa, usa o primeiro funil do workspace e a primeira etapa. O respons\xE1vel padr\xE3o \xE9 voc\xEA.",
-      inputSchema: { ...leadFields, name: z7.string(), workspace: z7.string().optional(), funnel: z7.string().optional(), stage: z7.string().optional(), owner: z7.string().optional() }
+      description: "Cria um lead. Sem funil/etapa, usa o primeiro funil do workspace e a primeira etapa. Vendedor: o respons\xE1vel padr\xE3o \xE9 voc\xEA. Admin ou Master sem owner: o AICRM escolhe um vendedor pelo desempenho (veja get_distribution); se ningu\xE9m puder receber, o lead fica sem respons\xE1vel.",
+      inputSchema: { ...leadFields, name: z10.string(), workspace: z10.string().optional(), funnel: z10.string().optional(), stage: z10.string().optional(), owner: z10.string().optional() }
     },
     withApi(async (api, a) => {
       const c = await ctx(api);
@@ -1507,7 +2172,7 @@ async function startServer() {
     {
       title: "Atualizar lead",
       description: 'Atualiza campos de um lead (s\xF3 os informados; texto vazio "" limpa um campo padr\xE3o). Use owner para reatribuir, ou owner="none" para deixar sem respons\xE1vel.',
-      inputSchema: { lead_id: z7.string().uuid(), ...leadFields, owner: z7.string().optional() }
+      inputSchema: { lead_id: z10.string().uuid(), ...leadFields, owner: z10.string().optional() }
     },
     withApi(async (api, a) => {
       const c = await ctx(api);
@@ -1527,8 +2192,8 @@ async function startServer() {
     "move_lead",
     {
       title: "Mover lead",
-      description: "Move um lead para outra etapa \u2014 e opcionalmente para outro funil (entre workspaces: s\xF3 admins). Lead ganho n\xE3o muda de funil (a venda precisa continuar contando onde foi fechada): para lev\xE1-lo a outro funil, use handoff_lead.",
-      inputSchema: { lead_id: z7.string().uuid(), stage: z7.string().describe("Nome ou id da etapa de destino"), funnel: z7.string().optional().describe("Funil de destino (padr\xE3o: o atual)") }
+      description: "Move um lead para outra etapa \u2014 e opcionalmente para outro funil (entre workspaces: s\xF3 admins e Masters). Lead ganho n\xE3o muda de funil (a venda precisa continuar contando onde foi fechada): para lev\xE1-lo a outro funil, use handoff_lead.",
+      inputSchema: { lead_id: z10.string().uuid(), stage: z10.string().describe("Nome ou id da etapa de destino"), funnel: z10.string().optional().describe("Funil de destino (padr\xE3o: o atual)") }
     },
     withApi(async (api, a) => {
       const c = await ctx(api);
@@ -1545,12 +2210,12 @@ async function startServer() {
       title: "Marcar como ganho",
       description: "Marca o lead como ganho. Informe value (R$) se o valor fechado for diferente do cadastrado. Para j\xE1 continuar o cliente em outro funil (ex.: Relacionamento), informe next_funnel: \xE9 criado um lead novo ligado ao ganho, na mesma opera\xE7\xE3o. Se o funil tiver um funil seguinte configurado, a resposta avisa \u2014 pergunte \xE0 pessoa antes de usar handoff_lead.",
       inputSchema: {
-        lead_id: z7.string().uuid(),
-        value: z7.number().min(0).optional(),
-        next_funnel: z7.string().optional().describe("Funil onde o cliente continua depois do ganho"),
-        next_stage: z7.string().optional().describe("Etapa de entrada no pr\xF3ximo funil (padr\xE3o: a primeira)"),
-        next_owner: z7.string().optional().describe("Respons\xE1vel no pr\xF3ximo funil (padr\xE3o: o mesmo)"),
-        next_value: z7.number().min(0).optional().describe("Valor em reais no pr\xF3ximo funil (padr\xE3o: 0)")
+        lead_id: z10.string().uuid(),
+        value: z10.number().min(0).optional(),
+        next_funnel: z10.string().optional().describe("Funil onde o cliente continua depois do ganho"),
+        next_stage: z10.string().optional().describe("Etapa de entrada no pr\xF3ximo funil (padr\xE3o: a primeira)"),
+        next_owner: z10.string().optional().describe("Respons\xE1vel no pr\xF3ximo funil (padr\xE3o: o mesmo)"),
+        next_value: z10.number().min(0).optional().describe("Valor em reais no pr\xF3ximo funil (padr\xE3o: 0)")
       }
     },
     withApi(async (api, a) => {
@@ -1578,7 +2243,7 @@ async function startServer() {
     {
       title: "Marcar como perdido",
       description: "Marca o lead como perdido com um motivo: price, timing, competitor, no_response, no_fit, other.",
-      inputSchema: { lead_id: z7.string().uuid(), reason: z7.enum(LOST_REASONS), note: z7.string().optional() }
+      inputSchema: { lead_id: z10.string().uuid(), reason: z10.enum(LOST_REASONS), note: z10.string().optional() }
     },
     withApi(async (api, a) => {
       const c = await ctx(api);
@@ -1591,7 +2256,7 @@ async function startServer() {
     {
       title: "Adicionar nota",
       description: "Adiciona uma nota \xE0 linha do tempo do lead.",
-      inputSchema: { lead_id: z7.string().uuid(), note: z7.string().min(1) }
+      inputSchema: { lead_id: z10.string().uuid(), note: z10.string().min(1) }
     },
     withApi(async (api, a) => {
       await api.post(`/leads/${a.lead_id}/notes`, { body: a.note });
@@ -1603,7 +2268,7 @@ async function startServer() {
     {
       title: "Dashboard de metas",
       description: "Metas do time e de cada vendedor no m\xEAs, com probabilidade de bater (Monte Carlo), proje\xE7\xE3o, ritmo, cobertura de pipeline, comiss\xE3o e KPIs descritivos.",
-      inputSchema: { funnel: z7.string().optional(), workspace: z7.string().optional(), month: z7.string().regex(/^\d{4}-\d{2}$/).optional().describe("YYYY-MM; padr\xE3o: m\xEAs atual") },
+      inputSchema: { funnel: z10.string().optional(), workspace: z10.string().optional(), month: z10.string().regex(/^\d{4}-\d{2}$/).optional().describe("YYYY-MM; padr\xE3o: m\xEAs atual") },
       annotations: { readOnlyHint: true }
     },
     withApi(async (api, a) => {
@@ -1639,7 +2304,7 @@ async function startServer() {
     {
       title: "Vai bater a meta?",
       description: "Proje\xE7\xE3o detalhada de um vendedor: probabilidade de bater a meta, intervalo de 80%, ritmo atual vs necess\xE1rio e comiss\xE3o projetada.",
-      inputSchema: { seller: z7.string().describe("Nome ou email do vendedor"), funnel: z7.string().optional(), month: z7.string().regex(/^\d{4}-\d{2}$/).optional() },
+      inputSchema: { seller: z10.string().describe("Nome ou email do vendedor"), funnel: z10.string().optional(), month: z10.string().regex(/^\d{4}-\d{2}$/).optional() },
       annotations: { readOnlyHint: true }
     },
     withApi(async (api, a) => {
@@ -1658,12 +2323,62 @@ async function startServer() {
       });
     })
   );
+  server.registerTool(
+    "get_today_plan",
+    {
+      title: "Plano do dia",
+      description: 'Plano do dia: os leads abertos que mais ajudam o vendedor a bater a meta hoje, em ordem, com o motivo e a a\xE7\xE3o sugerida (WhatsApp, pr\xF3ximo passo ou mover de etapa). Use quando a pessoa perguntar "o que eu fa\xE7o hoje?", "por onde come\xE7o?" ou "quais leads priorizar?". Por padr\xE3o \xE9 o plano de quem est\xE1 logado; admins e Masters podem pedir o de outro vendedor.',
+      inputSchema: {
+        funnel: z10.string().optional(),
+        workspace: z10.string().optional(),
+        seller: z10.string().optional().describe("Nome ou email do vendedor (s\xF3 admins e Masters veem o plano de outra pessoa)"),
+        limit: z10.number().int().min(5).max(10).optional().describe("Quantos leads sugerir (5 a 10; padr\xE3o 7)")
+      },
+      annotations: { readOnlyHint: true }
+    },
+    withApi(async (api, a) => {
+      const c = await ctx(api);
+      const funnel = pickFunnel(c, a.funnel, a.workspace);
+      const userId = a.seller ? findUser(c, a.seller).id : void 0;
+      const d = await api.get(`/today?funnelId=${funnel.id}${userId ? `&userId=${userId}` : ""}${a.limit ? `&limit=${a.limit}` : ""}`);
+      const kpi = d.funnel.goalKpi;
+      const suggest = (i) => i.action.kind === "whatsapp" && i.whatsappUrl ? `Chamar no WhatsApp: ${i.whatsappUrl} (entregue o link; depois registre o pr\xF3ximo passo com update_lead)` : i.action.kind === "move_stage" && i.nextStage ? `Se j\xE1 avan\xE7ou, mover para ${i.nextStage.name} (move_lead)` : "Combinar e registrar o pr\xF3ximo passo com data (update_lead com next_step e next_step_date)";
+      return text({
+        seller: d.seller.name,
+        funnel: d.funnel.name,
+        summary: d.summary,
+        goal: d.goal ? {
+          status: FORECAST_STATUS_LABEL[d.goal.status],
+          probability_to_hit: formatPct(d.goal.probability),
+          actual: formatKpi(kpi, d.goal.actual),
+          target: formatKpi(kpi, d.goal.target),
+          missing: formatKpi(kpi, d.goal.gap),
+          low_confidence: d.goal.lowConfidence
+        } : "sem meta neste m\xEAs (ordem por valor, chance e urg\xEAncia)",
+        plan: d.items.map((i) => ({
+          rank: i.rank,
+          lead_id: i.lead.id,
+          lead: i.lead.company ? `${i.lead.company} \u2014 ${i.lead.name}` : i.lead.name,
+          stage: i.stageName,
+          value: formatMoney(i.lead.valueCents),
+          chance: formatPct(i.chance),
+          ...kpi === "revenue" ? { worth_for_goal: formatMoney(i.expected) } : {},
+          ...i.shareOfGap != null && kpi === "revenue" ? { share_of_missing: formatPct(Math.min(1, i.shareOfGap)) } : {},
+          why: i.reasons.map((r) => r.text),
+          suggested_action: suggest(i),
+          phone: i.lead.phone
+        })),
+        done_today: d.doneToday.map((x) => `${x.name}: ${x.what}`),
+        open_leads: d.counts.open
+      });
+    })
+  );
   server.registerTool(
     "list_fields",
     {
       title: "Campos do workspace",
       description: "Mostra os campos de lead de um workspace: campos padr\xE3o (e quais est\xE3o escondidos), campos personalizados com tipo e op\xE7\xF5es, e os modelos de importa\xE7\xE3o de CSV salvos.",
-      inputSchema: { workspace: z7.string().optional() },
+      inputSchema: { workspace: z10.string().optional() },
       annotations: { readOnlyHint: true }
     },
     withApi(async (api, a) => {
@@ -1695,10 +2410,10 @@ async function startServer() {
       title: "Criar campo personalizado",
       description: "Cria um campo de lead no workspace (s\xF3 admins). Tipos: text, number, money (R$), date, select (lista \u2014 exige options), boolean (sim/n\xE3o), url.",
       inputSchema: {
-        label: z7.string().min(1).max(60).describe("Nome do campo, ex.: Cidade"),
-        type: z7.enum(CUSTOM_FIELD_TYPES),
-        options: z7.array(z7.string()).optional().describe("Op\xE7\xF5es da lista (tipo select)"),
-        workspace: z7.string().optional()
+        label: z10.string().min(1).max(60).describe("Nome do campo, ex.: Cidade"),
+        type: z10.enum(CUSTOM_FIELD_TYPES),
+        options: z10.array(z10.string()).optional().describe("Op\xE7\xF5es da lista (tipo select)"),
+        workspace: z10.string().optional()
       }
     },
     withApi(async (api, a) => {
@@ -1714,10 +2429,10 @@ async function startServer() {
       title: "Editar campo personalizado",
       description: "Renomeia um campo ou troca as op\xE7\xF5es de uma lista (s\xF3 admins). O tipo n\xE3o muda depois de criado. Renomear n\xE3o quebra modelos de importa\xE7\xE3o.",
       inputSchema: {
-        field: z7.string().describe("Nome ou id do campo"),
-        label: z7.string().min(1).max(60).optional(),
-        options: z7.array(z7.string()).optional().describe("Lista completa de op\xE7\xF5es (substitui a atual)"),
-        workspace: z7.string().optional()
+        field: z10.string().describe("Nome ou id do campo"),
+        label: z10.string().min(1).max(60).optional(),
+        options: z10.array(z10.string()).optional().describe("Lista completa de op\xE7\xF5es (substitui a atual)"),
+        workspace: z10.string().optional()
       }
     },
     withApi(async (api, a) => {
@@ -1733,7 +2448,7 @@ async function startServer() {
     {
       title: "Remover campo personalizado",
       description: "Remove um campo das telas e importa\xE7\xF5es (s\xF3 admins). Os valores j\xE1 preenchidos ficam guardados, mas deixam de aparecer.",
-      inputSchema: { field: z7.string().describe("Nome ou id do campo"), workspace: z7.string().optional() },
+      inputSchema: { field: z10.string().describe("Nome ou id do campo"), workspace: z10.string().optional() },
       annotations: { destructiveHint: true }
     },
     withApi(async (api, a) => {
@@ -1750,9 +2465,9 @@ async function startServer() {
       title: "Mostrar/esconder campos padr\xE3o",
       description: `Esconde ou volta a mostrar campos padr\xE3o que o workspace n\xE3o usa (s\xF3 admins). Podem ser escondidos: ${HIDEABLE_FIELDS.join(", ")}. Nome e valor ficam sempre vis\xEDveis.`,
       inputSchema: {
-        hide: z7.array(z7.enum(HIDEABLE_FIELDS)).optional(),
-        show: z7.array(z7.enum(HIDEABLE_FIELDS)).optional(),
-        workspace: z7.string().optional()
+        hide: z10.array(z10.enum(HIDEABLE_FIELDS)).optional(),
+        show: z10.array(z10.enum(HIDEABLE_FIELDS)).optional(),
+        workspace: z10.string().optional()
       }
     },
     withApi(async (api, a) => {
@@ -1768,7 +2483,7 @@ async function startServer() {
     {
       title: "Renomear modelo de importa\xE7\xE3o",
       description: "Renomeia um modelo de importa\xE7\xE3o de CSV (admins ou quem criou o modelo).",
-      inputSchema: { template: z7.string().describe("Nome ou id do modelo"), name: z7.string().min(1).max(80), workspace: z7.string().optional() }
+      inputSchema: { template: z10.string().describe("Nome ou id do modelo"), name: z10.string().min(1).max(80), workspace: z10.string().optional() }
     },
     withApi(async (api, a) => {
       const c = await ctx(api);
@@ -1783,7 +2498,7 @@ async function startServer() {
     {
       title: "Apagar modelo de importa\xE7\xE3o",
       description: "Apaga um modelo de importa\xE7\xE3o (admins ou quem criou). Leads j\xE1 importados n\xE3o mudam.",
-      inputSchema: { template: z7.string().describe("Nome ou id do modelo"), workspace: z7.string().optional() },
+      inputSchema: { template: z10.string().describe("Nome ou id do modelo"), workspace: z10.string().optional() },
       annotations: { destructiveHint: true }
     },
     withApi(async (api, a) => {
@@ -1800,15 +2515,17 @@ async function startServer() {
       title: "Importar CSV",
       description: 'Importa leads de um arquivo CSV local. As colunas s\xE3o ligadas aos campos do workspace (padr\xE3o e personalizados); se a planilha j\xE1 foi importada antes, o modelo salvo \xE9 reaproveitado. Use dry_run=true para ver o mapeamento, colunas ignoradas (com tipo sugerido para criar campo) e problemas antes de gravar. Ajuste com columns: { "Coluna do CSV": "Nome do campo" | "ignorar" }.',
       inputSchema: {
-        path: z7.string().describe("Caminho do arquivo CSV (aceita ~)"),
-        funnel: z7.string().optional(),
-        workspace: z7.string().optional(),
-        stage: z7.string().optional(),
-        owner_mode: z7.enum(["me", "round_robin", "column"]).default("me").describe("me = voc\xEA; round_robin = distribuir; column = coluna 'respons\xE1vel' (email)"),
-        duplicate: z7.enum(["skip", "update"]).default("skip"),
-        columns: z7.record(z7.string(), z7.string()).optional().describe('For\xE7a o destino de colunas: { "Munic\xEDpio": "Cidade", "Obs": "ignorar" }. Aceita campo padr\xE3o (Nome, Empresa, Email\u2026) ou personalizado.'),
-        dry_run: z7.boolean().default(false).describe("S\xF3 mostra o mapeamento e os problemas, sem importar"),
-        template_name: z7.string().max(80).optional().describe("Salva o mapeamento com este nome para as pr\xF3ximas importa\xE7\xF5es")
+        path: z10.string().describe("Caminho do arquivo CSV (aceita ~)"),
+        funnel: z10.string().optional(),
+        workspace: z10.string().optional(),
+        stage: z10.string().optional(),
+        owner_mode: z10.enum(["me", "auto", "round_robin", "column"]).optional().describe(
+          "Padr\xE3o: auto para admins e Masters (eles n\xE3o ficam com a base), me para vendedores. me = voc\xEA; auto = distribuir por desempenho entre os vendedores (quem fecha mais recebe mais); round_robin = distribuir igualmente entre os vendedores; column = coluna 'respons\xE1vel' (email). auto, round_robin e column s\xF3 para admins e Masters."
+        ),
+        duplicate: z10.enum(["skip", "update"]).default("skip"),
+        columns: z10.record(z10.string(), z10.string()).optional().describe('For\xE7a o destino de colunas: { "Munic\xEDpio": "Cidade", "Obs": "ignorar" }. Aceita campo padr\xE3o (Nome, Empresa, Email\u2026) ou personalizado.'),
+        dry_run: z10.boolean().default(false).describe("S\xF3 mostra o mapeamento e os problemas, sem importar"),
+        template_name: z10.string().max(80).optional().describe("Salva o mapeamento com este nome para as pr\xF3ximas importa\xE7\xF5es")
       }
     },
     withApi(
@@ -1818,8 +2535,8 @@ async function startServer() {
         const stage = resolve(funnel.stages, a.stage, "Etapa") ?? funnel.stages[0];
         const ws = c.workspaces.find((w) => w.id === funnel.workspaceId);
         const hidden = ws?.hiddenFields ?? [];
-        const file = path2.resolve(a.path.replace(/^~(?=$|\/)/, homedir2()));
-        const parsed = Papa.parse(await readFile2(file, "utf8"), { header: true, skipEmptyLines: "greedy", transformHeader: (h) => h.trim() });
+        const file = path3.resolve(a.path.replace(/^~(?=$|\/)/, homedir2()));
+        const parsed = Papa.parse(await readFile3(file, "utf8"), { header: true, skipEmptyLines: "greedy", transformHeader: (h) => h.trim() });
         const headers = (parsed.meta.fields ?? []).filter(Boolean);
         const [fields, templates] = await Promise.all([listFields(api, funnel.workspaceId), listTemplates(api, funnel.workspaceId)]);
         const match = matchTemplate(headers, templates);
@@ -1890,16 +2607,18 @@ async function startServer() {
         }
         const template = a.template_name ? { id: match?.template.name === a.template_name ? match.template.id : void 0, name: a.template_name, columns: mapping } : match && !changedFromTemplate ? { id: match.template.id, name: match.template.name, columns: mapping } : void 0;
         const me = await api.get("/auth/me");
+        const ownerMode = a.owner_mode ?? (me.user.role === "member" ? "me" : "auto");
         const res = await api.post(
           "/imports",
           {
             funnelId: funnel.id,
             stageId: stage.id,
-            ownerMode: a.owner_mode === "me" ? "fixed" : a.owner_mode,
-            ownerId: a.owner_mode === "me" ? me.user.id : void 0,
+            ownerMode: ownerMode === "me" ? "fixed" : ownerMode,
+            ownerId: ownerMode === "me" ? me.user.id : void 0,
             duplicate: a.duplicate,
             rows,
-            template
+            template,
+            origin: { fileName: path3.basename(a.path).slice(0, 200), valueColumn: headers.find((h) => mapping[h] === "std:value") }
           }
         );
         return text({
@@ -1915,9 +2634,19 @@ async function startServer() {
     )
   );
   registerManageTools(server);
+  if (role === "admin") registerIntegrationTools(server);
   await server.connect(new StdioServerTransport());
 }
 
+// src/skills.ts
+var SKILLS = ["aicrm", "aicrm-integrate"];
+function parseSkillArgs(args) {
+  const positional = args.filter((a, i) => !a.startsWith("--") && args[i - 1] !== "--dir");
+  const install = positional.includes("install");
+  const name = positional.find((a) => a !== "install") ?? "aicrm";
+  return { install, name };
+}
+
 // src/cli.ts
 var HELP = `AICRM MCP
 
@@ -1925,9 +2654,10 @@ Uso:
   aicrm-mcp login [--url https://seu-aicrm] [--email voce@empresa.com]
   aicrm-mcp logout
   aicrm-mcp whoami
-  aicrm-mcp skill                    imprime o SKILL.md (guia para agentes)
-  aicrm-mcp skill install [--project | --dir <pasta>]
-                                     instala em ~/.claude/skills/aicrm (ou no projeto atual)
+  aicrm-mcp skill [nome]             imprime o SKILL.md (guia para agentes)
+  aicrm-mcp skill install [nome] [--project | --dir <pasta>]
+                                     instala em ~/.claude/skills/<nome> (ou no projeto atual)
+      skills: aicrm (operar o CRM) \xB7 aicrm-integrate (integrar um sistema pela API)
   aicrm-mcp            inicia o servidor MCP (stdio) \u2014 use no seu cliente MCP
 
 Configurar:
@@ -1940,7 +2670,7 @@ function flag(name) {
 }
 async function login() {
   const existing = await loadCredentials();
-  const url = normalizeUrl(flag("url") ?? process.env.AICRM_URL ?? await ask("URL do AICRM", existing?.url ?? "http://localhost:5173"));
+  const url = normalizeUrl(flag("url") ?? process.env.AICRM_URL ?? await ask("URL do AICRM", existing?.url ?? "https://aicrm.dev"));
   const email2 = flag("email") ?? await ask("Email", existing?.user.email || void 0);
   const password2 = await askHidden("Senha");
   try {
@@ -1956,6 +2686,10 @@ async function login() {
     console.log(`
 Agora adicione ao seu cliente:
   claude mcp add aicrm -- npx -y aicrm-mcp`);
+    if (res.user.role === "developer")
+      console.log(`
+E instale o guia de integra\xE7\xE3o no projeto:
+  npx -y aicrm-mcp skill install aicrm-integrate --project`);
   } catch (e) {
     console.error(`
 \u2717 ${e.message}`);
@@ -1983,14 +2717,18 @@ async function whoami() {
     process.exit(1);
   }
 }
-var SKILL_PATH = new URL("../skill/aicrm/SKILL.md", import.meta.url);
 async function skill() {
-  const content = await readFile3(SKILL_PATH, "utf8");
-  if (process.argv[3] !== "install") return void process.stdout.write(content);
-  const base = flag("dir") ?? (process.argv.includes("--project") ? path3.join(process.cwd(), ".claude", "skills") : path3.join(homedir3(), ".claude", "skills"));
-  const target = path3.join(base, "aicrm", "SKILL.md");
-  await mkdir2(path3.dirname(target), { recursive: true });
-  await writeFile2(target, content);
+  const { install, name } = parseSkillArgs(process.argv.slice(3));
+  if (!SKILLS.includes(name)) {
+    console.error(`Skill desconhecido: ${name}. Dispon\xEDveis: ${SKILLS.join(", ")}`);
+    process.exit(1);
+  }
+  const content = await readFile4(new URL(`../skill/${name}/SKILL.md`, import.meta.url), "utf8");
+  if (!install) return void process.stdout.write(content);
+  const base = flag("dir") ?? (process.argv.includes("--project") ? path4.join(process.cwd(), ".claude", "skills") : path4.join(homedir3(), ".claude", "skills"));
+  const target = path4.join(base, name, "SKILL.md");
+  await mkdir2(path4.dirname(target), { recursive: true });
+  await writeFile3(target, content);
   console.log(`\u2713 Skill instalado em ${target}`);
 }
 var cmd = process.argv[2];