ponch-mcp-server 1.0.83 → 1.0.84

package/dist/index.js

@@ -2478,7 +2478,7 @@ function registerCoreTools(server, session) {
 }
 
 // src/tools/marketing.ts
-var import_zod49 = require("zod");
+var import_zod51 = require("zod");
 
 // ../packages/martin-schemas/dist/index.js
 var import_zod21 = require("zod");
@@ -9753,6 +9753,96 @@ async function getCurrentUsage(_tenantId, _quotaName) {
 function getWrapperMessage(key, locale) {
   return getMessage(`marketing.wrapper.${key}`, locale);
 }
+function _extractReceived(issue) {
+  if (issue.received !== void 0 && issue.received !== null) {
+    return String(issue.received);
+  }
+  const m = issue.message?.match(/received\s+(\w+)/i);
+  return m ? m[1] : "unknown";
+}
+function _placeholderForType(expected, locale) {
+  switch (expected) {
+    case "string":
+      return locale === "en" ? '"a-string"' : '"un-texto"';
+    case "number":
+      return "42";
+    case "integer":
+      return "42";
+    case "boolean":
+      return "true";
+    case "array":
+      return "[]";
+    case "object":
+      return "{}";
+    case "null":
+      return "null";
+    default:
+      return locale === "en" ? '"a-value"' : '"un-valor"';
+  }
+}
+function _unitForOrigin(origin, locale) {
+  if (origin === "string") return locale === "en" ? "characters" : "caracteres";
+  if (origin === "array") return locale === "en" ? "items" : "elementos";
+  if (origin === "set") return locale === "en" ? "items" : "elementos";
+  if (origin === "number" || origin === "bigint" || origin === "int") return "";
+  if (origin === "date") return locale === "en" ? "date" : "fecha";
+  return locale === "en" ? "units" : "unidades";
+}
+function getIssueHumanText(issue, locale) {
+  const field = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+  switch (issue.code) {
+    case "invalid_type": {
+      const expected = String(issue.expected ?? "unknown");
+      const received = _extractReceived(issue);
+      const example = _placeholderForType(issue.expected, locale);
+      return getMessage("marketing.wrapper.issue_invalid_type", locale, {
+        field,
+        expected,
+        received,
+        example
+      });
+    }
+    case "too_small": {
+      const minimum = String(issue.minimum ?? "");
+      const unit = _unitForOrigin(issue.origin, locale);
+      return getMessage("marketing.wrapper.issue_too_small", locale, {
+        field,
+        minimum,
+        unit
+      });
+    }
+    case "too_big": {
+      const maximum = String(issue.maximum ?? "");
+      const unit = _unitForOrigin(issue.origin, locale);
+      return getMessage("marketing.wrapper.issue_too_big", locale, {
+        field,
+        maximum,
+        unit
+      });
+    }
+    case "invalid_enum_value":
+    case "invalid_value": {
+      const opts = (issue.options ?? []).map((o) => JSON.stringify(o)).join(", ");
+      return getMessage("marketing.wrapper.issue_invalid_enum", locale, {
+        field,
+        options: opts
+      });
+    }
+    case "invalid_string":
+    case "invalid_format": {
+      const hint = issue.validation ? `(${issue.validation})` : "";
+      return getMessage("marketing.wrapper.issue_invalid_string", locale, {
+        field,
+        hint
+      });
+    }
+    default:
+      return getMessage("marketing.wrapper.issue_generic", locale, {
+        field,
+        message: issue.message
+      });
+  }
+}
 var NIVELES_ORDER = ["ninguno", "ver", "editar", "completo"];
 function nivelAlcanza(nivel, accion) {
   return NIVELES_ORDER.indexOf(nivel) >= NIVELES_ORDER.indexOf(accion);
@@ -9855,9 +9945,16 @@ function wrapWithContract(contract, helper, options = {}) {
           expected: issue.expected
         };
       });
-      const camposFallidos = validationErrors.map((v) => v.path.join(".")).filter(Boolean);
-      const baseMsg = getWrapperMessage("input_invalido", locale);
-      const text = camposFallidos.length ? locale === "en" ? `${baseMsg} Issues with: ${camposFallidos.join(", ")}.` : `${baseMsg} Hubo problemas con: ${camposFallidos.join(", ")}.` : baseMsg;
+      let text;
+      if (parseResult.error.issues.length === 0) {
+        text = getWrapperMessage("input_invalido", locale);
+      } else {
+        const intro = getWrapperMessage("input_invalido_intro", locale);
+        const lines = parseResult.error.issues.map(
+          (i) => getIssueHumanText(i, locale)
+        );
+        text = `${intro} ${lines.join(" ")}`;
+      }
       await writeAuditLog({
         tenantId: ctx.tenantId,
         brandId: ctx.brandId ?? null,
@@ -10736,18 +10833,20 @@ var import_zod35 = require("zod");
 var import_firebase_admin7 = require("firebase-admin");
 var import_zod36 = require("zod");
 var import_zod37 = require("zod");
-var import_firebase_admin8 = require("firebase-admin");
 var import_zod38 = require("zod");
 var import_zod39 = require("zod");
+var import_firebase_admin8 = require("firebase-admin");
 var import_zod40 = require("zod");
-var import_firebase_admin9 = require("firebase-admin");
 var import_zod41 = require("zod");
-var import_firebase_admin10 = require("firebase-admin");
 var import_zod42 = require("zod");
+var import_firebase_admin9 = require("firebase-admin");
 var import_zod43 = require("zod");
+var import_firebase_admin10 = require("firebase-admin");
 var import_zod44 = require("zod");
 var import_zod45 = require("zod");
 var import_zod46 = require("zod");
+var import_zod47 = require("zod");
+var import_zod48 = require("zod");
 var import_firestore6 = require("firebase-admin/firestore");
 var RULE_NEGATIVES = {
   allowFaces: "no people, no faces, no hands",
@@ -12062,6 +12161,229 @@ var rawContract7 = {
 var getCalendarContract = MartinContractSchema.parse(
   rawContract7
 );
+async function seoSnapshotReader(input) {
+  const { db, tenantId, brandId } = input;
+  const brandRef = db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId);
+  const brandSnap = await brandRef.get();
+  if (!brandSnap.exists) {
+    return { ok: false, code: "BRAND_NOT_FOUND" };
+  }
+  const snap = await db.collection("tenants").doc(tenantId).collection("marketing_snapshots_semrush").where("brandId", "==", brandId).orderBy("mes", "desc").limit(1).get();
+  if (snap.empty) {
+    return { ok: false, code: "SEO_SNAPSHOT_MISSING" };
+  }
+  const doc = snap.docs[0];
+  const data = doc.data();
+  const mes = typeof data.mes === "string" ? data.mes : "";
+  return {
+    ok: true,
+    brandId,
+    mes,
+    snapshot: { id: doc.id, ...data }
+  };
+}
+var ParamsSchema8 = import_zod38.z.object({
+  tenantId: import_zod38.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod38.z.string().min(1).describe("Brand identifier within the tenant.")
+});
+var SuccessSchema = import_zod38.z.object({
+  ok: import_zod38.z.literal(true),
+  brandId: import_zod38.z.string(),
+  mes: import_zod38.z.string(),
+  snapshot: import_zod38.z.record(import_zod38.z.string(), import_zod38.z.unknown())
+});
+var FailureSchema = import_zod38.z.object({
+  ok: import_zod38.z.literal(false),
+  code: import_zod38.z.enum(["BRAND_NOT_FOUND", "SEO_SNAPSHOT_MISSING"])
+});
+var OutputSchema8 = import_zod38.z.discriminatedUnion("ok", [SuccessSchema, FailureSchema]);
+var rawContract8 = {
+  name: "get_seo_snapshot",
+  description: "Read the latest Semrush SEO snapshot for a brand. Returns rank, top keywords, opportunities, and competitors.",
+  paramsSchema: ParamsSchema8,
+  outputSchema: OutputSchema8,
+  requiresConfirmation: false,
+  destructive: false,
+  affectsPublication: false,
+  affectsExternal: false,
+  martinSummaryTemplate: (input, output, locale) => {
+    if (!output.ok) {
+      if (output.code === "BRAND_NOT_FOUND") {
+        return locale === "en" ? `Brand ${input.brandId} not found.` : `No encontr\xE9 la brand ${input.brandId}.`;
+      }
+      return locale === "en" ? `No SEO snapshot for brand ${input.brandId} yet.` : `A\xFAn no hay snapshot SEO de ${input.brandId}.`;
+    }
+    return locale === "en" ? `Latest SEO snapshot for ${input.brandId} (${output.mes}).` : `Snapshot SEO m\xE1s reciente de ${input.brandId} (${output.mes}).`;
+  },
+  // AUDITA SIEMPRE — regla A5. Lectura no muta, changes son null/null.
+  auditAction: "marketing.seo_snapshot.leer",
+  quotasConsumed: [],
+  permissionScope: "module",
+  permissionKey: "marketing",
+  permissionAction: "ver",
+  sideEffects: ["reads_firestore"]
+};
+var seoSnapshotReaderContract = MartinContractSchema.parse(
+  rawContract8
+);
+var BEST_PRACTICES_EN = {
+  title: "Primary keyword, clear and short. Page H1.",
+  description: "Above grid: 2-3 sentences (50-70 words). Below grid: 200-400 words with long-tail keywords. Pages with descriptions rank 2.7x higher.",
+  metaTitle: "50-60 chars. Keyword first. Format: {Keyword} | {Brand}. Max 600px.",
+  metaDescription: "120-158 chars. Keyword + CTA + value prop. 120 mobile, 158 desktop.",
+  handle: "Keyword in URL. NEVER change an indexed URL without a 301 redirect.",
+  imageAlt: "Descriptive with keyword. Accessibility + Google Images + AEO.",
+  aeo: "AI engines validate images against schema. Structured data matters."
+};
+var SCHEMA_FOR_SAVE_EN = {
+  _instructions: "STRICT SCHEMA for save_collection_suggestions. Use EXACTLY these field names. The system WILL REJECT mismatched fields.",
+  _example: {
+    collectionId: 123456789,
+    suggestedTitle: "Purple Flowers | Same-Day CDMX Delivery",
+    suggestedDescription: "<p>Discover our purple flowers collection...</p>",
+    suggestedMetaTitle: "Purple Flowers CDMX | Same-Day Delivery",
+    suggestedMetaDescription: "Send purple flowers to your door in CDMX. Fresh arrangements with purple roses, tulips, and lilies. Same-day delivery.",
+    suggestedHandle: null,
+    suggestedImageAlt: "Bouquet of purple flowers with roses and tulips \u2014 local florist CDMX",
+    keyword: "purple flowers cdmx",
+    notas: "Meta title optimized with local keyword. Description expanded with long-tail keywords. Handle unchanged (already indexed)."
+  },
+  _rules: [
+    "collectionId: REQUIRED. Numeric Shopify ID (not GID).",
+    "suggestedTitle: string. Page H1. Clear with keyword.",
+    "suggestedDescription: HTML string. 200-400 words. Include links to related collections.",
+    "suggestedMetaTitle: string. 50-60 chars. Keyword first. NEVER over 60.",
+    "suggestedMetaDescription: string. 120-158 chars. Keyword + CTA + value prop. NEVER over 158.",
+    "suggestedHandle: string | null. Only change if the current handle is bad. null = no change.",
+    "suggestedImageAlt: string. Descriptive with keyword. For accessibility + Google Images.",
+    "keyword: string. Target keyword for this collection (from the marketing plan).",
+    "notas: string. Brief explanation of what changed and why."
+  ],
+  _never: [
+    "NEVER use Spanish field names (titulo, descripcion, etc.) \u2014 use English names.",
+    "NEVER fabricate collectionId \u2014 use the id from the collections array.",
+    "NEVER exceed 60 chars in metaTitle or 158 chars in metaDescription.",
+    "NEVER change the handle of an indexed collection without justification."
+  ]
+};
+async function collectionsReader(input) {
+  const { db, tenantId, brandId } = input;
+  const brandRef = db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId);
+  const brandSnap = await brandRef.get();
+  if (!brandSnap.exists) {
+    return { ok: false, code: "BRAND_NOT_FOUND" };
+  }
+  const collSnap = await db.collection("tenants").doc(tenantId).collection("marketing_snapshots").doc(brandId).collection("collections").get();
+  if (collSnap.empty) {
+    return { ok: false, code: "NO_COLLECTIONS_NESTED" };
+  }
+  const items = collSnap.docs.map((d) => d.data());
+  const brand = brandSnap.data() ?? {};
+  const plan = brand.plan ?? {};
+  const keywordsPrioritarios = Array.isArray(plan.keywordsPrioritarios) ? plan.keywordsPrioritarios : [];
+  const existingSuggestions = brand.collectionSuggestions ?? {};
+  const collections = items.map((c) => {
+    const seo = c.seo || {};
+    const featured = c.featuredImage || null;
+    return {
+      id: c.platformId,
+      title: c.title,
+      handle: c.handle,
+      body_html: typeof c.descriptionHtml === "string" ? c.descriptionHtml.slice(0, 500) : null,
+      metaTitle: seo.metaTitle ?? null,
+      metaDescription: seo.metaDescription ?? null,
+      products_count: null,
+      collectionType: "canonical",
+      image: featured ? { src: featured.url, alt: featured.altText } : null,
+      existingSuggestion: existingSuggestions[String(c.platformId)] ?? null
+    };
+  });
+  return {
+    ok: true,
+    brandId,
+    totalCollections: collections.length,
+    keywordsPrioritarios,
+    collections,
+    bestPractices: BEST_PRACTICES_EN,
+    schemaParaSave: SCHEMA_FOR_SAVE_EN
+  };
+}
+var ParamsSchema9 = import_zod39.z.object({
+  tenantId: import_zod39.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod39.z.string().min(1).describe("Brand identifier within the tenant.")
+});
+var CollectionItemSchema = import_zod39.z.object({
+  id: import_zod39.z.unknown(),
+  title: import_zod39.z.unknown(),
+  handle: import_zod39.z.unknown(),
+  body_html: import_zod39.z.string().nullable(),
+  metaTitle: import_zod39.z.unknown(),
+  metaDescription: import_zod39.z.unknown(),
+  products_count: import_zod39.z.null(),
+  collectionType: import_zod39.z.literal("canonical"),
+  image: import_zod39.z.object({ src: import_zod39.z.unknown(), alt: import_zod39.z.unknown() }).nullable(),
+  existingSuggestion: import_zod39.z.record(import_zod39.z.string(), import_zod39.z.unknown()).nullable()
+});
+var BestPracticesSchema = import_zod39.z.object({
+  title: import_zod39.z.string(),
+  description: import_zod39.z.string(),
+  metaTitle: import_zod39.z.string(),
+  metaDescription: import_zod39.z.string(),
+  handle: import_zod39.z.string(),
+  imageAlt: import_zod39.z.string(),
+  aeo: import_zod39.z.string()
+});
+var SchemaForSaveSchema = import_zod39.z.object({
+  _instructions: import_zod39.z.string(),
+  _example: import_zod39.z.record(import_zod39.z.string(), import_zod39.z.unknown()),
+  _rules: import_zod39.z.array(import_zod39.z.string()),
+  _never: import_zod39.z.array(import_zod39.z.string())
+});
+var SuccessSchema2 = import_zod39.z.object({
+  ok: import_zod39.z.literal(true),
+  brandId: import_zod39.z.string(),
+  totalCollections: import_zod39.z.number(),
+  // Shape real: Array<{ keyword, posicion, volumen, dificultad, prioridad, accion }>.
+  // Passthrough loose para no acoplar el reader al schema interno del plan.
+  keywordsPrioritarios: import_zod39.z.array(import_zod39.z.record(import_zod39.z.string(), import_zod39.z.unknown())),
+  collections: import_zod39.z.array(CollectionItemSchema),
+  bestPractices: BestPracticesSchema,
+  schemaParaSave: SchemaForSaveSchema
+});
+var FailureSchema2 = import_zod39.z.object({
+  ok: import_zod39.z.literal(false),
+  code: import_zod39.z.enum(["BRAND_NOT_FOUND", "NO_COLLECTIONS_NESTED"])
+});
+var OutputSchema9 = import_zod39.z.discriminatedUnion("ok", [SuccessSchema2, FailureSchema2]);
+var rawContract9 = {
+  name: "get_collections",
+  description: "Read all canonical collections (Shopify/WordPress/web-only) for a brand with their 6 SEO fields, plus best practices and the strict schema for generating SEO suggestions.",
+  paramsSchema: ParamsSchema9,
+  outputSchema: OutputSchema9,
+  requiresConfirmation: false,
+  destructive: false,
+  affectsPublication: false,
+  affectsExternal: false,
+  martinSummaryTemplate: (input, output, locale) => {
+    if (!output.ok) {
+      if (output.code === "BRAND_NOT_FOUND") {
+        return locale === "en" ? `Brand ${input.brandId} not found.` : `No encontr\xE9 la brand ${input.brandId}.`;
+      }
+      return locale === "en" ? `No collections synced for ${input.brandId} yet.` : `A\xFAn no hay colecciones sincronizadas para ${input.brandId}.`;
+    }
+    return locale === "en" ? `${output.totalCollections} collections for ${input.brandId}.` : `${output.totalCollections} colecciones para ${input.brandId}.`;
+  },
+  // AUDITA SIEMPRE — regla A5. Lectura no muta, changes son null/null.
+  auditAction: "marketing.colecciones.listar",
+  quotasConsumed: [],
+  permissionScope: "module",
+  permissionKey: "marketing",
+  permissionAction: "ver",
+  sideEffects: ["reads_firestore"]
+};
+var collectionsReaderContract = MartinContractSchema.parse(
+  rawContract9
+);
 var PLATAFORMA_A_FORMATO = {
   gbp: "gbp_4_3",
   shopify_blog: "blog_3_2",
@@ -12173,35 +12495,35 @@ async function photoAssigner(input) {
     formato
   };
 }
-var ParamsSchema8 = import_zod38.z.object({
-  tenantId: import_zod38.z.string().min(1).describe("Tenant identifier (the business account)."),
-  brandId: import_zod38.z.string().min(1).describe("Brand identifier within the tenant."),
-  contenidoRef: import_zod38.z.string().min(1).describe("Document ID in marketing_contenido (the post receiving the photo)."),
-  fotoId: import_zod38.z.string().min(1).describe("Photo ID in marketing_fotos. Photo must be in state='editada'."),
-  calendarioItemRef: import_zod38.z.string().regex(/^semana:\d+:slot:\d+$/).optional().describe(
+var ParamsSchema10 = import_zod40.z.object({
+  tenantId: import_zod40.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod40.z.string().min(1).describe("Brand identifier within the tenant."),
+  contenidoRef: import_zod40.z.string().min(1).describe("Document ID in marketing_contenido (the post receiving the photo)."),
+  fotoId: import_zod40.z.string().min(1).describe("Photo ID in marketing_fotos. Photo must be in state='editada'."),
+  calendarioItemRef: import_zod40.z.string().regex(/^semana:\d+:slot:\d+$/).optional().describe(
     'Calendar slot reference in format "semana:N:slot:M". Optional \u2014 if provided, syncs the slot.fotoIdAsignada UI snapshot atomically with the content update. OMIT if there is no calendar slot to sync.'
   )
 });
-var OutputSchema8 = import_zod38.z.discriminatedUnion("ok", [
-  import_zod38.z.object({
-    ok: import_zod38.z.literal(true),
-    fotoId: import_zod38.z.string(),
-    contenidoRef: import_zod38.z.string(),
-    plataforma: import_zod38.z.string(),
-    varianteUrl: import_zod38.z.string().nullable(),
-    formato: import_zod38.z.string()
+var OutputSchema10 = import_zod40.z.discriminatedUnion("ok", [
+  import_zod40.z.object({
+    ok: import_zod40.z.literal(true),
+    fotoId: import_zod40.z.string(),
+    contenidoRef: import_zod40.z.string(),
+    plataforma: import_zod40.z.string(),
+    varianteUrl: import_zod40.z.string().nullable(),
+    formato: import_zod40.z.string()
   }),
-  import_zod38.z.object({
-    ok: import_zod38.z.literal(false),
-    error: import_zod38.z.string(),
-    code: import_zod38.z.enum(["CONTENT_NOT_FOUND", "CONTENT_TENANT_MISMATCH", "PHOTO_NOT_FOUND", "PHOTO_NOT_READY"]).optional()
+  import_zod40.z.object({
+    ok: import_zod40.z.literal(false),
+    error: import_zod40.z.string(),
+    code: import_zod40.z.enum(["CONTENT_NOT_FOUND", "CONTENT_TENANT_MISMATCH", "PHOTO_NOT_FOUND", "PHOTO_NOT_READY"]).optional()
   })
 ]);
-var rawContract8 = {
+var rawContract10 = {
   name: "assign_photo_to_content",
   description: 'Assign an edited photo to an existing content. Writes atomically to BOTH marketing_contenido.fotoId+mediaVariante (canonical for publish) AND marketing_calendario slot.fotoIdAsignada (UI snapshot, only if calendarioItemRef provided). NEVER use update_calendar_slot for this \u2014 that one writes to the agenda, not the post. The photo must be in state="editada".',
-  paramsSchema: ParamsSchema8,
-  outputSchema: OutputSchema8,
+  paramsSchema: ParamsSchema10,
+  outputSchema: OutputSchema10,
   // Cambia la foto vinculada al contenido — reversible (volver a llamar con
   // otra fotoId), no publica nada externo. La foto editada queda intacta;
   // solo se actualiza la referencia.
@@ -12243,7 +12565,7 @@ var rawContract8 = {
   sideEffects: ["writes_firestore", "updates_calendar_slot"]
 };
 var photoAssignerContract = MartinContractSchema.parse(
-  rawContract8
+  rawContract10
 );
 function findPageByHeuristic(pages, pattern) {
   return pages.find((p) => pattern.test(p.title || "")) || pages.find((p) => pattern.test(p.handle || "")) || null;
@@ -12432,27 +12754,27 @@ var BRAND_BRIEF_SCHEMA_HINT = {
     escenas: [{ id: string, nombre: string, promptHint: string }]
   }`
 };
-var ParamsSchema9 = import_zod39.z.object({
-  tenantId: import_zod39.z.string().min(1).describe("Tenant identifier (the business account)."),
-  brandId: import_zod39.z.string().min(1).describe("Brand identifier within the tenant.")
+var ParamsSchema11 = import_zod41.z.object({
+  tenantId: import_zod41.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod41.z.string().min(1).describe("Brand identifier within the tenant.")
 });
-var OutputSchema9 = import_zod39.z.discriminatedUnion("ok", [
-  import_zod39.z.object({
-    ok: import_zod39.z.literal(true),
+var OutputSchema11 = import_zod41.z.discriminatedUnion("ok", [
+  import_zod41.z.object({
+    ok: import_zod41.z.literal(true),
     /** Payload con instrucción + datos del negocio para que Claude genere el brief. */
-    payload: import_zod39.z.record(import_zod39.z.string(), import_zod39.z.unknown())
+    payload: import_zod41.z.record(import_zod41.z.string(), import_zod41.z.unknown())
   }),
-  import_zod39.z.object({
-    ok: import_zod39.z.literal(false),
-    error: import_zod39.z.string(),
-    code: import_zod39.z.enum(["BRAND_NOT_FOUND"]).optional()
+  import_zod41.z.object({
+    ok: import_zod41.z.literal(false),
+    error: import_zod41.z.string(),
+    code: import_zod41.z.enum(["BRAND_NOT_FOUND"]).optional()
   })
 ]);
-var rawContract9 = {
+var rawContract11 = {
   name: "generate_brand_brief",
   description: "Aggregate business data (Shopify, SEO, GBP, scraped site_content, brand config, tenant locations) into a payload to generate a pre-filled Brand Brief. Read-only \u2014 does NOT write the brief; the caller saves it via save_brand_brief.",
-  paramsSchema: ParamsSchema9,
-  outputSchema: OutputSchema9,
+  paramsSchema: ParamsSchema11,
+  outputSchema: OutputSchema11,
   // Lectura pura, sin side effects de escritura ni publicación.
   requiresConfirmation: false,
   destructive: false,
@@ -12477,7 +12799,7 @@ var rawContract9 = {
   sideEffects: ["reads_firestore"]
 };
 var brandBriefBuilderContract = MartinContractSchema.parse(
-  rawContract9
+  rawContract11
 );
 async function resolveLastImportId(db, tenantId, brandId) {
   const configSnap = await db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId).get();
@@ -12665,28 +12987,28 @@ var BLOG_STRATEGY_REGLAS = [
   "blogId, handle, title, ultimoPostFecha, ultimoPostKeyword, totalArticulos \u2014 copiar del shopifyBlogs (datos reales del import)",
   "defaultBlogId y defaultBlogHandle \u2014 usar el primer blog de la lista"
 ];
-var ParamsSchema10 = import_zod40.z.object({
-  tenantId: import_zod40.z.string().min(1).describe("Tenant identifier (the business account)."),
-  brandId: import_zod40.z.string().min(1).describe("Brand identifier within the tenant.")
+var ParamsSchema12 = import_zod42.z.object({
+  tenantId: import_zod42.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod42.z.string().min(1).describe("Brand identifier within the tenant.")
 });
-var OutputSchema10 = import_zod40.z.discriminatedUnion("ok", [
-  import_zod40.z.object({
-    ok: import_zod40.z.literal(true),
-    payload: import_zod40.z.record(import_zod40.z.string(), import_zod40.z.unknown()).describe(
+var OutputSchema12 = import_zod42.z.discriminatedUnion("ok", [
+  import_zod42.z.object({
+    ok: import_zod42.z.literal(true),
+    payload: import_zod42.z.record(import_zod42.z.string(), import_zod42.z.unknown()).describe(
       "Aggregated business data + instructions + schema hints for the LLM to generate a marketing plan. Includes seoSnapshot, productos, historialReciente, shopifyColecciones, shopifyBlogs, brandBrief, planActual, and schema/rules hints for coleccionesPriorizadas and blogStrategy."
     )
   }),
-  import_zod40.z.object({
-    ok: import_zod40.z.literal(false),
-    error: import_zod40.z.string(),
-    code: import_zod40.z.enum(["BRAND_NOT_FOUND", "SEO_SNAPSHOT_MISSING"]).optional()
+  import_zod42.z.object({
+    ok: import_zod42.z.literal(false),
+    error: import_zod42.z.string(),
+    code: import_zod42.z.enum(["BRAND_NOT_FOUND", "SEO_SNAPSHOT_MISSING"]).optional()
   })
 ]);
-var rawContract10 = {
+var rawContract12 = {
   name: "generate_marketing_plan",
   description: "Aggregate business data (seoSnapshot, productos, brand config, brandBrief, historial, Shopify collections + blogs) into a payload for the LLM to generate a marketing plan. Read-only \u2014 does NOT save the plan. The caller saves via save_marketing_plan or update_marketing_plan_field after generating. Requires an existing seoSnapshot on the brand (returns SEO_SNAPSHOT_MISSING otherwise).",
-  paramsSchema: ParamsSchema10,
-  outputSchema: OutputSchema10,
+  paramsSchema: ParamsSchema12,
+  outputSchema: OutputSchema12,
   // Lectura pura, no muta nada.
   requiresConfirmation: false,
   destructive: false,
@@ -12711,7 +13033,7 @@ var rawContract10 = {
   sideEffects: ["reads_firestore"]
 };
 var marketingPlanBuilderContract = MartinContractSchema.parse(
-  rawContract10
+  rawContract12
 );
 function buildGenId() {
   return `mkt_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
@@ -12952,54 +13274,54 @@ async function contenidoWriter(input) {
     pipelineLinked
   };
 }
-var ParamsSchema11 = import_zod41.z.object({
-  tenantId: import_zod41.z.string().min(1).describe("Tenant identifier (the business account)."),
-  brandId: import_zod41.z.string().min(1).describe("Brand identifier within the tenant."),
-  plataforma: import_zod41.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Target platform for the content."),
-  tipo: import_zod41.z.string().optional().describe(
+var ParamsSchema13 = import_zod43.z.object({
+  tenantId: import_zod43.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod43.z.string().min(1).describe("Brand identifier within the tenant."),
+  plataforma: import_zod43.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Target platform for the content."),
+  tipo: import_zod43.z.string().optional().describe(
     "Content type ('post', 'blog', 'carousel', 'reel', 'story', 'review_response'). Match to the platform."
   ),
-  keyword: import_zod41.z.string().optional().describe("Primary keyword for the content. OMIT if not applicable."),
-  languageCode: import_zod41.z.string().optional().describe(
+  keyword: import_zod43.z.string().optional().describe("Primary keyword for the content. OMIT if not applicable."),
+  languageCode: import_zod43.z.string().optional().describe(
     "Content language code (e.g. 'es', 'en'). For shopify_blog auto-injects to datos.languageCode if not present."
   ),
-  fotoId: import_zod41.z.string().optional().describe("Linked photo ID. OMIT if no photo associated yet (use assign_photo_to_content later)."),
-  datos: import_zod41.z.record(import_zod41.z.string(), import_zod41.z.unknown()).describe(
+  fotoId: import_zod43.z.string().optional().describe("Linked photo ID. OMIT if no photo associated yet (use assign_photo_to_content later)."),
+  datos: import_zod43.z.record(import_zod43.z.string(), import_zod43.z.unknown()).describe(
     "Platform-specific content payload. Validated against Blog/GBP/IG/Review schemas. Use buildDatosBlog/GBP/IG/Review helpers to construct safely."
   ),
-  calendarioItemRef: import_zod41.z.string().optional().describe(
+  calendarioItemRef: import_zod43.z.string().optional().describe(
     'Calendar slot reference (format "semana:N:slot:M"). If provided, links content to that slot AND discards prior non-discarded content of the same slot.'
   )
 });
-var PipelineLinkResultSchema = import_zod41.z.object({
-  linked: import_zod41.z.boolean(),
-  paso: import_zod41.z.string().nullable(),
-  motivo: import_zod41.z.string().optional(),
-  code: import_zod41.z.string().optional(),
-  _instrucciones: import_zod41.z.string().optional()
+var PipelineLinkResultSchema = import_zod43.z.object({
+  linked: import_zod43.z.boolean(),
+  paso: import_zod43.z.string().nullable(),
+  motivo: import_zod43.z.string().optional(),
+  code: import_zod43.z.string().optional(),
+  _instrucciones: import_zod43.z.string().optional()
 });
-var OutputSchema11 = import_zod41.z.discriminatedUnion("ok", [
-  import_zod41.z.object({
-    ok: import_zod41.z.literal(true),
-    contenidoId: import_zod41.z.string(),
-    estado: import_zod41.z.string(),
-    plataforma: import_zod41.z.enum(["gbp", "shopify_blog", "instagram", "review"]),
-    descartados: import_zod41.z.number().int().nonnegative(),
+var OutputSchema13 = import_zod43.z.discriminatedUnion("ok", [
+  import_zod43.z.object({
+    ok: import_zod43.z.literal(true),
+    contenidoId: import_zod43.z.string(),
+    estado: import_zod43.z.string(),
+    plataforma: import_zod43.z.enum(["gbp", "shopify_blog", "instagram", "review"]),
+    descartados: import_zod43.z.number().int().nonnegative(),
     pipelineLinked: PipelineLinkResultSchema
   }),
-  import_zod41.z.object({
-    ok: import_zod41.z.literal(false),
-    error: import_zod41.z.string(),
-    code: import_zod41.z.enum(["CONTENT_FREQUENCY_LIMIT", "CONTENT_DATA_VALIDATION_FAILED"]).optional(),
-    activosEstaSemana: import_zod41.z.number().int().optional(),
-    limite: import_zod41.z.number().int().optional()
+  import_zod43.z.object({
+    ok: import_zod43.z.literal(false),
+    error: import_zod43.z.string(),
+    code: import_zod43.z.enum(["CONTENT_FREQUENCY_LIMIT", "CONTENT_DATA_VALIDATION_FAILED"]).optional(),
+    activosEstaSemana: import_zod43.z.number().int().optional(),
+    limite: import_zod43.z.number().int().optional()
   })
 ]);
-var rawContract11 = {
+var rawContract13 = {
   name: "save_generated_content",
   description: "Save newly generated marketing content to marketing_contenido. The content is saved as pendiente_aprobacion \u2014 it is NOT published until the tenant approves it. Enforces weekly frequency limits per platform. If calendarioItemRef is provided, links to the slot and discards any prior content of the same slot. Validates datos against the platform schema.",
-  paramsSchema: ParamsSchema11,
-  outputSchema: OutputSchema11,
+  paramsSchema: ParamsSchema13,
+  outputSchema: OutputSchema13,
   // Crea borrador + descarta borrador previo del mismo slot. Reversible
   // (volver a llamar con datos corregidos crea un nuevo borrador y descarta
   // el actual). NO publica nada externo — la CF de publish se encarga
@@ -13044,7 +13366,7 @@ var rawContract11 = {
   sideEffects: ["writes_firestore", "updates_calendar_slot"]
 };
 var contenidoWriterContract = MartinContractSchema.parse(
-  rawContract11
+  rawContract13
 );
 function fmtDate(d) {
   const y = d.getFullYear();
@@ -13319,34 +13641,34 @@ OBLIGATORIO: calendarioItemRef con formato EXACTO "semana:N:slot:M" (ej: "semana
 OBLIGATORIO: fotoId \u2014 SIEMPRE pasa el ID de la foto que elegiste con get_photos_for_slot.
 Si el slot tiene notas[], LEERLAS y usarlas como contexto. Si estado es revisar, regenerar adaptando a las notas.
 BLOG SLOTS: Usa _blogJIT para el contexto de cada slot shopify_blog \u2014 blogTarget, tono, author, articulosExistentes para interlinking.`;
-var ParamsSchema12 = import_zod42.z.object({
-  tenantId: import_zod42.z.string().min(1).describe("Tenant identifier (the business account)."),
-  brandId: import_zod42.z.string().min(1).describe("Brand identifier within the tenant."),
-  semana: import_zod42.z.number().int().min(1).max(5).optional().describe(
+var ParamsSchema14 = import_zod44.z.object({
+  tenantId: import_zod44.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod44.z.string().min(1).describe("Brand identifier within the tenant."),
+  semana: import_zod44.z.number().int().min(1).max(5).optional().describe(
     "Week number within the current month (1-5). OMIT to default to the current week inferred from today."
   ),
-  modo: import_zod42.z.enum(["planificar", "generar"]).optional().describe(
+  modo: import_zod44.z.enum(["planificar", "generar"]).optional().describe(
     "Operation mode. 'planificar' (default): propose distribution platform+keyword+tipo per day. 'generar': requires slots in pre_aprobado/revisar \u2014 generate actual content. OMIT to default to 'planificar'."
   )
 });
-var OutputSchema12 = import_zod42.z.discriminatedUnion("ok", [
-  import_zod42.z.object({
-    ok: import_zod42.z.literal(true),
-    payload: import_zod42.z.record(import_zod42.z.string(), import_zod42.z.unknown()).describe(
+var OutputSchema14 = import_zod44.z.discriminatedUnion("ok", [
+  import_zod44.z.object({
+    ok: import_zod44.z.literal(true),
+    payload: import_zod44.z.record(import_zod44.z.string(), import_zod44.z.unknown()).describe(
       "Aggregated context for the LLM. Shape varies by modo: 'planificar' returns brand skeleton + slotsYaExistentes + historial; 'generar' returns slotsParaGenerar + fotosDisponibles + brand.blogStrategy + blogJIT (if blog slots present)."
     )
   }),
-  import_zod42.z.object({
-    ok: import_zod42.z.literal(false),
-    error: import_zod42.z.string(),
-    code: import_zod42.z.enum(["BRAND_NOT_FOUND", "WEEK_HAS_NO_SLOTS"]).optional()
+  import_zod44.z.object({
+    ok: import_zod44.z.literal(false),
+    error: import_zod44.z.string(),
+    code: import_zod44.z.enum(["BRAND_NOT_FOUND", "WEEK_HAS_NO_SLOTS"]).optional()
   })
 ]);
-var rawContract12 = {
+var rawContract14 = {
   name: "generate_weekly_content",
   description: "Build the week's content. Two modes: 'planificar' aggregates context for the LLM to propose distribution (LLM then uses add_calendar_slot/update_calendar_slot per day); 'generar' returns pre-approved slots + photos + blog JIT context for the LLM to generate actual content (LLM then calls save_generated_content per slot). AUTO-CREATES the monthly marketing_calendario if it does not exist. NEVER generates content directly \u2014 always returns a payload for the LLM consumer.",
-  paramsSchema: ParamsSchema12,
-  outputSchema: OutputSchema12,
+  paramsSchema: ParamsSchema14,
+  outputSchema: OutputSchema14,
   // Auto-create de calendario es bootstrap reversible (volver a llamar usa el
   // calendario existente). NO publica nada externo. modo='generar' tampoco
   // publica — solo prepara contexto.
@@ -13391,7 +13713,7 @@ var rawContract12 = {
   sideEffects: ["reads_firestore", "writes_firestore"]
 };
 var weeklyContentBuilderContract = MartinContractSchema.parse(
-  rawContract12
+  rawContract14
 );
 var DEFAULT_TEXT_THRESHOLD = 0.35;
 var DEFAULT_IMAGE_THRESHOLD = 0.08;
@@ -13580,69 +13902,69 @@ async function contentFinder(input) {
   }
   return result;
 }
-var IncludeSchema = import_zod43.z.object({
-  products: import_zod43.z.boolean(),
-  collections: import_zod43.z.boolean(),
-  articles: import_zod43.z.boolean(),
-  pages: import_zod43.z.boolean()
+var IncludeSchema = import_zod45.z.object({
+  products: import_zod45.z.boolean(),
+  collections: import_zod45.z.boolean(),
+  articles: import_zod45.z.boolean(),
+  pages: import_zod45.z.boolean()
 }).describe(
   "Toggles for which Shopify content types to search. Default truthy for products/collections/articles, false for pages. Set false to skip a category for performance."
 );
-var LimitSchema = import_zod43.z.object({
-  products: import_zod43.z.number().int().min(0).max(20),
-  collections: import_zod43.z.number().int().min(0).max(10),
-  articles: import_zod43.z.number().int().min(0).max(20),
-  pages: import_zod43.z.number().int().min(0).max(10)
+var LimitSchema = import_zod45.z.object({
+  products: import_zod45.z.number().int().min(0).max(20),
+  collections: import_zod45.z.number().int().min(0).max(10),
+  articles: import_zod45.z.number().int().min(0).max(20),
+  pages: import_zod45.z.number().int().min(0).max(10)
 }).describe(
   "Per-category result count caps. Defaults: products 5, collections 3, articles 5, pages 2."
 );
-var ParamsSchema13 = import_zod43.z.object({
-  tenantId: import_zod43.z.string().min(1).describe("Tenant identifier (the business account)."),
-  brandId: import_zod43.z.string().min(1).describe("Brand identifier within the tenant."),
-  contexto: import_zod43.z.string().min(1).describe(
+var ParamsSchema15 = import_zod45.z.object({
+  tenantId: import_zod45.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod45.z.string().min(1).describe("Brand identifier within the tenant."),
+  contexto: import_zod45.z.string().min(1).describe(
     "Search context: a paragraph, keyword, or intent string. Embedded for vector search."
   ),
-  fecha: import_zod43.z.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe(
+  fecha: import_zod45.z.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe(
     "Content date in YYYY-MM-DD. Used to detect active season and prioritize matching collections."
   ),
   include: IncludeSchema,
   limit: LimitSchema,
-  diversidad: import_zod43.z.boolean().describe(
+  diversidad: import_zod45.z.boolean().describe(
     "Whether to apply Jaccard title diversification + handle dedupe to results. Default true."
   ),
-  mode: import_zod43.z.enum(["text", "hybrid"]).optional().describe(
+  mode: import_zod45.z.enum(["text", "hybrid"]).optional().describe(
     "Search mode. 'text' (default): single query per collection against embeddingText, fast. 'hybrid': parallel text + image queries with Reciprocal Rank Fusion, 2x queries \u2014 useful when text mode returns few results or to surface visually-similar items with weak SEO."
   )
 });
-var VectorResultSchema = import_zod43.z.object({
-  id: import_zod43.z.string(),
-  similarity: import_zod43.z.number().optional()
+var VectorResultSchema = import_zod45.z.object({
+  id: import_zod45.z.string(),
+  similarity: import_zod45.z.number().optional()
 }).passthrough();
-var TemporadaSchema2 = import_zod43.z.object({
-  coleccion: import_zod43.z.string().nullable(),
-  titulo: import_zod43.z.string().nullable(),
-  razon: import_zod43.z.string().nullable(),
-  fechaInicio: import_zod43.z.string().nullable(),
-  fechaFin: import_zod43.z.string().nullable()
+var TemporadaSchema2 = import_zod45.z.object({
+  coleccion: import_zod45.z.string().nullable(),
+  titulo: import_zod45.z.string().nullable(),
+  razon: import_zod45.z.string().nullable(),
+  fechaInicio: import_zod45.z.string().nullable(),
+  fechaFin: import_zod45.z.string().nullable()
 });
-var SuggestedActionSchema2 = import_zod43.z.record(import_zod43.z.string(), import_zod43.z.unknown());
-var DetectedConflictSchema2 = import_zod43.z.record(import_zod43.z.string(), import_zod43.z.unknown());
-var OutputSchema13 = import_zod43.z.object({
-  productos: import_zod43.z.array(VectorResultSchema),
-  colecciones: import_zod43.z.array(VectorResultSchema),
-  articles: import_zod43.z.array(VectorResultSchema),
-  pages: import_zod43.z.array(VectorResultSchema),
-  _instrucciones: import_zod43.z.string(),
-  _negativePrompt: import_zod43.z.string(),
+var SuggestedActionSchema2 = import_zod45.z.record(import_zod45.z.string(), import_zod45.z.unknown());
+var DetectedConflictSchema2 = import_zod45.z.record(import_zod45.z.string(), import_zod45.z.unknown());
+var OutputSchema15 = import_zod45.z.object({
+  productos: import_zod45.z.array(VectorResultSchema),
+  colecciones: import_zod45.z.array(VectorResultSchema),
+  articles: import_zod45.z.array(VectorResultSchema),
+  pages: import_zod45.z.array(VectorResultSchema),
+  _instrucciones: import_zod45.z.string(),
+  _negativePrompt: import_zod45.z.string(),
   _temporadaActiva: TemporadaSchema2.nullable(),
   _detectedConflict: DetectedConflictSchema2.optional(),
-  _suggestedActions: import_zod43.z.array(SuggestedActionSchema2)
+  _suggestedActions: import_zod45.z.array(SuggestedActionSchema2)
 });
-var rawContract13 = {
+var rawContract15 = {
   name: "find_content_for_topic",
   description: "Find Shopify content (products, collections, articles, pages) semantically related to a context/keyword + date. Uses multimodal vector search (1408d Vertex). Mode 'text' (default) queries embeddingText (fast); 'hybrid' merges text + image results via Reciprocal Rank Fusion (rescues items with weak text SEO). Auto-injects JIT context: linking instructions, brand visual negatives, active season collection, and conflict detection (>85% similar article).",
-  paramsSchema: ParamsSchema13,
-  outputSchema: OutputSchema13,
+  paramsSchema: ParamsSchema15,
+  outputSchema: OutputSchema15,
   // Lectura pura (vector search). Failures internas en search degradan a
   // arrays vacíos — el helper NO falla.
   requiresConfirmation: false,
@@ -13665,7 +13987,7 @@ var rawContract13 = {
   sideEffects: ["reads_firestore"]
 };
 var contentFinderContract = MartinContractSchema.parse(
-  rawContract13
+  rawContract15
 );
 var DEFAULT_PHOTO_THRESHOLD = 0.7;
 var DEFAULT_SHOPIFY_THRESHOLD = 0.65;
@@ -13812,51 +14134,51 @@ async function slotAssetFinder(input) {
     _fuente: fuente
   };
 }
-var ParamsSchema14 = import_zod44.z.object({
-  tenantId: import_zod44.z.string().min(1).describe("Tenant identifier (the business account)."),
-  brandId: import_zod44.z.string().min(1).describe("Brand identifier within the tenant."),
-  keyword: import_zod44.z.string().min(1).describe(
+var ParamsSchema16 = import_zod46.z.object({
+  tenantId: import_zod46.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod46.z.string().min(1).describe("Brand identifier within the tenant."),
+  keyword: import_zod46.z.string().min(1).describe(
     "Slot keyword to search photos for. Used as embedding query for multimodal vector search."
   ),
-  plataforma: import_zod44.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe(
+  plataforma: import_zod46.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe(
     "Target platform \u2014 determines the variant format to resolve (gbp_4_3, blog_3_2, ig_4_5, ig_1_1)."
   ),
-  fecha: import_zod44.z.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe(
+  fecha: import_zod46.z.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe(
     "Slot date in YYYY-MM-DD. Used to detect active season and apply seasonal catalog overrides."
   ),
-  limit: import_zod44.z.number().int().min(1).max(10).optional().describe("Max number of photos to return. Default 5. Max 10.")
+  limit: import_zod46.z.number().int().min(1).max(10).optional().describe("Max number of photos to return. Default 5. Max 10.")
 });
-var TemporadaSchema22 = import_zod44.z.object({
-  coleccion: import_zod44.z.string().nullable(),
-  titulo: import_zod44.z.string().nullable(),
-  razon: import_zod44.z.string().nullable(),
-  fechaInicio: import_zod44.z.string().nullable(),
-  fechaFin: import_zod44.z.string().nullable()
+var TemporadaSchema22 = import_zod46.z.object({
+  coleccion: import_zod46.z.string().nullable(),
+  titulo: import_zod46.z.string().nullable(),
+  razon: import_zod46.z.string().nullable(),
+  fechaInicio: import_zod46.z.string().nullable(),
+  fechaFin: import_zod46.z.string().nullable()
 });
-var OutputSchema14 = import_zod44.z.discriminatedUnion("ok", [
+var OutputSchema16 = import_zod46.z.discriminatedUnion("ok", [
   // Note: success case does not include `ok: true` literal in helper return —
   // helper returns the success shape directly. Adapter to discriminated union
   // happens at wrapper level if needed; here we accept both shapes.
-  import_zod44.z.object({
-    ok: import_zod44.z.literal(true),
-    fotos: import_zod44.z.array(import_zod44.z.record(import_zod44.z.string(), import_zod44.z.unknown())),
-    _instrucciones: import_zod44.z.string(),
-    _negativePrompt: import_zod44.z.string(),
+  import_zod46.z.object({
+    ok: import_zod46.z.literal(true),
+    fotos: import_zod46.z.array(import_zod46.z.record(import_zod46.z.string(), import_zod46.z.unknown())),
+    _instrucciones: import_zod46.z.string(),
+    _negativePrompt: import_zod46.z.string(),
     _temporadaActiva: TemporadaSchema22.nullable(),
-    _bloqueoProducto: import_zod44.z.boolean(),
-    _fuente: import_zod44.z.enum(["tenant", "shopify_product"])
+    _bloqueoProducto: import_zod46.z.boolean(),
+    _fuente: import_zod46.z.enum(["tenant", "shopify_product"])
   }),
-  import_zod44.z.object({
-    ok: import_zod44.z.literal(false),
-    error: import_zod44.z.string(),
-    code: import_zod44.z.enum(["BRAND_NOT_FOUND"]).optional()
+  import_zod46.z.object({
+    ok: import_zod46.z.literal(false),
+    error: import_zod46.z.string(),
+    code: import_zod46.z.enum(["BRAND_NOT_FOUND"]).optional()
   })
 ]);
-var rawContract14 = {
+var rawContract16 = {
   name: "get_photos_for_slot",
   description: "Find tenant photos for a calendar slot (keyword + platform + date) via multimodal vector search (1408d Vertex). Resolves the platform-specific variant (gbp_4_3/blog_3_2/ig_4_5/ig_1_1). Auto-injects JIT context: how to choose, brand visual negatives, active season overrides, and source layer (tenant photos vs Shopify product fallback). If <3 photos returned, consider calling request_photo_shoot to alert the tenant.",
-  paramsSchema: ParamsSchema14,
-  outputSchema: OutputSchema14,
+  paramsSchema: ParamsSchema16,
+  outputSchema: OutputSchema16,
   requiresConfirmation: false,
   destructive: false,
   affectsPublication: false,
@@ -13883,7 +14205,7 @@ var rawContract14 = {
   sideEffects: ["reads_firestore"]
 };
 var slotAssetFinderContract = MartinContractSchema.parse(
-  rawContract14
+  rawContract16
 );
 var DEFAULT_SIMILARITY_THRESHOLD = 0.6;
 function cosineSimilarity(a, b) {
@@ -13960,44 +14282,44 @@ async function canvaTemplateSelector(input) {
     _instrucciones: "Plantilla Canva seleccionada. Llama a marketingDesignWithCanva({contenidoId, plantillaId, fotoVariantePath, textos}) para renderizar la pieza final."
   };
 }
-var ParamsSchema15 = import_zod45.z.object({
-  tenantId: import_zod45.z.string().min(1).describe("Tenant identifier (the business account)."),
-  brandId: import_zod45.z.string().min(1).describe("Brand identifier within the tenant."),
-  plataforma: import_zod45.z.string().min(1).describe(
+var ParamsSchema17 = import_zod47.z.object({
+  tenantId: import_zod47.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod47.z.string().min(1).describe("Brand identifier within the tenant."),
+  plataforma: import_zod47.z.string().min(1).describe(
     "Target platform (e.g. 'gbp', 'shopify_blog', 'instagram'). Filters templates that declare this plataforma."
   ),
-  tipoContenido: import_zod45.z.string().min(1).describe(
+  tipoContenido: import_zod47.z.string().min(1).describe(
     "Content type (e.g. 'post', 'carousel', 'story', 'blog'). Filters templates that declare this tipoContenido."
   ),
-  keyword: import_zod45.z.string().min(1).describe("Slot keyword. Used as embedding query for cosine similarity match.")
+  keyword: import_zod47.z.string().min(1).describe("Slot keyword. Used as embedding query for cosine similarity match.")
 });
-var OutputSchema15 = import_zod45.z.union([
-  import_zod45.z.object({
-    plantillaId: import_zod45.z.string(),
-    titulo: import_zod45.z.string().nullable(),
-    thumbnailUrl: import_zod45.z.string().nullable(),
-    similarity: import_zod45.z.number(),
-    _instrucciones: import_zod45.z.string()
+var OutputSchema17 = import_zod47.z.union([
+  import_zod47.z.object({
+    plantillaId: import_zod47.z.string(),
+    titulo: import_zod47.z.string().nullable(),
+    thumbnailUrl: import_zod47.z.string().nullable(),
+    similarity: import_zod47.z.number(),
+    _instrucciones: import_zod47.z.string()
   }),
-  import_zod45.z.object({
-    plantillaId: import_zod45.z.null(),
-    motivo: import_zod45.z.enum([
+  import_zod47.z.object({
+    plantillaId: import_zod47.z.null(),
+    motivo: import_zod47.z.enum([
       "brand_no_encontrada",
       "no_canva",
       "no_match_plataforma",
       "modo_cliente_no_soportado",
       "similarity_baja"
     ]),
-    similarity: import_zod45.z.number().optional(),
-    _instrucciones: import_zod45.z.string().optional(),
-    _todo: import_zod45.z.string().optional()
+    similarity: import_zod47.z.number().optional(),
+    _instrucciones: import_zod47.z.string().optional(),
+    _todo: import_zod47.z.string().optional()
   })
 ]);
-var rawContract15 = {
+var rawContract17 = {
   name: "select_canva_template",
   description: "Select the best Canva template from the tenant for a slot. Filters templates by plataforma+tipoContenido, then cosine-similarity matches embeddings vs the keyword query. Returns plantillaId on match (similarity >= 0.60). On miss returns plantillaId=null with motivo enum (no_canva, no_match_plataforma, modo_cliente_no_soportado, similarity_baja, brand_no_encontrada). The LLM should degrade gracefully (generate without Canva template) on any miss.",
-  paramsSchema: ParamsSchema15,
-  outputSchema: OutputSchema15,
+  paramsSchema: ParamsSchema17,
+  outputSchema: OutputSchema17,
   // Lectura pura. NO falla — todo "no encontré" es resultado válido del helper.
   requiresConfirmation: false,
   destructive: false,
@@ -14024,7 +14346,7 @@ var rawContract15 = {
   sideEffects: ["reads_firestore"]
 };
 var canvaTemplateSelectorContract = MartinContractSchema.parse(
-  rawContract15
+  rawContract17
 );
 function buildDirectorPlanInstrucciones(catalogoVisual) {
   const etiquetas = catalogoVisual.etiquetas || {};
@@ -14248,38 +14570,38 @@ async function photoDirectorExecute(input) {
     _instrucciones: buildDirectorExecuteSuccessInstrucciones(result.balanceAfter)
   };
 }
-var PlanParamsSchema = import_zod46.z.object({
-  tenantId: import_zod46.z.string().min(1).describe("Tenant identifier (the business account)."),
-  fotoId: import_zod46.z.string().min(1).describe("Photo ID in marketing_fotos. The photo must have an archivoOriginal uploaded.")
+var PlanParamsSchema = import_zod48.z.object({
+  tenantId: import_zod48.z.string().min(1).describe("Tenant identifier (the business account)."),
+  fotoId: import_zod48.z.string().min(1).describe("Photo ID in marketing_fotos. The photo must have an archivoOriginal uploaded.")
 });
-var PlanContextSchema = import_zod46.z.object({
-  fotoId: import_zod46.z.string(),
-  archivoOriginal: import_zod46.z.string(),
-  estrategia: import_zod46.z.string(),
-  brandBrief: import_zod46.z.object({
-    segmento: import_zod46.z.string().nullable(),
-    personalidad: import_zod46.z.unknown().nullable()
+var PlanContextSchema = import_zod48.z.object({
+  fotoId: import_zod48.z.string(),
+  archivoOriginal: import_zod48.z.string(),
+  estrategia: import_zod48.z.string(),
+  brandBrief: import_zod48.z.object({
+    segmento: import_zod48.z.string().nullable(),
+    personalidad: import_zod48.z.unknown().nullable()
   }),
-  visualRules: import_zod46.z.record(import_zod46.z.string(), import_zod46.z.unknown()),
-  catalogoVisual: import_zod46.z.record(import_zod46.z.string(), import_zod46.z.unknown()),
-  estiloVisual: import_zod46.z.unknown().nullable(),
-  notaTenant: import_zod46.z.unknown().nullable(),
-  productoLinkeadoManual: import_zod46.z.unknown().nullable(),
-  _instrucciones: import_zod46.z.string()
+  visualRules: import_zod48.z.record(import_zod48.z.string(), import_zod48.z.unknown()),
+  catalogoVisual: import_zod48.z.record(import_zod48.z.string(), import_zod48.z.unknown()),
+  estiloVisual: import_zod48.z.unknown().nullable(),
+  notaTenant: import_zod48.z.unknown().nullable(),
+  productoLinkeadoManual: import_zod48.z.unknown().nullable(),
+  _instrucciones: import_zod48.z.string()
 });
-var PlanOutputSchema = import_zod46.z.discriminatedUnion("ok", [
-  import_zod46.z.object({
-    ok: import_zod46.z.literal(true),
-    imageBase64: import_zod46.z.string().describe("Compressed photo as base64 for transport to the LLM."),
+var PlanOutputSchema = import_zod48.z.discriminatedUnion("ok", [
+  import_zod48.z.object({
+    ok: import_zod48.z.literal(true),
+    imageBase64: import_zod48.z.string().describe("Compressed photo as base64 for transport to the LLM."),
     context: PlanContextSchema
   }),
-  import_zod46.z.object({
-    ok: import_zod46.z.literal(false),
-    code: import_zod46.z.string(),
-    error: import_zod46.z.string(),
-    _instrucciones: import_zod46.z.string().optional(),
-    fix: import_zod46.z.string().optional(),
-    fotoId: import_zod46.z.string().optional()
+  import_zod48.z.object({
+    ok: import_zod48.z.literal(false),
+    code: import_zod48.z.string(),
+    error: import_zod48.z.string(),
+    _instrucciones: import_zod48.z.string().optional(),
+    fix: import_zod48.z.string().optional(),
+    fotoId: import_zod48.z.string().optional()
   })
 ]);
 var planRawContract = {
@@ -14309,43 +14631,43 @@ var planRawContract = {
 var photoDirectorPlanContract = MartinContractSchema.parse(
   planRawContract
 );
-var ExecuteParamsSchema = import_zod46.z.object({
+var ExecuteParamsSchema = import_zod48.z.object({
   // tenantId is injected by the wrapper from ctx (A7 module-scope pattern,
   // even though the helper function itself derives tenantId via the foto's
   // brandId). Needed here for extractTargetPath canonical path.
-  tenantId: import_zod46.z.string().min(1).describe("Tenant identifier (the business account)."),
-  fotoId: import_zod46.z.string().min(1).describe("Photo ID to edit (must have been planned via plan_photo_edit)."),
-  prompt: import_zod46.z.string().nullable().describe(
+  tenantId: import_zod48.z.string().min(1).describe("Tenant identifier (the business account)."),
+  fotoId: import_zod48.z.string().min(1).describe("Photo ID to edit (must have been planned via plan_photo_edit)."),
+  prompt: import_zod48.z.string().nullable().describe(
     "English prompt for Gemini Image Edit when acciones includes edit_background. Pass null when strategy is 'tal_cual' (no editing \u2014 just regenerate thumbnail + embedding with new tags)."
   ),
-  acciones: import_zod46.z.array(import_zod46.z.enum(["edit_background", "none"])).describe(
+  acciones: import_zod48.z.array(import_zod48.z.enum(["edit_background", "none"])).describe(
     "Edit operations to perform. Use ['edit_background'] for AI background edit, ['none'] when strategy is 'tal_cual'."
   ),
-  descripcion: import_zod46.z.string().describe("Semantic description in Spanish (saved as descripcionVision on the photo)."),
-  tipo: import_zod46.z.string().nullable().describe("Photo type from the brand catalogoVisual. null only if catalog has no matching type."),
-  tagsPrimarios: import_zod46.z.array(import_zod46.z.string()).describe("Primary tags from the catalogoVisual."),
-  tagsSecundarios: import_zod46.z.array(import_zod46.z.string()).describe("Secondary tags from the catalogoVisual."),
-  tagsContexto: import_zod46.z.array(import_zod46.z.string()).describe("Contextual tags (occasion, mood, style).")
+  descripcion: import_zod48.z.string().describe("Semantic description in Spanish (saved as descripcionVision on the photo)."),
+  tipo: import_zod48.z.string().nullable().describe("Photo type from the brand catalogoVisual. null only if catalog has no matching type."),
+  tagsPrimarios: import_zod48.z.array(import_zod48.z.string()).describe("Primary tags from the catalogoVisual."),
+  tagsSecundarios: import_zod48.z.array(import_zod48.z.string()).describe("Secondary tags from the catalogoVisual."),
+  tagsContexto: import_zod48.z.array(import_zod48.z.string()).describe("Contextual tags (occasion, mood, style).")
 });
-var ExecuteOutputSchema = import_zod46.z.discriminatedUnion("ok", [
-  import_zod46.z.object({
-    ok: import_zod46.z.literal(true),
-    fotoId: import_zod46.z.string(),
-    archivoEditado: import_zod46.z.string().optional(),
-    thumbnailUrl: import_zod46.z.string().optional(),
-    iteracion: import_zod46.z.number().optional(),
-    editCosto: import_zod46.z.number().optional(),
-    creditsConsumed: import_zod46.z.number().optional(),
-    balanceAfter: import_zod46.z.number().optional(),
-    imageBase64: import_zod46.z.string().nullable(),
-    _instrucciones: import_zod46.z.string()
+var ExecuteOutputSchema = import_zod48.z.discriminatedUnion("ok", [
+  import_zod48.z.object({
+    ok: import_zod48.z.literal(true),
+    fotoId: import_zod48.z.string(),
+    archivoEditado: import_zod48.z.string().optional(),
+    thumbnailUrl: import_zod48.z.string().optional(),
+    iteracion: import_zod48.z.number().optional(),
+    editCosto: import_zod48.z.number().optional(),
+    creditsConsumed: import_zod48.z.number().optional(),
+    balanceAfter: import_zod48.z.number().optional(),
+    imageBase64: import_zod48.z.string().nullable(),
+    _instrucciones: import_zod48.z.string()
   }),
-  import_zod46.z.object({
-    ok: import_zod46.z.literal(false),
-    error: import_zod46.z.string(),
-    code: import_zod46.z.string(),
-    details: import_zod46.z.record(import_zod46.z.string(), import_zod46.z.unknown()).optional(),
-    _instrucciones: import_zod46.z.string()
+  import_zod48.z.object({
+    ok: import_zod48.z.literal(false),
+    error: import_zod48.z.string(),
+    code: import_zod48.z.string(),
+    details: import_zod48.z.record(import_zod48.z.string(), import_zod48.z.unknown()).optional(),
+    _instrucciones: import_zod48.z.string()
   })
 ]);
 var executeRawContract = {
@@ -15053,6 +15375,12 @@ function callGetCalendar(input) {
 function callAddCalendarSlot(input) {
   return callCF("marketingAddCalendarSlotCallable", input);
 }
+function callSeoSnapshotReader(input) {
+  return callCF("marketingSeoSnapshotReaderCallable", input);
+}
+function callCollectionsReader(input) {
+  return callCF("marketingCollectionsReaderCallable", input);
+}
 function callBrandBriefWriter(input) {
   return callCF("marketingBrandBriefWriterCallable", input);
 }
@@ -15121,7 +15449,7 @@ function callListarRutinas(input) {
 }
 
 // src/tools/marketing/photos.ts
-var import_zod47 = require("zod");
+var import_zod49 = require("zod");
 
 // src/services/marketingEmbeddings.ts
 var import_google_auth_library = require("google-auth-library");
@@ -15417,11 +15745,11 @@ REGLAS:
 
 USAR: antes de generar contenido de cualquier slot del calendario.`,
     {
-      brandId: import_zod47.z.string().optional().describe("ID de la brand"),
-      keyword: import_zod47.z.string().describe("Keyword del slot"),
-      plataforma: import_zod47.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Plataforma destino del slot"),
-      fecha: import_zod47.z.string().describe("Fecha del slot en ISO YYYY-MM-DD"),
-      limit: import_zod47.z.number().int().min(1).max(10).default(5)
+      brandId: import_zod49.z.string().optional().describe("ID de la brand"),
+      keyword: import_zod49.z.string().describe("Keyword del slot"),
+      plataforma: import_zod49.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Plataforma destino del slot"),
+      fecha: import_zod49.z.string().describe("Fecha del slot en ISO YYYY-MM-DD"),
+      limit: import_zod49.z.number().int().min(1).max(10).default(5)
     },
     async ({ brandId: inputBrandId, keyword, plataforma, fecha, limit }) => {
       const tenantId = session.requireTenant();
@@ -15469,7 +15797,7 @@ DESPUES de ver la foto, decide:
 
 Luego llama execute_photo_edit con tu analisis y prompt.`,
     {
-      fotoId: import_zod47.z.string().describe("ID de la foto")
+      fotoId: import_zod49.z.string().describe("ID de la foto")
     },
     async ({ fotoId }) => {
       const tenantId = session.requireTenant();
@@ -15517,14 +15845,14 @@ Retorna la foto editada para que la revises. Si no te gusta:
 
 Si estrategia era 'tal_cual', pasa acciones=['none'] \u2014 no se edita pero si se genera thumbnail y embedding con tus tags.`,
     {
-      fotoId: import_zod47.z.string(),
-      prompt: import_zod47.z.string().nullable().describe("Prompt en ingles para Gemini Image Edit. null si tal_cual"),
-      acciones: import_zod47.z.array(import_zod47.z.enum(["edit_background", "none"])),
-      descripcion: import_zod47.z.string().describe("Descripcion semantica en espanol"),
-      tipo: import_zod47.z.string().nullable().describe("Tipo del catalogoVisual del tenant"),
-      tagsPrimarios: import_zod47.z.array(import_zod47.z.string()),
-      tagsSecundarios: import_zod47.z.array(import_zod47.z.string()),
-      tagsContexto: import_zod47.z.array(import_zod47.z.string())
+      fotoId: import_zod49.z.string(),
+      prompt: import_zod49.z.string().nullable().describe("Prompt en ingles para Gemini Image Edit. null si tal_cual"),
+      acciones: import_zod49.z.array(import_zod49.z.enum(["edit_background", "none"])),
+      descripcion: import_zod49.z.string().describe("Descripcion semantica en espanol"),
+      tipo: import_zod49.z.string().nullable().describe("Tipo del catalogoVisual del tenant"),
+      tagsPrimarios: import_zod49.z.array(import_zod49.z.string()),
+      tagsSecundarios: import_zod49.z.array(import_zod49.z.string()),
+      tagsContexto: import_zod49.z.array(import_zod49.z.string())
     },
     async ({ fotoId, prompt, acciones, descripcion, tipo, tagsPrimarios, tagsSecundarios, tagsContexto }) => {
       const tenantId = session.requireTenant();
@@ -15600,7 +15928,7 @@ Retorna:
   - creditos: { balance, planId, periodEnd, costoPhotoEdit }
   - _instrucciones: que hacer segun el estado`,
     {
-      fotoId: import_zod47.z.string().describe("ID de la foto")
+      fotoId: import_zod49.z.string().describe("ID de la foto")
     },
     async ({ fotoId }) => {
       const tenantId = session.requireTenant();
@@ -15700,11 +16028,11 @@ Retorna:
     "find_products_for_content",
     `[DEPRECATED 179.5] Wrapper interno de find_content_for_topic. Para nuevas integraciones, usa find_content_for_topic con include.products=true directamente. Este wrapper existe solo por compat hacia atras.`,
     {
-      brandId: import_zod47.z.string().optional().describe("ID de la brand"),
-      contexto: import_zod47.z.string().describe("Parrafo, keyword o intencion del contenido"),
-      fecha: import_zod47.z.string().describe("Fecha del contenido en ISO YYYY-MM-DD"),
-      limit: import_zod47.z.number().int().min(1).max(10).default(5),
-      diversidad: import_zod47.z.boolean().default(true)
+      brandId: import_zod49.z.string().optional().describe("ID de la brand"),
+      contexto: import_zod49.z.string().describe("Parrafo, keyword o intencion del contenido"),
+      fecha: import_zod49.z.string().describe("Fecha del contenido en ISO YYYY-MM-DD"),
+      limit: import_zod49.z.number().int().min(1).max(10).default(5),
+      diversidad: import_zod49.z.boolean().default(true)
     },
     async ({ brandId: inputBrandId, contexto, fecha, limit, diversidad }) => {
       console.warn(
@@ -15781,10 +16109,10 @@ RETORNA { plantillaId, titulo, thumbnailUrl } o { plantillaId: null, motivo: 'no
 
 USAR: solo si tenant tiene Canva conectado (tenants/{tenantId}/marketing_config/{brandId}.canva.connected=true).`,
     {
-      brandId: import_zod47.z.string().optional().describe("ID de la brand"),
-      plataforma: import_zod47.z.string().describe("gbp | instagram | shopify_blog"),
-      tipoContenido: import_zod47.z.string().describe("post | carousel | story | blog"),
-      keyword: import_zod47.z.string().describe("Keyword del slot")
+      brandId: import_zod49.z.string().optional().describe("ID de la brand"),
+      plataforma: import_zod49.z.string().describe("gbp | instagram | shopify_blog"),
+      tipoContenido: import_zod49.z.string().describe("post | carousel | story | blog"),
+      keyword: import_zod49.z.string().describe("Keyword del slot")
     },
     async ({ brandId: inputBrandId, plataforma, tipoContenido, keyword }) => {
       const tenantId = session.requireTenant();
@@ -15829,15 +16157,15 @@ USAR: cuando get_photos_for_slot retorna pocas fotos y el slot aun no esta cubie
 
 IMPORTANTE \u2014 campo 'razon': Este texto lo ve el tenant en la app. Escribe en lenguaje amigable y claro, NO tecnico. Ejemplo MALO: "get_photos_for_slot retorno 0 fotos para shopify_blog". Ejemplo BUENO: "No hay fotos de alcatraz para el blog del 8 de abril". Siempre en espanol si el tenant habla espanol.`,
     {
-      brandId: import_zod47.z.string().optional().describe("ID de la brand"),
-      semana: import_zod47.z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "semana debe ser ISO YYYY-MM-DD").describe("Semana en ISO del lunes"),
-      necesidades: import_zod47.z.array(
-        import_zod47.z.object({
-          tema: import_zod47.z.string(),
-          keyword: import_zod47.z.string(),
-          cantidadSugerida: import_zod47.z.number().int().positive(),
-          razon: import_zod47.z.string(),
-          slotsAfectados: import_zod47.z.array(import_zod47.z.string()).optional().describe('Refs de slots afectados (formato "semana:N:slot:M")')
+      brandId: import_zod49.z.string().optional().describe("ID de la brand"),
+      semana: import_zod49.z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "semana debe ser ISO YYYY-MM-DD").describe("Semana en ISO del lunes"),
+      necesidades: import_zod49.z.array(
+        import_zod49.z.object({
+          tema: import_zod49.z.string(),
+          keyword: import_zod49.z.string(),
+          cantidadSugerida: import_zod49.z.number().int().positive(),
+          razon: import_zod49.z.string(),
+          slotsAfectados: import_zod49.z.array(import_zod49.z.string()).optional().describe('Refs de slots afectados (formato "semana:N:slot:M")')
         })
       ).min(1)
     },
@@ -15900,7 +16228,7 @@ IMPORTANTE \u2014 campo 'razon': Este texto lo ve el tenant en la app. Escribe e
 }
 
 // src/tools/marketing/content.ts
-var import_zod48 = require("zod");
+var import_zod50 = require("zod");
 var _logOverride = null;
 async function logToMcpLogs(entry) {
   if (_logOverride) return _logOverride(entry);
@@ -15913,22 +16241,22 @@ async function logToMcpLogs(entry) {
   } catch {
   }
 }
-var IncludeSchema2 = import_zod48.z.object({
-  products: import_zod48.z.boolean().default(true),
-  collections: import_zod48.z.boolean().default(true),
-  articles: import_zod48.z.boolean().default(true),
-  pages: import_zod48.z.boolean().default(false)
+var IncludeSchema2 = import_zod50.z.object({
+  products: import_zod50.z.boolean().default(true),
+  collections: import_zod50.z.boolean().default(true),
+  articles: import_zod50.z.boolean().default(true),
+  pages: import_zod50.z.boolean().default(false)
 }).default({
   products: true,
   collections: true,
   articles: true,
   pages: false
 });
-var LimitSchema2 = import_zod48.z.object({
-  products: import_zod48.z.number().int().min(0).max(20).default(5),
-  collections: import_zod48.z.number().int().min(0).max(10).default(3),
-  articles: import_zod48.z.number().int().min(0).max(20).default(5),
-  pages: import_zod48.z.number().int().min(0).max(10).default(2)
+var LimitSchema2 = import_zod50.z.object({
+  products: import_zod50.z.number().int().min(0).max(20).default(5),
+  collections: import_zod50.z.number().int().min(0).max(10).default(3),
+  articles: import_zod50.z.number().int().min(0).max(20).default(5),
+  pages: import_zod50.z.number().int().min(0).max(10).default(2)
 }).default({ products: 5, collections: 3, articles: 5, pages: 2 });
 function registerContentTools(server, session) {
   server.tool(
@@ -15956,13 +16284,13 @@ MODOS (parametro mode):
 
 Cuando uses hybrid: inspecciona el campo \`modesFound\` en los resultados. 2 = el doc aparecio en ambos modos (alta confianza). 1 = aparecio solo en text (problema visual) o solo en image (problema SEO). Esos "solo image" son candidatos perfectos para recomendar optimizacion al tenant.`,
     {
-      brandId: import_zod48.z.string().optional().describe("ID de la brand"),
-      contexto: import_zod48.z.string().min(1).describe("Parrafo, keyword o intencion"),
-      fecha: import_zod48.z.string().describe("Fecha del contenido en ISO YYYY-MM-DD"),
+      brandId: import_zod50.z.string().optional().describe("ID de la brand"),
+      contexto: import_zod50.z.string().min(1).describe("Parrafo, keyword o intencion"),
+      fecha: import_zod50.z.string().describe("Fecha del contenido en ISO YYYY-MM-DD"),
       include: IncludeSchema2.optional(),
       limit: LimitSchema2.optional(),
-      diversidad: import_zod48.z.boolean().default(true),
-      mode: import_zod48.z.enum(["text", "hybrid"]).default("text").describe("Modo de busqueda: 'text' (rapido, 1 query) o 'hybrid' (text+image via RRF, 2x queries, rescata SEO debil)")
+      diversidad: import_zod50.z.boolean().default(true),
+      mode: import_zod50.z.enum(["text", "hybrid"]).default("text").describe("Modo de busqueda: 'text' (rapido, 1 query) o 'hybrid' (text+image via RRF, 2x queries, rescata SEO debil)")
     },
     async ({ brandId: inputBrandId, contexto, fecha, include, limit, diversidad, mode }) => {
       const tenantId = session.requireTenant();
@@ -16173,8 +16501,8 @@ function registerMarketingTools(server, session) {
     "get_calendar",
     "Lee el calendario editorial del mes. Muestra semanas con items planificados por plataforma.",
     {
-      brandId: import_zod49.z.string().optional().describe("ID de la brand"),
-      mes: import_zod49.z.string().optional().describe("Mes en formato YYYY-MM (default: mes actual)")
+      brandId: import_zod51.z.string().optional().describe("ID de la brand"),
+      mes: import_zod51.z.string().optional().describe("Mes en formato YYYY-MM (default: mes actual)")
     },
     async ({ brandId: inputBrandId, mes }) => {
       const tenantId = session.requireTenant();
@@ -16210,29 +16538,46 @@ function registerMarketingTools(server, session) {
   );
   server.tool(
     "get_seo_snapshot",
-    "Lee el snapshot SEO de la brand: rank, keywords, oportunidades, competidores.",
+    "Read the latest Semrush SEO snapshot for a brand: rank, top keywords, opportunities, competitors.",
     {
-      brandId: import_zod49.z.string().optional().describe("ID de la brand")
+      brandId: import_zod51.z.string().optional().describe("Brand identifier within the tenant")
     },
     async ({ brandId: inputBrandId }) => {
       const tenantId = session.requireTenant();
       const brandId = inputBrandId ?? session.requireBrand();
-      const brand = await readDoc(`tenants/${tenantId}/marketing_config`, brandId);
-      if (!brand) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: `Brand "${brandId}" no encontrada` }) }] };
-      }
-      if (!brand.seoSnapshot) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: "No hay snapshot SEO. Ejecuta la Cloud Function marketingSeoSnapshot primero." }) }] };
+      const ctx = await buildContext(session, brandId);
+      const result = await dispatchWithContract({
+        contract: seoSnapshotReaderContract,
+        helper: seoSnapshotReader,
+        callable: callSeoSnapshotReader,
+        input: { tenantId, brandId },
+        ctx
+      });
+      let payload;
+      if (result.state === "success" && result.structuredOutput) {
+        const out = result.structuredOutput;
+        if (out.ok) {
+          payload = out.snapshot;
+        } else {
+          payload = { ok: false, code: out.code, mensaje: result.text };
+        }
+      } else {
+        payload = {
+          ok: false,
+          state: result.state,
+          mensaje: result.text,
+          ...result.validationErrors && result.validationErrors.length > 0 ? { validationErrors: result.validationErrors } : {}
+        };
       }
-      return { content: [{ type: "text", text: JSON.stringify(brand.seoSnapshot, null, 2) }] };
+      return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
     }
   );
   server.tool(
     "get_photo_gallery",
     "Fotos disponibles filtradas por estado. Muestra fotos con metadata y conteo.",
     {
-      brandId: import_zod49.z.string().optional().describe("ID de la brand"),
-      estado: import_zod49.z.string().optional().describe("Filtrar por estado (nueva, procesando, editada, usada, descartada, error)")
+      brandId: import_zod51.z.string().optional().describe("ID de la brand"),
+      estado: import_zod51.z.string().optional().describe("Filtrar por estado (nueva, procesando, editada, usada, descartada, error)")
     },
     async ({ brandId: inputBrandId, estado }) => {
       session.requireTenant();
@@ -16272,7 +16617,7 @@ function registerMarketingTools(server, session) {
     "generate_marketing_plan",
     "Aggregate the data needed to generate a strategic marketing plan: SEO snapshot + products. The LLM uses the system prompt to generate the plan from this payload.",
     {
-      brandId: import_zod49.z.string().optional().describe("ID de la brand")
+      brandId: import_zod51.z.string().optional().describe("ID de la brand")
     },
     async ({ brandId: inputBrandId }) => {
       const tenantId = session.requireTenant();
@@ -16286,8 +16631,8 @@ function registerMarketingTools(server, session) {
     "save_marketing_plan",
     "Save a marketing plan to the brand configuration. Writes to tenants/{tenantId}/marketing_config/{brandId}.plan. If the plan object includes a blogStrategy field, it is extracted and stored at brand level (not nested inside plan).",
     {
-      brandId: import_zod49.z.string().optional().describe("Brand ID. If omitted, uses the active brand from session context."),
-      plan: import_zod49.z.record(import_zod49.z.string(), import_zod49.z.unknown()).describe("Full marketing plan object. Common fields: keywordsPrioritarios, gapsCompetencia, temporadas, tonoMarca, quickWins, coleccionesPriorizadas, blogStrategy.")
+      brandId: import_zod51.z.string().optional().describe("Brand ID. If omitted, uses the active brand from session context."),
+      plan: import_zod51.z.record(import_zod51.z.string(), import_zod51.z.unknown()).describe("Full marketing plan object. Common fields: keywordsPrioritarios, gapsCompetencia, temporadas, tonoMarca, quickWins, coleccionesPriorizadas, blogStrategy.")
     },
     async ({ brandId: inputBrandId, plan }) => {
       const tenantId = session.requireTenant();
@@ -16315,9 +16660,9 @@ function registerMarketingTools(server, session) {
     "update_marketing_plan_field",
     "Actualiza UN campo del plan de marketing sin sobreescribir el resto. Merge parcial. Ideal para agregar coleccionesPriorizadas, actualizar quickWins, etc.",
     {
-      brandId: import_zod49.z.string().optional().describe("ID de la brand"),
-      field: import_zod49.z.string().describe('Nombre del campo a actualizar (ej: "coleccionesPriorizadas", "quickWins", "temporadas")'),
-      value: import_zod49.z.unknown().describe("Valor del campo")
+      brandId: import_zod51.z.string().optional().describe("ID de la brand"),
+      field: import_zod51.z.string().describe('Nombre del campo a actualizar (ej: "coleccionesPriorizadas", "quickWins", "temporadas")'),
+      value: import_zod51.z.unknown().describe("Valor del campo")
     },
     async ({ brandId: inputBrandId, field, value }) => {
       const tenantId = session.requireTenant();
@@ -16330,7 +16675,7 @@ function registerMarketingTools(server, session) {
     "generate_brand_brief",
     "Aggregate all business data needed to generate a Brand Brief: Shopify (products, collections, orders, shop info), SEO snapshot, GBP profiles, scraped site_content, brand config, tenant locations. Read-only \u2014 does NOT write the brief. After receiving the payload, generate the brief content and save it via save_brand_brief.",
     {
-      brandId: import_zod49.z.string().optional().describe("Brand ID. If omitted, uses the active brand from session context.")
+      brandId: import_zod51.z.string().optional().describe("Brand ID. If omitted, uses the active brand from session context.")
     },
     async ({ brandId: inputBrandId }) => {
       const tenantId = session.requireTenant();
@@ -16363,8 +16708,8 @@ function registerMarketingTools(server, session) {
     "save_brand_brief",
     "Save the Brand Brief at tenants/{tenantId}/marketing_config/{brandId}.brandBrief. Partial merge \u2014 only the brandBrief field is overwritten.",
     {
-      brandId: import_zod49.z.string().optional().describe("ID de la brand"),
-      brandBrief: import_zod49.z.record(import_zod49.z.string(), import_zod49.z.unknown()).describe("Full Brand Brief object.")
+      brandId: import_zod51.z.string().optional().describe("ID de la brand"),
+      brandBrief: import_zod51.z.record(import_zod51.z.string(), import_zod51.z.unknown()).describe("Full Brand Brief object.")
     },
     async ({ brandId: inputBrandId, brandBrief }) => {
       const tenantId = session.requireTenant();
@@ -16390,9 +16735,9 @@ function registerMarketingTools(server, session) {
     "generate_weekly_content",
     "Aggregate calendar + photos + plan data to generate the week's content. The LLM generates with the system prompt, then uses save_generated_content to persist.",
     {
-      brandId: import_zod49.z.string().optional().describe("ID de la brand"),
-      semana: import_zod49.z.number().optional().describe("Numero de semana (1-5). Default: semana actual del mes."),
-      modo: import_zod49.z.enum(["planificar", "generar"]).optional().describe("'planificar' = proponer distribucion (plataforma+keyword por dia). 'generar' = generar contenido real para slots ya planificados. Default: 'planificar'.")
+      brandId: import_zod51.z.string().optional().describe("ID de la brand"),
+      semana: import_zod51.z.number().optional().describe("Numero de semana (1-5). Default: semana actual del mes."),
+      modo: import_zod51.z.enum(["planificar", "generar"]).optional().describe("'planificar' = proponer distribucion (plataforma+keyword por dia). 'generar' = generar contenido real para slots ya planificados. Default: 'planificar'.")
     },
     async ({ brandId: inputBrandId, semana, modo }) => {
       const tenantId = session.requireTenant();
@@ -16420,14 +16765,14 @@ function registerMarketingTools(server, session) {
 
 IMPORTANT: If you selected a photo with get_photos_for_slot, ALWAYS pass fotoId here. Without fotoId the post will be published without an image.`,
     {
-      brandId: import_zod49.z.string().optional().describe("ID de la brand"),
-      plataforma: import_zod49.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Plataforma destino"),
-      tipo: import_zod49.z.string().optional().describe("Tipo de contenido (post, blog, carousel, etc.)"),
-      keyword: import_zod49.z.string().optional().describe("Keyword target"),
-      languageCode: import_zod49.z.string().optional().describe("Idioma (es/en)"),
-      fotoId: import_zod49.z.string().optional().describe("ID de la foto a asociar"),
-      datos: import_zod49.z.record(import_zod49.z.string(), import_zod49.z.unknown()).describe("Datos especificos de la plataforma (output de buildDatos*)"),
-      calendarioItemRef: import_zod49.z.string().optional().describe("Referencia al item del calendario")
+      brandId: import_zod51.z.string().optional().describe("ID de la brand"),
+      plataforma: import_zod51.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Plataforma destino"),
+      tipo: import_zod51.z.string().optional().describe("Tipo de contenido (post, blog, carousel, etc.)"),
+      keyword: import_zod51.z.string().optional().describe("Keyword target"),
+      languageCode: import_zod51.z.string().optional().describe("Idioma (es/en)"),
+      fotoId: import_zod51.z.string().optional().describe("ID de la foto a asociar"),
+      datos: import_zod51.z.record(import_zod51.z.string(), import_zod51.z.unknown()).describe("Datos especificos de la plataforma (output de buildDatos*)"),
+      calendarioItemRef: import_zod51.z.string().optional().describe("Referencia al item del calendario")
     },
     async ({ brandId: inputBrandId, plataforma, tipo, keyword, languageCode, fotoId, datos, calendarioItemRef }) => {
       const tenantId = session.requireTenant();
@@ -16463,13 +16808,13 @@ Usa para: corregir body, metaTitle, tags, fotoId, o cualquier campo sin tener qu
 NO puede cambiar: tenantId, brandId, id (inmutables).
 Si pasas campos dentro de "datos", se hace merge con los datos existentes (no los reemplaza entero).`,
     {
-      contenidoId: import_zod49.z.string().describe("ID del doc en marketing_contenido"),
-      datos: import_zod49.z.record(import_zod49.z.string(), import_zod49.z.unknown()).optional().describe('Campos de datos a actualizar (merge parcial sobre datos existentes). Ej: { body: "...", metaTitle: "..." }'),
-      fotoId: import_zod49.z.string().nullable().optional().describe("Actualizar foto asociada"),
-      keyword: import_zod49.z.string().nullable().optional().describe("Actualizar keyword"),
-      languageCode: import_zod49.z.string().optional().describe("Actualizar idioma"),
-      estado: import_zod49.z.enum(["borrador", "generado", "pendiente_aprobacion", "aprobado", "rechazado"]).optional().describe("Cambiar estado manualmente"),
-      calendarioItemRef: import_zod49.z.string().nullable().optional().describe("Vincular a un slot del calendario")
+      contenidoId: import_zod51.z.string().describe("ID del doc en marketing_contenido"),
+      datos: import_zod51.z.record(import_zod51.z.string(), import_zod51.z.unknown()).optional().describe('Campos de datos a actualizar (merge parcial sobre datos existentes). Ej: { body: "...", metaTitle: "..." }'),
+      fotoId: import_zod51.z.string().nullable().optional().describe("Actualizar foto asociada"),
+      keyword: import_zod51.z.string().nullable().optional().describe("Actualizar keyword"),
+      languageCode: import_zod51.z.string().optional().describe("Actualizar idioma"),
+      estado: import_zod51.z.enum(["borrador", "generado", "pendiente_aprobacion", "aprobado", "rechazado"]).optional().describe("Cambiar estado manualmente"),
+      calendarioItemRef: import_zod51.z.string().nullable().optional().describe("Vincular a un slot del calendario")
     },
     async ({ contenidoId, datos: newDatos, fotoId, keyword, languageCode, estado, calendarioItemRef }) => {
       const tenantId = session.requireTenant();
@@ -16503,19 +16848,19 @@ Si pasas campos dentro de "datos", se hace merge con los datos existentes (no lo
     "add_calendar_slot",
     "Add a NEW slot to the editorial calendar. To modify an existing slot use update_calendar_slot instead.",
     {
-      brandId: import_zod49.z.string().describe('Brand ID (e.g. "ponch", "teleglobos").'),
-      mes: import_zod49.z.string().describe('Calendar month in YYYY-MM format (e.g. "2026-05").'),
-      semana: import_zod49.z.number().describe("Week number within the month (1-5)."),
-      slot: import_zod49.z.object({
-        dia: import_zod49.z.string().describe("Slot date in YYYY-MM-DD format. Must fall within the week's fechaInicio/fechaFin range."),
-        plataforma: import_zod49.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Target publishing platform."),
-        tipo: import_zod49.z.enum(["post", "blog", "carousel", "reel", "story", "review_response"]).describe("Content type."),
-        keyword: import_zod49.z.string().describe("Primary keyword for the content."),
-        tema: import_zod49.z.string().optional().describe("Content topic/theme. OMIT this field if it does not apply. Do NOT send empty string or null."),
-        productoId: import_zod49.z.string().optional().describe("Linked product ID. OMIT this field if no product is linked."),
-        estado: import_zod49.z.enum(["planificado", "pre_aprobado", "generado", "revisar", "aprobado", "publicado", "rechazado"]).optional().describe('Initial status. OMIT to use default "planificado".'),
-        locationId: import_zod49.z.string().optional().describe("GBP location ID \u2014 only when plataforma=gbp AND tenant is multi-location. OMIT otherwise."),
-        locationNombre: import_zod49.z.string().optional().describe("Human-readable GBP location name. OMIT if locationId is not provided.")
+      brandId: import_zod51.z.string().describe('Brand ID (e.g. "ponch", "teleglobos").'),
+      mes: import_zod51.z.string().describe('Calendar month in YYYY-MM format (e.g. "2026-05").'),
+      semana: import_zod51.z.number().describe("Week number within the month (1-5)."),
+      slot: import_zod51.z.object({
+        dia: import_zod51.z.string().describe("Slot date in YYYY-MM-DD format. Must fall within the week's fechaInicio/fechaFin range."),
+        plataforma: import_zod51.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Target publishing platform."),
+        tipo: import_zod51.z.enum(["post", "blog", "carousel", "reel", "story", "review_response"]).describe("Content type."),
+        keyword: import_zod51.z.string().describe("Primary keyword for the content."),
+        tema: import_zod51.z.string().optional().describe("Content topic/theme. OMIT this field if it does not apply. Do NOT send empty string or null."),
+        productoId: import_zod51.z.string().optional().describe("Linked product ID. OMIT this field if no product is linked."),
+        estado: import_zod51.z.enum(["planificado", "pre_aprobado", "generado", "revisar", "aprobado", "publicado", "rechazado"]).optional().describe('Initial status. OMIT to use default "planificado".'),
+        locationId: import_zod51.z.string().optional().describe("GBP location ID \u2014 only when plataforma=gbp AND tenant is multi-location. OMIT otherwise."),
+        locationNombre: import_zod51.z.string().optional().describe("Human-readable GBP location name. OMIT if locationId is not provided.")
       }).describe("New slot data.")
     },
     async ({ brandId, mes, semana, slot }) => {
@@ -16541,27 +16886,27 @@ Si pasas campos dentro de "datos", se hace merge con los datos existentes (no lo
     "update_calendar_slot",
     "MODIFY an EXISTING slot in the editorial calendar. To create a new slot use add_calendar_slot. If slotIndex does not exist, returns error SLOT_NOT_FOUND.",
     {
-      brandId: import_zod49.z.string().optional().describe("Brand ID. If omitted, uses the active brand from session context."),
-      mes: import_zod49.z.string().describe("Calendar month in YYYY-MM format."),
-      semana: import_zod49.z.number().describe("Week number within the month (1-5)."),
-      slotIndex: import_zod49.z.number().describe("Slot index (0-based). Must point to an existing slot \u2014 to add new slots use add_calendar_slot."),
-      cambios: import_zod49.z.object({
-        dia: import_zod49.z.string().nullable().optional().describe("Slot date in YYYY-MM-DD. OMIT if not changing date. Use null to explicitly clear."),
-        plataforma: import_zod49.z.enum(["gbp", "shopify_blog", "instagram", "review"]).nullable().optional().describe("OMIT if not changing platform."),
-        tipo: import_zod49.z.enum(["post", "blog", "carousel", "reel", "story", "review_response"]).nullable().optional().describe("OMIT if not changing content type."),
-        keyword: import_zod49.z.string().nullable().optional().describe("OMIT if not changing keyword."),
-        tema: import_zod49.z.string().nullable().optional().describe("OMIT if not changing topic."),
-        productoId: import_zod49.z.string().nullable().optional().describe("OMIT if not changing linked product. Use null to unlink."),
-        estado: import_zod49.z.enum(["planificado", "pre_aprobado", "generado", "revisar", "aprobado", "publicado", "rechazado"]).optional().describe("OMIT if not changing status manually."),
-        contenidoRef: import_zod49.z.string().nullable().optional().describe("OMIT \u2014 managed by the system, not by callers."),
-        fotoIdAsignada: import_zod49.z.string().nullable().optional().describe("Use assign_photo_to_content for photos. OMIT here."),
-        notas: import_zod49.z.array(NotaCalendarioSchema).optional().describe("Append-only notes for the slot."),
-        locationId: import_zod49.z.string().nullable().optional().describe("GBP location ID \u2014 only when plataforma=gbp."),
-        locationNombre: import_zod49.z.string().nullable().optional().describe("Human-readable GBP location name (for UI).")
+      brandId: import_zod51.z.string().optional().describe("Brand ID. If omitted, uses the active brand from session context."),
+      mes: import_zod51.z.string().describe("Calendar month in YYYY-MM format."),
+      semana: import_zod51.z.number().describe("Week number within the month (1-5)."),
+      slotIndex: import_zod51.z.number().describe("Slot index (0-based). Must point to an existing slot \u2014 to add new slots use add_calendar_slot."),
+      cambios: import_zod51.z.object({
+        dia: import_zod51.z.string().nullable().optional().describe("Slot date in YYYY-MM-DD. OMIT if not changing date. Use null to explicitly clear."),
+        plataforma: import_zod51.z.enum(["gbp", "shopify_blog", "instagram", "review"]).nullable().optional().describe("OMIT if not changing platform."),
+        tipo: import_zod51.z.enum(["post", "blog", "carousel", "reel", "story", "review_response"]).nullable().optional().describe("OMIT if not changing content type."),
+        keyword: import_zod51.z.string().nullable().optional().describe("OMIT if not changing keyword."),
+        tema: import_zod51.z.string().nullable().optional().describe("OMIT if not changing topic."),
+        productoId: import_zod51.z.string().nullable().optional().describe("OMIT if not changing linked product. Use null to unlink."),
+        estado: import_zod51.z.enum(["planificado", "pre_aprobado", "generado", "revisar", "aprobado", "publicado", "rechazado"]).optional().describe("OMIT if not changing status manually."),
+        contenidoRef: import_zod51.z.string().nullable().optional().describe("OMIT \u2014 managed by the system, not by callers."),
+        fotoIdAsignada: import_zod51.z.string().nullable().optional().describe("Use assign_photo_to_content for photos. OMIT here."),
+        notas: import_zod51.z.array(NotaCalendarioSchema).optional().describe("Append-only notes for the slot."),
+        locationId: import_zod51.z.string().nullable().optional().describe("GBP location ID \u2014 only when plataforma=gbp."),
+        locationNombre: import_zod51.z.string().nullable().optional().describe("Human-readable GBP location name (for UI).")
       }).strict().describe("Fields to update on the slot. Only declared fields accepted; unknown fields are rejected. OMIT any field you are not changing."),
-      accionContenidoExistente: import_zod49.z.union([
-        import_zod49.z.enum(["descartar", "nuevo_slot", "mantener"]),
-        import_zod49.z.string().regex(/^mover:semana:\d+:slot:\d+$/, "Format: mover:semana:N:slot:M")
+      accionContenidoExistente: import_zod51.z.union([
+        import_zod51.z.enum(["descartar", "nuevo_slot", "mantener"]),
+        import_zod51.z.string().regex(/^mover:semana:\d+:slot:\d+$/, "Format: mover:semana:N:slot:M")
       ]).optional().describe(
         'Required ONLY when the slot already has a contenidoRef AND the cambios touch semantic fields (keyword/tema/plataforma/tipo). In that case, the helper returns ACCION_CONTENIDO_EXISTENTE_REQUIRED with the 4 options listed below \u2014 ask the tenant which one to apply. OMIT this field in any other case. Do NOT send null. Valid values: "descartar" (mark existing content as discarded and apply changes to this slot) | "mover:semana:N:slot:M" (move existing content to target empty slot N/M and apply changes to origin slot) | "nuevo_slot" (do NOT touch this slot or its content; create a new slot same day with the changes \u2014 useful for multiple posts per day) | "mantener" (keep existing content here and apply changes anyway \u2014 typo-fix case where old content stays valid).'
       )
@@ -16606,9 +16951,9 @@ ESCRIBE EN DOS LUGARES:
 
 NUNCA uses update_calendar_slot para asignar fotos \u2014 eso escribe en la agenda, no en el post.`,
     {
-      contenidoRef: import_zod49.z.string().describe("ID del doc en marketing_contenido"),
-      fotoId: import_zod49.z.string().describe("ID de la foto en marketing_fotos (estado editada)"),
-      calendarioItemRef: import_zod49.z.string().optional().describe('Ref del slot (formato "semana:N:slot:M") para actualizar fotoIdAsignada')
+      contenidoRef: import_zod51.z.string().describe("ID del doc en marketing_contenido"),
+      fotoId: import_zod51.z.string().describe("ID de la foto en marketing_fotos (estado editada)"),
+      calendarioItemRef: import_zod51.z.string().optional().describe('Ref del slot (formato "semana:N:slot:M") para actualizar fotoIdAsignada')
     },
     async ({ contenidoRef, fotoId, calendarioItemRef }) => {
       const tenantId = session.requireTenant();
@@ -16634,7 +16979,7 @@ NUNCA uses update_calendar_slot para asignar fotos \u2014 eso escribe en la agen
     "approve_content",
     "Aprueba contenido para publicacion. Valida transicion de estado.",
     {
-      contenidoId: import_zod49.z.string().describe("ID del contenido a aprobar")
+      contenidoId: import_zod51.z.string().describe("ID del contenido a aprobar")
     },
     async ({ contenidoId }) => {
       session.requireTenant();
@@ -16658,8 +17003,8 @@ NUNCA uses update_calendar_slot para asignar fotos \u2014 eso escribe en la agen
     "reject_content",
     "Rechaza contenido con motivo. Valida transicion de estado.",
     {
-      contenidoId: import_zod49.z.string().describe("ID del contenido a rechazar"),
-      motivo: import_zod49.z.string().describe("Motivo del rechazo")
+      contenidoId: import_zod51.z.string().describe("ID del contenido a rechazar"),
+      motivo: import_zod51.z.string().describe("Motivo del rechazo")
     },
     async ({ contenidoId, motivo }) => {
       session.requireTenant();
@@ -16680,96 +17025,40 @@ NUNCA uses update_calendar_slot para asignar fotos \u2014 eso escribe en la agen
   );
   server.tool(
     "get_collections",
-    "Lee todas las colecciones canonicas (Shopify/WordPress/webonly) con sus 6 campos SEO actuales. Incluye best practices 2026.",
+    "Read all canonical collections (Shopify/WordPress/web-only) for a brand with their 6 SEO fields, plus best practices and the strict schema for generating SEO suggestions.",
     {
-      brandId: import_zod49.z.string().optional().describe("ID de la brand")
+      brandId: import_zod51.z.string().optional().describe("Brand identifier within the tenant")
     },
     async ({ brandId: inputBrandId }) => {
       const tenantId = session.requireTenant();
       const brandId = inputBrandId ?? session.requireBrand();
-      const db = getAdminDb();
-      const collSnap = await db.collection(`tenants/${tenantId}/marketing_snapshots/${brandId}/collections`).get();
-      const items = collSnap.docs.map((d) => d.data());
-      if (items.length === 0) {
-        return { content: [{ type: "text", text: JSON.stringify({
+      const ctx = await buildContext(session, brandId);
+      const result = await dispatchWithContract({
+        contract: collectionsReaderContract,
+        helper: collectionsReader,
+        callable: callCollectionsReader,
+        input: { tenantId, brandId },
+        ctx
+      });
+      let payload;
+      if (result.state === "success" && result.structuredOutput) {
+        payload = result.structuredOutput;
+      } else {
+        payload = {
           ok: false,
-          error: "No hay colecciones nested. El tenant debe sincronizar desde Marketing > Configuraci\xF3n > Shopify > Sincronizar."
-        }) }] };
-      }
-      const brand = await readDoc(`tenants/${tenantId}/marketing_config`, brandId);
-      const plan = brand?.plan ?? {};
-      const keywords = plan.keywordsPrioritarios ?? [];
-      const existingSuggestions = brand?.collectionSuggestions ?? {};
-      const collections = items.map((c) => {
-        const seo = c.seo || {};
-        const featured = c.featuredImage || null;
-        return {
-          id: c.platformId,
-          title: c.title,
-          handle: c.handle,
-          body_html: typeof c.descriptionHtml === "string" ? c.descriptionHtml.slice(0, 500) : null,
-          metaTitle: seo.metaTitle ?? null,
-          metaDescription: seo.metaDescription ?? null,
-          products_count: null,
-          // adapter v2 aun no calcula products_count por collection
-          collectionType: "canonical",
-          image: featured ? { src: featured.url, alt: featured.altText } : null,
-          existingSuggestion: existingSuggestions[String(c.platformId)] ?? null
+          state: result.state,
+          mensaje: result.text,
+          ...result.validationErrors && result.validationErrors.length > 0 ? { validationErrors: result.validationErrors } : {}
         };
-      });
-      return { content: [{ type: "text", text: JSON.stringify({
-        ok: true,
-        totalCollections: collections.length,
-        keywordsPrioritarios: keywords,
-        collections,
-        bestPractices: {
-          title: "Keyword principal, claro y corto. H1 de la p\xE1gina.",
-          description: "Arriba del grid: 2-3 frases (50-70 palabras). Abajo: 200-400 palabras con long-tail keywords. P\xE1ginas con descripci\xF3n rankean 2.7x m\xE1s.",
-          metaTitle: "50-60 chars. Keyword al inicio. Formato: {Keyword} | {Brand}. Max 600px.",
-          metaDescription: "120-158 chars. Keyword + CTA + value prop. 120 mobile, 158 desktop.",
-          handle: "Keyword en URL. NUNCA cambiar URL indexado sin redirect 301.",
-          imageAlt: "Descriptivo con keyword. Accesibilidad + Google Images + AEO.",
-          aeo: "AI engines validan im\xE1genes contra schema. Structured data importa."
-        },
-        schemaParaSave: {
-          _instrucciones: "SCHEMA ESTRICTO para save_collection_suggestions. Usa EXACTAMENTE estos nombres de campo. El sistema RECHAZAR\xC1 campos que no coincidan.",
-          _ejemplo: {
-            collectionId: 123456789,
-            suggestedTitle: "Flores Moradas | Env\xEDo CDMX",
-            suggestedDescription: "<p>Descubre nuestra colecci\xF3n de flores moradas...</p>",
-            suggestedMetaTitle: "Flores Moradas CDMX | Env\xEDo Mismo D\xEDa",
-            suggestedMetaDescription: "Env\xEDa flores moradas a domicilio en CDMX. Arreglos frescos con rosas, tulipanes y lirios morados. Entrega el mismo d\xEDa.",
-            suggestedHandle: null,
-            suggestedImageAlt: "Ramo de flores moradas con rosas y tulipanes - Ponch y Capric\xF3 florer\xEDa CDMX",
-            keyword: "flores moradas cdmx",
-            notas: "Meta title optimizado con keyword local. Description ampliada con long-tail keywords. Handle no cambia (ya indexado)."
-          },
-          _reglas: [
-            "collectionId: OBLIGATORIO. ID num\xE9rico de Shopify (no GID)",
-            "suggestedTitle: string. H1 de la p\xE1gina. Claro con keyword",
-            "suggestedDescription: string HTML. 200-400 palabras. Incluir links a colecciones relacionadas",
-            "suggestedMetaTitle: string. 50-60 chars. Keyword al inicio. NUNCA m\xE1s de 60",
-            "suggestedMetaDescription: string. 120-158 chars. Keyword + CTA + value prop. NUNCA m\xE1s de 158",
-            "suggestedHandle: string | null. Solo cambiar si el handle actual es malo. null = no cambiar",
-            "suggestedImageAlt: string. Descriptivo con keyword. Para accesibilidad + Google Images",
-            "keyword: string. Keyword target de esta colecci\xF3n (del plan de marketing)",
-            "notas: string. Explicaci\xF3n breve de qu\xE9 cambiaste y por qu\xE9"
-          ],
-          _nunca: [
-            "NUNCA usar titulo, descripcion, metaTitulo, metaDescripcion \u2014 usar los nombres en ingl\xE9s",
-            "NUNCA inventar collectionId \u2014 usar el id del array collections",
-            "NUNCA meta title > 60 chars o meta description > 158 chars",
-            "NUNCA cambiar handle de colecci\xF3n indexada sin justificaci\xF3n"
-          ]
-        }
-      }) }] };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
     }
   );
   server.tool(
     "save_collection_suggestions",
     "Guarda sugerencias SEO para colecciones de Shopify. El tenant las aprueba en la UI.",
     {
-      brandId: import_zod49.z.string().optional().describe("ID de la brand"),
+      brandId: import_zod51.z.string().optional().describe("ID de la brand"),
       suggestions: CollectionSuggestionsInputArraySchema.describe("Array de sugerencias SEO. Cada una con max 60 chars en metaTitle, max 158 en metaDescription, max 125 en imageAlt")
     },
     async ({ brandId: inputBrandId, suggestions }) => {
@@ -16795,7 +17084,7 @@ NUNCA uses update_calendar_slot para asignar fotos \u2014 eso escribe en la agen
 }
 
 // src/tools/martin.ts
-var import_zod50 = require("zod");
+var import_zod52 = require("zod");
 function renderResult(result) {
   const payload = {
     state: result.state,
@@ -16811,16 +17100,16 @@ function registerMartinTools(server, session) {
     "recordar_memoria",
     "Save a user preference, rule, pattern or aversion that the system will respect in future interactions. Personal to the calling user (scope: self). Applied automatically in Martin's prompt for subsequent conversations.",
     {
-      tipo: import_zod50.z.enum(["preferencia", "regla", "patron", "aversion"]).describe(
+      tipo: import_zod52.z.enum(["preferencia", "regla", "patron", "aversion"]).describe(
         "Memory type: 'preferencia' (personal preference), 'regla' (operational rule), 'patron' (observed behavioral pattern), 'aversion' (explicit do-not-do rule)."
       ),
-      categoria: import_zod50.z.enum(["compras", "produccion", "dispatch", "ventas", "marketing", "operacion", "personal", "delegacion"]).describe("Business area this memory applies to."),
-      contenido: import_zod50.z.string().min(3).max(500).describe("Memory content in the user's own words (3-500 chars)."),
-      origen: import_zod50.z.object({
-        tipo: import_zod50.z.enum(["conversacion", "feedback_card", "inferido_automatico"]),
-        conversacionId: import_zod50.z.string().nullable(),
-        cardId: import_zod50.z.string().nullable(),
-        rationale: import_zod50.z.array(import_zod50.z.string()).optional()
+      categoria: import_zod52.z.enum(["compras", "produccion", "dispatch", "ventas", "marketing", "operacion", "personal", "delegacion"]).describe("Business area this memory applies to."),
+      contenido: import_zod52.z.string().min(3).max(500).describe("Memory content in the user's own words (3-500 chars)."),
+      origen: import_zod52.z.object({
+        tipo: import_zod52.z.enum(["conversacion", "feedback_card", "inferido_automatico"]),
+        conversacionId: import_zod52.z.string().nullable(),
+        cardId: import_zod52.z.string().nullable(),
+        rationale: import_zod52.z.array(import_zod52.z.string()).optional()
       }).describe("Where this memory was inferred from (conversation, card feedback, or auto-inferred).")
     },
     async ({ tipo, categoria, contenido, origen }) => {
@@ -16839,9 +17128,9 @@ function registerMartinTools(server, session) {
     "olvidar_memoria",
     "Archive a memory that no longer applies. The memory remains visible in settings but is no longer enforced in future interactions. Requires confirmation: the first call returns a confirmation prompt; pass confirm=true on the second call to execute.",
     {
-      memoriaId: import_zod50.z.string().min(1).describe("Memory document ID to archive."),
-      motivo: import_zod50.z.string().optional().describe("Optional reason for archiving (logged for audit)."),
-      confirm: import_zod50.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
+      memoriaId: import_zod52.z.string().min(1).describe("Memory document ID to archive."),
+      motivo: import_zod52.z.string().optional().describe("Optional reason for archiving (logged for audit)."),
+      confirm: import_zod52.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
     },
     async ({ memoriaId, motivo, confirm }) => {
       const ctx = await buildContext(session, null, { confirmationGranted: confirm === true });
@@ -16859,25 +17148,25 @@ function registerMartinTools(server, session) {
     "programar_rutina",
     "Schedule a recurring or one-time task. Useful for monthly reports, reminders, scheduled posts, suggested purchases. Personal to the calling user (scope: self). Requires confirmation.",
     {
-      uidDestinatario: import_zod50.z.string().optional().describe("User ID who should receive the routine output. OMIT to default to the calling user (most common case)."),
-      tipo: import_zod50.z.enum(["reporte", "recordatorio", "accion_delegada", "publicacion", "compra_sugerida"]).describe("Routine type from canonical TipoRutinaEnum."),
-      frecuencia: import_zod50.z.enum(["diaria", "semanal", "quincenal", "mensual", "trimestral", "puntual"]).describe("Execution cadence."),
-      config: import_zod50.z.object({
-        diaSemana: import_zod50.z.number().int().min(0).max(6).nullable(),
-        diaMes: import_zod50.z.number().int().min(1).max(31).nullable(),
-        hora: import_zod50.z.string().regex(/^\d{2}:\d{2}$/),
-        fechaPuntual: import_zod50.z.string().datetime({ offset: true }).nullable()
+      uidDestinatario: import_zod52.z.string().optional().describe("User ID who should receive the routine output. OMIT to default to the calling user (most common case)."),
+      tipo: import_zod52.z.enum(["reporte", "recordatorio", "accion_delegada", "publicacion", "compra_sugerida"]).describe("Routine type from canonical TipoRutinaEnum."),
+      frecuencia: import_zod52.z.enum(["diaria", "semanal", "quincenal", "mensual", "trimestral", "puntual"]).describe("Execution cadence."),
+      config: import_zod52.z.object({
+        diaSemana: import_zod52.z.number().int().min(0).max(6).nullable(),
+        diaMes: import_zod52.z.number().int().min(1).max(31).nullable(),
+        hora: import_zod52.z.string().regex(/^\d{2}:\d{2}$/),
+        fechaPuntual: import_zod52.z.string().datetime({ offset: true }).nullable()
       }).describe("Schedule configuration. Match fields to the frecuencia (semanal needs diaSemana; mensual needs diaMes; puntual needs fechaPuntual)."),
-      accion: import_zod50.z.object({
-        tool: import_zod50.z.string().min(1),
-        params: import_zod50.z.record(import_zod50.z.string(), import_zod50.z.unknown())
+      accion: import_zod52.z.object({
+        tool: import_zod52.z.string().min(1),
+        params: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown())
       }).describe("Action to execute on each fire (MCP tool name + params)."),
-      origen: import_zod50.z.object({
-        tipo: import_zod50.z.enum(["conversacion", "feedback_card", "configurada_explicito"]),
-        conversacionId: import_zod50.z.string().nullable(),
-        cardId: import_zod50.z.string().nullable()
+      origen: import_zod52.z.object({
+        tipo: import_zod52.z.enum(["conversacion", "feedback_card", "configurada_explicito"]),
+        conversacionId: import_zod52.z.string().nullable(),
+        cardId: import_zod52.z.string().nullable()
       }).describe("Where this routine was scheduled from."),
-      confirm: import_zod50.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
+      confirm: import_zod52.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
     },
     async ({ uidDestinatario, tipo, frecuencia, config, accion, origen, confirm }) => {
       const ctx = await buildContext(session, null, { confirmationGranted: confirm === true });
@@ -16906,8 +17195,8 @@ function registerMartinTools(server, session) {
     "pausar_rutina",
     "Pause an active routine temporarily. Can be resumed later by re-enabling it.",
     {
-      rutinaId: import_zod50.z.string().min(1).describe("Routine document ID to pause."),
-      motivo: import_zod50.z.string().optional().describe("Optional reason for pausing (logged for audit).")
+      rutinaId: import_zod52.z.string().min(1).describe("Routine document ID to pause."),
+      motivo: import_zod52.z.string().optional().describe("Optional reason for pausing (logged for audit).")
     },
     async ({ rutinaId, motivo }) => {
       const ctx = await buildContext(session, null);
@@ -16933,9 +17222,9 @@ function registerMartinTools(server, session) {
     "archivar_rutina",
     "Archive a routine that no longer applies. The routine is preserved for audit purposes but will NOT be executed. Requires confirmation.",
     {
-      rutinaId: import_zod50.z.string().min(1).describe("Routine document ID to archive (will not execute again)."),
-      motivo: import_zod50.z.string().optional().describe("Optional reason for archiving (logged for audit)."),
-      confirm: import_zod50.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
+      rutinaId: import_zod52.z.string().min(1).describe("Routine document ID to archive (will not execute again)."),
+      motivo: import_zod52.z.string().optional().describe("Optional reason for archiving (logged for audit)."),
+      confirm: import_zod52.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
     },
     async ({ rutinaId, motivo, confirm }) => {
       const ctx = await buildContext(session, null, { confirmationGranted: confirm === true });