ponch-mcp-server 1.0.70 → 1.0.72

package/dist/index.js

@@ -133,6 +133,14 @@ var Session = class {
   get userName() {
     return this._authContext.userName;
   }
+  /** uid del usuario logueado. Necesario para audit log (211.1 HITO 6). */
+  get userId() {
+    return this._authContext.userId;
+  }
+  /** Rol del usuario (admin/encargado/empleado/super_admin). 211.1 HITO 6 */
+  get rol() {
+    return this._authContext.rol;
+  }
   setContext(tenantId, brandId) {
     if (this._authContext.mode !== "cowork") {
       throw new Error("set_context solo disponible en Modo Cowork");
@@ -408,27 +416,26 @@ function registerContextTools(server, session) {
         brandId: import_zod.z.string().describe('ID de la brand (ej: "ponch")')
       },
       async ({ tenantId, brandId }) => {
-        const config = await readDoc("marketing_config", tenantId);
-        if (!config) {
-          return {
-            content: [{ type: "text", text: JSON.stringify({ ok: false, error: `Tenant "${tenantId}" no tiene marketing_config` }) }]
-          };
-        }
-        const brands = config.brands ?? {};
-        if (!brands[brandId]) {
+        const brand = await readDoc(`tenants/${tenantId}/marketing_config`, brandId);
+        if (!brand) {
+          const brandsSnap = await getAdminDb().collection("tenants").doc(tenantId).collection("marketing_config").get();
+          if (brandsSnap.empty) {
+            return {
+              content: [{ type: "text", text: JSON.stringify({ ok: false, error: `Tenant "${tenantId}" no tiene marketing_config` }) }]
+            };
+          }
           return {
             content: [{
               type: "text",
               text: JSON.stringify({
                 ok: false,
                 error: `Brand "${brandId}" no existe en tenant "${tenantId}"`,
-                brandsDisponibles: Object.keys(brands)
+                brandsDisponibles: brandsSnap.docs.map((d) => d.id)
               })
             }]
           };
         }
         session.setContext(tenantId, brandId);
-        const brand = brands[brandId];
         return {
           content: [{
             type: "text",
@@ -522,7 +529,7 @@ function registerContextTools(server, session) {
 }
 
 // src/tools/core.ts
-var import_zod14 = require("zod");
+var import_zod26 = require("zod");
 
 // ../packages/marketing-schemas/dist/index.js
 var import_zod2 = require("zod");
@@ -537,6 +544,18 @@ var import_zod10 = require("zod");
 var import_zod11 = require("zod");
 var import_zod12 = require("zod");
 var import_zod13 = require("zod");
+var import_zod14 = require("zod");
+var import_zod15 = require("zod");
+var import_zod16 = require("zod");
+var import_zod17 = require("zod");
+var import_zod18 = require("zod");
+var import_zod19 = require("zod");
+var import_zod20 = require("zod");
+var import_zod21 = require("zod");
+var import_zod22 = require("zod");
+var import_zod23 = require("zod");
+var import_zod24 = require("zod");
+var import_zod25 = require("zod");
 var MARKETING_CONSTRAINTS = {
   // ═══════════════════════════════════════════════════════════
   // AUDIT — Legacy Content Audit (killer feature)
@@ -662,23 +681,24 @@ var MARKETING_CONSTRAINTS = {
 var SOURCE_PLATFORMS = ["shopify", "wordpress", "webonly"];
 var SourceSchema = import_zod2.z.enum(SOURCE_PLATFORMS);
 var FeaturedImageSchema = import_zod2.z.object({
-  url: import_zod2.z.string().min(10, "URL absoluta de la imagen (incluye protocolo https://)"),
-  altText: import_zod2.z.string().min(5, "Alt text describiendo lo que se ve en la imagen, minimo 5 chars. Critico para accesibilidad + AEO").nullable().optional(),
+  url: import_zod2.z.string().min(1, "URL de la imagen (no vacia)"),
+  altText: import_zod2.z.string().nullable().optional(),
   width: import_zod2.z.number().int().positive().nullable().optional(),
   height: import_zod2.z.number().int().positive().nullable().optional()
 }).strict();
 var SeoFieldsSchema = import_zod2.z.object({
-  metaTitle: import_zod2.z.string().max(70, "Meta title max 70 chars \u2014 Google trunca despues de 60").nullable().optional(),
-  metaDescription: import_zod2.z.string().max(180, "Meta description max 180 chars \u2014 Google trunca despues de 158").nullable().optional(),
+  metaTitle: import_zod2.z.string().nullable().optional(),
+  metaDescription: import_zod2.z.string().nullable().optional(),
+  ogDescription: import_zod2.z.string().nullable().optional(),
   focusKeyword: import_zod2.z.string().nullable().optional(),
   canonicalUrl: import_zod2.z.string().nullable().optional()
 }).strict();
-var EmbeddingsSchema = import_zod2.z.object({
-  /** Vertex multimodalembedding@001 — 1408 dims texto */
-  text: import_zod2.z.array(import_zod2.z.number()).length(1408, "embedding texto debe ser array de 1408 floats (Vertex multimodalembedding@001)").nullable().optional(),
-  /** Vertex multimodalembedding@001 — 1408 dims imagen */
-  image: import_zod2.z.array(import_zod2.z.number()).length(1408, "embedding imagen debe ser array de 1408 floats (Vertex multimodalembedding@001)").nullable().optional()
+var ExtractedHeadingsSchema = import_zod2.z.object({
+  h1: import_zod2.z.string().nullable(),
+  h2s: import_zod2.z.array(import_zod2.z.string()).default([])
 }).strict();
+var EMBEDDING_TEXT = import_zod2.z.array(import_zod2.z.number()).length(1408, "embedding texto debe ser array de 1408 floats (Vertex multimodalembedding@001)").nullable().optional();
+var EMBEDDING_IMAGE = import_zod2.z.array(import_zod2.z.number()).length(1408, "embedding imagen debe ser array de 1408 floats (Vertex multimodalembedding@001)").nullable().optional();
 var AdapterMetaSchema = import_zod2.z.object({
   /** WP: estructura de permalinks detectada. Ej: "/%postname%/" */
   permalinkStructure: import_zod2.z.string().nullable().optional(),
@@ -692,12 +712,13 @@ var AdapterMetaSchema = import_zod2.z.object({
   shopifyBlogId: import_zod2.z.string().nullable().optional()
 }).strict().nullable().optional();
 var ArticleSchema = import_zod2.z.object({
+  schemaVersion: import_zod2.z.literal(1).default(1),
   source: SourceSchema,
   platformId: import_zod2.z.string().min(1, "ID de la plataforma origen (Shopify GID o WP post ID como string)"),
   handle: import_zod2.z.string().min(1, "Slug/handle del articulo"),
-  title: import_zod2.z.string().min(5, "Titulo del articulo, minimo 5 chars"),
-  url: import_zod2.z.string().min(10, "URL publica absoluta del articulo"),
-  content: import_zod2.z.string().min(100, "Body HTML del articulo, minimo 100 chars para contenido real"),
+  title: import_zod2.z.string().min(1, "Titulo del articulo (no vacio)"),
+  url: import_zod2.z.string().min(1, "URL del articulo (no vacia)"),
+  content: import_zod2.z.string(),
   excerpt: import_zod2.z.string().nullable().optional(),
   featuredImage: FeaturedImageSchema.nullable().optional(),
   seo: SeoFieldsSchema,
@@ -709,33 +730,63 @@ var ArticleSchema = import_zod2.z.object({
     name: import_zod2.z.string().min(1),
     url: import_zod2.z.string().nullable().optional()
   }).strict().nullable().optional(),
-  embeddings: EmbeddingsSchema.nullable().optional(),
+  /**
+   * Blog asociado del articulo (Shopify blog / WP custom post type).
+   * Top-level porque es metadata estructural — UI agrupa articles por blog,
+   * brandBriefBuilder enriquece prompts con blog context, etc.
+   * Sesion 211.1 hito 5b.4 fix.
+   */
+  blogId: import_zod2.z.string().nullable().optional(),
+  blogHandle: import_zod2.z.string().nullable().optional(),
+  blogTitle: import_zod2.z.string().nullable().optional(),
+  embeddingText: EMBEDDING_TEXT,
+  embeddingImage: EMBEDDING_IMAGE,
   _adapterMeta: AdapterMetaSchema
 }).strict();
 var PageSchema = import_zod2.z.object({
+  schemaVersion: import_zod2.z.literal(1).default(1),
   source: SourceSchema,
   platformId: import_zod2.z.string().min(1),
   handle: import_zod2.z.string().min(1),
-  title: import_zod2.z.string().min(3),
-  url: import_zod2.z.string().min(10),
-  content: import_zod2.z.string().min(50, "Content HTML de la pagina, minimo 50 chars"),
+  title: import_zod2.z.string().min(1),
+  url: import_zod2.z.string().min(1),
+  content: import_zod2.z.string(),
   seo: SeoFieldsSchema,
+  /** H1 + H2s pre-extraidos del HTML (sesion 211.1 — usado por brandBriefBuilder sin re-parsear). */
+  extractedHeadings: ExtractedHeadingsSchema.nullable().optional(),
+  /** Primer parrafo plano extraido del content HTML (sesion 211.1). */
+  firstParagraph: import_zod2.z.string().nullable().optional(),
   featuredImage: FeaturedImageSchema.nullable().optional(),
   publishedAt: import_zod2.z.string().nullable().optional(),
   updatedAt: import_zod2.z.string().nullable().optional(),
-  embeddings: EmbeddingsSchema.nullable().optional(),
+  embeddingText: EMBEDDING_TEXT,
+  embeddingImage: EMBEDDING_IMAGE,
   _adapterMeta: AdapterMetaSchema
 }).strict();
 var PriceSchema = import_zod2.z.object({
   amount: import_zod2.z.number().nonnegative(),
   currencyCode: import_zod2.z.string().length(3, "currencyCode debe ser ISO 4217 (ej: USD, MXN, AUD)")
 }).strict();
+var VariantSchema = import_zod2.z.object({
+  platformId: import_zod2.z.string().min(1, "ID de la variante en la plataforma origen (Shopify GID variant, WP variation ID)"),
+  sku: import_zod2.z.string().nullable().optional(),
+  title: import_zod2.z.string().nullable().optional(),
+  price: PriceSchema.nullable().optional(),
+  compareAtPrice: PriceSchema.nullable().optional(),
+  available: import_zod2.z.boolean().nullable().optional(),
+  inventoryQuantity: import_zod2.z.number().int().nullable().optional(),
+  /** Mapa de opciones: { Color: 'Rojo', Talla: 'M' } — formato platform-agnostic */
+  options: import_zod2.z.record(import_zod2.z.string(), import_zod2.z.string()).optional(),
+  image: FeaturedImageSchema.nullable().optional(),
+  position: import_zod2.z.number().int().nullable().optional()
+}).strict();
 var ProductSchema = import_zod2.z.object({
+  schemaVersion: import_zod2.z.literal(1).default(1),
   source: SourceSchema,
   platformId: import_zod2.z.string().min(1),
   handle: import_zod2.z.string().min(1),
-  title: import_zod2.z.string().min(3),
-  url: import_zod2.z.string().min(10),
+  title: import_zod2.z.string().min(1),
+  url: import_zod2.z.string().min(1),
   description: import_zod2.z.string(),
   descriptionHtml: import_zod2.z.string().nullable().optional(),
   vendor: import_zod2.z.string().nullable().optional(),
@@ -746,27 +797,44 @@ var ProductSchema = import_zod2.z.object({
   price: PriceSchema.nullable().optional(),
   compareAtPrice: PriceSchema.nullable().optional(),
   available: import_zod2.z.boolean().nullable().optional(),
+  /** Variantes del producto (sesion 211.1 — Shopify variants, WP variations). */
+  variants: import_zod2.z.array(VariantSchema).default([]),
   seo: SeoFieldsSchema,
   collections: import_zod2.z.array(import_zod2.z.string()).optional(),
   publishedAt: import_zod2.z.string().nullable().optional(),
   updatedAt: import_zod2.z.string().nullable().optional(),
-  embeddings: EmbeddingsSchema.nullable().optional(),
+  embeddingText: EMBEDDING_TEXT,
+  embeddingImage: EMBEDDING_IMAGE,
   _adapterMeta: AdapterMetaSchema
 }).strict();
+var COLLECTION_TYPES = ["shopify_custom", "shopify_smart", "wp_category", "canonical"];
+var CollectionTypeSchema = import_zod2.z.enum(COLLECTION_TYPES);
 var CollectionSchema = import_zod2.z.object({
+  schemaVersion: import_zod2.z.literal(1).default(1),
   source: SourceSchema,
   platformId: import_zod2.z.string().min(1),
   handle: import_zod2.z.string().min(1),
-  title: import_zod2.z.string().min(2),
-  url: import_zod2.z.string().min(10),
+  title: import_zod2.z.string().min(1),
+  url: import_zod2.z.string().min(1),
   description: import_zod2.z.string().nullable().optional(),
   descriptionHtml: import_zod2.z.string().nullable().optional(),
   featuredImage: FeaturedImageSchema.nullable().optional(),
   productIds: import_zod2.z.array(import_zod2.z.string()).optional(),
+  /**
+   * Cantidad de productos en la coleccion. Sesion 211.1 5b.3 fix.
+   * Shopify lo provee via GraphQL (productsCount). WordPress lo calcularia del
+   * category. Webonly: null. UI usa para "X productos" badge.
+   */
+  productsCount: import_zod2.z.number().int().nonnegative().nullable().optional(),
+  /**
+   * Tipo de coleccion en la plataforma origen. Sesion 211.1 5b.3 fix.
+   */
+  collectionType: CollectionTypeSchema.nullable().optional(),
   seo: SeoFieldsSchema,
   publishedAt: import_zod2.z.string().nullable().optional(),
   updatedAt: import_zod2.z.string().nullable().optional(),
-  embeddings: EmbeddingsSchema.nullable().optional(),
+  embeddingText: EMBEDDING_TEXT,
+  embeddingImage: EMBEDDING_IMAGE,
   _adapterMeta: AdapterMetaSchema
 }).strict();
 var TONO_NARRATIVO_PROMPTS = {
@@ -863,6 +931,7 @@ var VisualRulesSchema = import_zod3.z.object({
   customNegatives: import_zod3.z.array(import_zod3.z.string()).default([])
 }).passthrough();
 var BrandBriefSchema = import_zod3.z.object({
+  schemaVersion: import_zod3.z.literal(1).default(1),
   descripcionCorta: import_zod3.z.string().min(1, "descripcionCorta es obligatorio"),
   segmento: SegmentoEnum,
   industria: IndustriaSchema.optional(),
@@ -1049,6 +1118,7 @@ var SemrushUsageSchema = import_zod4.z.object({
   historial: import_zod4.z.array(SemrushUsageHistorialItemSchema).optional()
 }).passthrough();
 var ConfigSchema = import_zod4.z.object({
+  schemaVersion: import_zod4.z.literal(1).default(1),
   id: import_zod4.z.string().min(1, "id es obligatorio"),
   tenantId: import_zod4.z.string().min(1, "tenantId es obligatorio"),
   brands: import_zod4.z.record(import_zod4.z.string(), BrandConfigSchema).optional(),
@@ -1111,6 +1181,7 @@ var SemanaCalendarioSchema = import_zod5.z.object({
   items: import_zod5.z.array(CalendarioItemSchema).optional()
 }).passthrough();
 var CalendarioSchema = import_zod5.z.object({
+  schemaVersion: import_zod5.z.literal(1).default(1),
   id: import_zod5.z.string().min(1, "id es obligatorio"),
   tenantId: import_zod5.z.string().min(1, "tenantId es obligatorio"),
   brandId: import_zod5.z.string().min(1, "brandId es obligatorio"),
@@ -1135,6 +1206,7 @@ var CollectionSuggestionInputSchema = import_zod6.z.object({
 }).passthrough();
 var CollectionSuggestionsInputArraySchema = import_zod6.z.array(CollectionSuggestionInputSchema).min(1, "Debe enviar al menos 1 sugerencia");
 var CollectionSuggestionStoredSchema = CollectionSuggestionInputSchema.extend({
+  schemaVersion: import_zod6.z.literal(1).default(1),
   estado: import_zod6.z.enum(["pendiente", "rechazado", "aplicado_parcial", "aplicado_total"]),
   generadoAt: import_zod6.z.union([
     import_zod6.z.string(),
@@ -1339,6 +1411,7 @@ var MediaVarianteSchema = import_zod7.z.object({
   mediaExternalId: import_zod7.z.string().nullable().optional()
 }).passthrough();
 var ContenidoSchema = import_zod7.z.object({
+  schemaVersion: import_zod7.z.literal(1).default(1),
   id: import_zod7.z.string().min(1, "id es obligatorio"),
   tenantId: import_zod7.z.string().min(1, "tenantId es obligatorio"),
   brandId: import_zod7.z.string().min(1, "brandId es obligatorio"),
@@ -1366,6 +1439,11 @@ var ContenidoSchema = import_zod7.z.object({
   externalId: import_zod7.z.string().nullable().optional()
 }).passthrough();
 function buildContenido(input) {
+  if (!input.languageCode) {
+    throw new Error(
+      `buildContenido requiere languageCode expl\xEDcito en input. Resolver antes de invocar el builder.`
+    );
+  }
   return ContenidoSchema.parse({
     id: input.id,
     tenantId: input.tenantId,
@@ -1373,7 +1451,7 @@ function buildContenido(input) {
     plataforma: input.plataforma ?? null,
     tipo: input.tipo,
     keyword: input.keyword ?? null,
-    languageCode: input.languageCode ?? "es",
+    languageCode: input.languageCode,
     estado: input.estado ?? "borrador",
     fotoId: input.fotoId ?? null,
     mediaUrl: input.mediaUrl ?? null,
@@ -1435,6 +1513,7 @@ var FotoLinkManualSchema = import_zod8.z.object({
   title: import_zod8.z.string()
 }).nullable();
 var FotoSchema = import_zod8.z.object({
+  schemaVersion: import_zod8.z.literal(1).default(1),
   id: import_zod8.z.string().min(1, "id es obligatorio"),
   tenantId: import_zod8.z.string().min(1, "tenantId es obligatorio"),
   brandId: import_zod8.z.string().min(1, "brandId es obligatorio"),
@@ -1510,6 +1589,7 @@ var FotoBriefingNecesidadSchema = import_zod9.z.object({
   fechaCubierta: import_zod9.z.unknown().nullable().optional()
 });
 var FotoBriefingSchema = import_zod9.z.object({
+  schemaVersion: import_zod9.z.literal(1).default(1),
   id: import_zod9.z.string().min(1),
   tenantId: import_zod9.z.string().min(1),
   brandId: import_zod9.z.string().min(1),
@@ -1619,6 +1699,7 @@ var PrioridadMesSchema = import_zod10.z.object({
   foco: import_zod10.z.string().optional()
 }).passthrough();
 var ColeccionesPriorizadasSchema = import_zod10.z.object({
+  schemaVersion: import_zod10.z.literal(1).default(1),
   grupos: import_zod10.z.array(GrupoColeccionesSchema),
   prioridadesMes: import_zod10.z.record(import_zod10.z.string(), PrioridadMesSchema).optional()
 }).passthrough();
@@ -1650,6 +1731,7 @@ var BlogEntrySchema = import_zod10.z.object({
   totalArticulos: import_zod10.z.number().int().nonnegative()
 }).passthrough();
 var BlogStrategySchema = import_zod10.z.object({
+  schemaVersion: import_zod10.z.literal(1).default(1),
   blogs: import_zod10.z.array(BlogEntrySchema).min(1, "Al menos 1 blog configurado"),
   defaultBlogId: import_zod10.z.string().min(1),
   defaultBlogHandle: import_zod10.z.string().min(1),
@@ -1835,6 +1917,7 @@ var EmbeddedDocBase = {
   ultimoUpdate: import_zod11.z.unknown().nullable().optional()
 };
 var ShopifyProductDocSchema = import_zod11.z.object({
+  schemaVersion: import_zod11.z.literal(1).default(1),
   ...EmbeddedDocBase,
   title: import_zod11.z.string(),
   handle: import_zod11.z.string(),
@@ -1850,6 +1933,7 @@ var ShopifyProductDocSchema = import_zod11.z.object({
   collectionHandles: import_zod11.z.array(import_zod11.z.string()).default([])
 }).passthrough();
 var ShopifyCollectionDocSchema = import_zod11.z.object({
+  schemaVersion: import_zod11.z.literal(1).default(1),
   ...EmbeddedDocBase,
   title: import_zod11.z.string(),
   handle: import_zod11.z.string(),
@@ -1866,6 +1950,7 @@ var ShopifyInlineImageSchema = import_zod11.z.object({
   alt: import_zod11.z.string().nullable()
 });
 var ShopifyArticleDocSchema = import_zod11.z.object({
+  schemaVersion: import_zod11.z.literal(1).default(1),
   ...EmbeddedDocBase,
   title: import_zod11.z.string(),
   handle: import_zod11.z.string(),
@@ -1882,6 +1967,7 @@ var ShopifyArticleDocSchema = import_zod11.z.object({
   published_at: import_zod11.z.string().nullable()
 }).passthrough();
 var ShopifyPageDocSchema = import_zod11.z.object({
+  schemaVersion: import_zod11.z.literal(1).default(1),
   ...EmbeddedDocBase,
   title: import_zod11.z.string(),
   handle: import_zod11.z.string(),
@@ -1905,6 +1991,7 @@ var SitePageContentSchema = import_zod12.z.object({
   fetchedAt: import_zod12.z.string()
 }).passthrough();
 var SiteContentSchema = import_zod12.z.object({
+  schemaVersion: import_zod12.z.literal(1).default(1),
   id: import_zod12.z.string().min(1),
   tenantId: import_zod12.z.string().min(1),
   brandId: import_zod12.z.string().min(1),
@@ -1984,6 +2071,7 @@ var DETECTED_CONFLICT_TYPES = [
 ];
 var CONFLICT_SEVERITIES = ["info", "warning", "error"];
 var SuggestedActionSchema = import_zod13.z.object({
+  schemaVersion: import_zod13.z.literal(1).default(1),
   id: import_zod13.z.enum(ALLOWED_ACTION_IDS),
   labelKey: import_zod13.z.string().regex(/^marketing\.actions\./, {
     message: 'labelKey debe empezar con "marketing.actions."'
@@ -2000,6 +2088,456 @@ var DetectedConflictSchema = import_zod13.z.object({
   message: import_zod13.z.string().max(500),
   relatedItems: import_zod13.z.array(import_zod13.z.unknown()).optional()
 });
+var TenantStatusEnum = import_zod14.z.enum([
+  "active",
+  "trial",
+  "suspended",
+  "cancelled",
+  "pending_payment"
+]);
+var TrialInfoSchema = import_zod14.z.object({
+  inicioTrial: import_zod14.z.unknown().nullable(),
+  finTrial: import_zod14.z.unknown().nullable()
+}).strict().nullable().optional();
+var SuspensionInfoSchema = import_zod14.z.object({
+  fecha: import_zod14.z.unknown(),
+  motivo: import_zod14.z.string(),
+  gracePeriodDias: import_zod14.z.number(),
+  finGracePeriod: import_zod14.z.unknown()
+}).strict().nullable().optional();
+var CancellationInfoSchema = import_zod14.z.object({
+  fecha: import_zod14.z.unknown(),
+  motivo: import_zod14.z.string(),
+  iniciadaPor: import_zod14.z.enum(["user", "admin", "system"]),
+  gracePeriodDias: import_zod14.z.number(),
+  finGracePeriod: import_zod14.z.unknown()
+}).strict().nullable().optional();
+var TenantStatusFieldsSchema = import_zod14.z.object({
+  schemaVersion: import_zod14.z.literal(1).default(1),
+  status: TenantStatusEnum.default("active"),
+  trial: TrialInfoSchema,
+  suspension: SuspensionInfoSchema,
+  cancellation: CancellationInfoSchema
+}).passthrough();
+var AuditActorSchema = import_zod15.z.object({
+  type: import_zod15.z.enum(["user", "martin", "system", "cf_scheduled", "webhook"]),
+  uid: import_zod15.z.string().nullable(),
+  nombre: import_zod15.z.string(),
+  metadata: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.any()).optional()
+}).strict();
+var AuditChangesSchema = import_zod15.z.object({
+  before: import_zod15.z.any().nullable(),
+  after: import_zod15.z.any().nullable()
+}).strict();
+var AuditLogEntrySchema = import_zod15.z.object({
+  schemaVersion: import_zod15.z.literal(1).default(1),
+  id: import_zod15.z.string(),
+  tenantId: import_zod15.z.string(),
+  brandId: import_zod15.z.string().nullable(),
+  // Quién
+  actor: AuditActorSchema,
+  // Qué
+  action: import_zod15.z.string().min(1, 'action can\xF3nico es obligatorio (ej. "contenido.descartar")'),
+  targetType: import_zod15.z.string(),
+  targetPath: import_zod15.z.string(),
+  targetId: import_zod15.z.string(),
+  // Cómo
+  changes: AuditChangesSchema,
+  // Contexto
+  motivo: import_zod15.z.string().nullable(),
+  conversacionId: import_zod15.z.string().nullable(),
+  // Resultado
+  status: import_zod15.z.enum(["success", "error", "partial"]),
+  errorMessage: import_zod15.z.string().nullable(),
+  durationMs: import_zod15.z.number().nonnegative(),
+  // Cuándo (Firestore serverTimestamp)
+  timestamp: import_zod15.z.unknown(),
+  // Origen técnico (debugging, NO mostrar al usuario)
+  origenTecnico: import_zod15.z.object({
+    cfName: import_zod15.z.string().optional(),
+    helperName: import_zod15.z.string().optional(),
+    requestId: import_zod15.z.string().optional()
+  }).optional()
+}).strict();
+function buildAuditLogEntry(input) {
+  return AuditLogEntrySchema.parse(input);
+}
+var PrecioRegionSchema = import_zod16.z.object({
+  mensual: import_zod16.z.number().nonnegative(),
+  anual: import_zod16.z.number().nonnegative(),
+  moneda: import_zod16.z.string().length(3, "moneda debe ser ISO 4217 (USD, MXN, AUD, etc.)")
+}).strict();
+var MembresiaAddonSchema = import_zod16.z.object({
+  schemaVersion: import_zod16.z.literal(1).default(1),
+  id: import_zod16.z.string().min(1),
+  nombre: import_zod16.z.string().min(1),
+  descripcion: import_zod16.z.string(),
+  activo: import_zod16.z.boolean(),
+  /** Diccionario de límites a incrementar. Ej: { brandsIncluidas: 1 } */
+  incrementa: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.number()),
+  /** Precio default (si la región del tenant no tiene override) */
+  precio: PrecioRegionSchema,
+  /** Precios por región: { MX, US, AR, ES, AU, ... } */
+  preciosPorRegion: import_zod16.z.record(import_zod16.z.string(), PrecioRegionSchema).optional(),
+  /** Planes a los que se puede aplicar. Ej: ['pro', 'enterprise'] */
+  aplicableA: import_zod16.z.array(import_zod16.z.string()),
+  /** Máximo de unidades por tenant. null = sin tope */
+  maxPorTenant: import_zod16.z.number().int().nullable(),
+  fechaCreacion: import_zod16.z.string()
+}).strict();
+var AddonActivoSchema = import_zod16.z.object({
+  addonId: import_zod16.z.string(),
+  cantidad: import_zod16.z.number().int().positive(),
+  fechaCompra: import_zod16.z.unknown(),
+  /** null = suscripción mensual continua */
+  finVigencia: import_zod16.z.unknown().nullable(),
+  estado: import_zod16.z.enum(["active", "cancelled"])
+}).strict();
+var TipoMemoriaEnum = import_zod17.z.enum([
+  "filtro",
+  "preferencia",
+  "patron",
+  "aprendido",
+  "delegacion"
+]);
+var StatusMemoriaEnum = import_zod17.z.enum([
+  "explicito",
+  "explicito_confirmado",
+  "inferido",
+  "archivado"
+]);
+var CategoriaMemoriaEnum = import_zod17.z.enum([
+  "compras",
+  "produccion",
+  "dispatch",
+  "ventas",
+  "marketing",
+  "operacion",
+  "personal",
+  "delegacion"
+]);
+var OrigenMemoriaSchema = import_zod17.z.object({
+  tipo: import_zod17.z.enum(["conversacion", "feedback_card", "inferido_automatico"]),
+  conversacionId: import_zod17.z.string().nullable(),
+  /** Si vino de feedback long-press en un card */
+  cardId: import_zod17.z.string().nullable(),
+  /** Razones que la generaron (para debugging + transparencia) */
+  rationale: import_zod17.z.array(import_zod17.z.string()).optional()
+}).strict();
+var MartinMemoriaSchema = import_zod17.z.object({
+  schemaVersion: import_zod17.z.literal(1).default(1),
+  id: import_zod17.z.string().min(1, "id es obligatorio"),
+  tenantId: import_zod17.z.string().min(1, "tenantId es obligatorio"),
+  /** Usuario dueño de la memoria */
+  uid: import_zod17.z.string().min(1, "uid es obligatorio"),
+  tipo: TipoMemoriaEnum,
+  categoria: CategoriaMemoriaEnum,
+  contenido: import_zod17.z.string().min(3, "contenido debe tener al menos 3 chars").max(500, "contenido max 500 chars"),
+  origen: OrigenMemoriaSchema,
+  status: StatusMemoriaEnum.default("explicito"),
+  /** Veces que Martin la usó */
+  aplicacionesCount: import_zod17.z.number().int().nonnegative().default(0),
+  ultimaAplicacionAt: import_zod17.z.string().datetime().nullable().default(null),
+  createdAt: import_zod17.z.string().datetime(),
+  updatedAt: import_zod17.z.string().datetime()
+}).strict();
+var TipoRutinaEnum = import_zod18.z.enum([
+  "reporte",
+  "recordatorio",
+  "accion_delegada",
+  "publicacion",
+  "compra_sugerida"
+]);
+var FrecuenciaRutinaEnum = import_zod18.z.enum([
+  "diaria",
+  "semanal",
+  "quincenal",
+  "mensual",
+  "trimestral",
+  "puntual"
+]);
+var StatusRutinaEnum = import_zod18.z.enum([
+  "activa",
+  "pausada",
+  "archivada",
+  "completada"
+]);
+var ConfigRutinaSchema = import_zod18.z.object({
+  /** Día semana 0=dom, 6=sab. Para semanal/quincenal */
+  diaSemana: import_zod18.z.number().int().min(0).max(6).nullable(),
+  /** Día mes 1-31. Para mensual/trimestral */
+  diaMes: import_zod18.z.number().int().min(1).max(31).nullable(),
+  /** Hora "HH:MM" en la timezone del tenant (heredada de tenants/{tid}.zonaHoraria) */
+  hora: import_zod18.z.string().regex(/^\d{2}:\d{2}$/, "hora debe ser formato HH:MM (24h)"),
+  /** Si frecuencia=puntual, fecha exacta ISO con offset */
+  fechaPuntual: import_zod18.z.string().datetime({ offset: true }).nullable()
+}).strict();
+var AccionRutinaSchema = import_zod18.z.object({
+  /** Nombre del tool MCP a invocar */
+  tool: import_zod18.z.string().min(1),
+  /** Parámetros para el tool */
+  params: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.unknown())
+}).strict();
+var OrigenRutinaSchema = import_zod18.z.object({
+  tipo: import_zod18.z.enum(["conversacion", "feedback_card", "configurada_explicito"]),
+  conversacionId: import_zod18.z.string().nullable(),
+  cardId: import_zod18.z.string().nullable()
+}).strict();
+var MartinRutinaSchema = import_zod18.z.object({
+  schemaVersion: import_zod18.z.literal(1).default(1),
+  id: import_zod18.z.string().min(1),
+  tenantId: import_zod18.z.string().min(1),
+  /** Quién la creó */
+  uidCreador: import_zod18.z.string().min(1),
+  /** A quién va dirigida (puede ser otro empleado) */
+  uidDestinatario: import_zod18.z.string().min(1),
+  tipo: TipoRutinaEnum,
+  frecuencia: FrecuenciaRutinaEnum,
+  config: ConfigRutinaSchema,
+  accion: AccionRutinaSchema,
+  origen: OrigenRutinaSchema,
+  status: StatusRutinaEnum.default("activa"),
+  ejecucionesCount: import_zod18.z.number().int().nonnegative().default(0),
+  ultimaEjecucionAt: import_zod18.z.string().datetime().nullable().default(null),
+  /** Calculado para optimizar query del cron */
+  proximaEjecucionAt: import_zod18.z.string().datetime(),
+  createdAt: import_zod18.z.string().datetime(),
+  updatedAt: import_zod18.z.string().datetime()
+}).strict();
+var MenuItemSchema = import_zod19.z.lazy(
+  () => import_zod19.z.object({
+    title: import_zod19.z.string().min(1, "Texto visible del item del menu"),
+    url: import_zod19.z.string().min(1, "URL del item (puede ser absoluta o relativa)"),
+    /** Tipo de destino: collection / page / product / catalog / blog / article / etc. */
+    type: import_zod19.z.string().nullable().optional(),
+    /** ID del recurso al que apunta el item (collection ID, page ID, etc.) */
+    resourceId: import_zod19.z.string().nullable().optional(),
+    /** Sub-items recursivos (sub-menus). Default array vacio. */
+    items: import_zod19.z.array(MenuItemSchema).default([])
+  }).strict()
+);
+var MENU_ASSIGNMENTS = ["header", "footer", "unassigned"];
+var MenuAssignmentSchema = import_zod19.z.enum(MENU_ASSIGNMENTS);
+var MenuSchema = import_zod19.z.object({
+  schemaVersion: import_zod19.z.literal(1).default(1),
+  source: SourceSchema,
+  platformId: import_zod19.z.string().min(1, "ID del menu en la plataforma origen"),
+  handle: import_zod19.z.string().min(1, "Handle/slug del menu"),
+  title: import_zod19.z.string().min(1, "Titulo del menu"),
+  /** Donde aparece el menu en el sitio */
+  assignedTo: MenuAssignmentSchema.default("unassigned"),
+  items: import_zod19.z.array(MenuItemSchema).default([]),
+  updatedAt: import_zod19.z.string().nullable().optional()
+}).strict();
+var SITE_META_SOURCES = ["shopify", "wordpress", "webonly"];
+var SiteMetaSourceSchema = import_zod20.z.enum(SITE_META_SOURCES);
+var ScrapedPageSchema = import_zod20.z.object({
+  url: import_zod20.z.string().min(1, "URL de la pagina scrappeada (no vacia)"),
+  title: import_zod20.z.string().nullable().optional(),
+  metaDescription: import_zod20.z.string().nullable().optional(),
+  ogTitle: import_zod20.z.string().nullable().optional(),
+  ogDescription: import_zod20.z.string().nullable().optional(),
+  h1: import_zod20.z.string().nullable().optional(),
+  h2s: import_zod20.z.array(import_zod20.z.string()).default([]),
+  firstParagraph: import_zod20.z.string().nullable().optional(),
+  canonicalUrl: import_zod20.z.string().nullable().optional(),
+  fetchedAt: import_zod20.z.string()
+}).strict();
+var SiteMetaSchema = import_zod20.z.object({
+  schemaVersion: import_zod20.z.literal(1).default(1),
+  source: SiteMetaSourceSchema,
+  /** Hostname del shop (ej: "atteyo-com.myshopify.com" o "atteyo.com") */
+  shop: import_zod20.z.string().min(1, "Hostname del shop"),
+  fetchedAt: import_zod20.z.string(),
+  sitemapFound: import_zod20.z.boolean(),
+  urlsDiscovered: import_zod20.z.number().int().nonnegative(),
+  urlsScraped: import_zod20.z.number().int().nonnegative(),
+  /** Homepage parseada (puede ser null si fall el fetch). */
+  homepage: ScrapedPageSchema.nullable().optional(),
+  /** Paginas extra detectadas via sitemap.xml: about, faq, contact, terms, privacy, etc. */
+  extraPages: import_zod20.z.record(import_zod20.z.string(), ScrapedPageSchema).default({}),
+  /** Texto combinado de homepage + extras para embedding texto. */
+  combinedText: import_zod20.z.string().nullable().optional(),
+  /** Embedding 1408d Vertex (texto). */
+  embeddingText: import_zod20.z.array(import_zod20.z.number()).length(EMBEDDING_DIMS).nullable().optional(),
+  /** Embedding 1408d Vertex (imagen — opcional). */
+  embeddingImage: import_zod20.z.array(import_zod20.z.number()).length(EMBEDDING_DIMS).nullable().optional(),
+  embeddingModelo: import_zod20.z.string().nullable().optional(),
+  /** Firestore Timestamp / Date / string ISO — flexible. */
+  embeddingFecha: import_zod20.z.unknown().nullable().optional()
+}).strict();
+var GSC_CHANGE_TYPES = [
+  "publish",
+  "urlChange",
+  "bodyRewrite",
+  "metaEdit",
+  "altText",
+  "internalLinks"
+];
+var GscChangeTypeSchema = import_zod21.z.enum(GSC_CHANGE_TYPES);
+var GSC_PRIORITIES = ["high", "medium", "low", "skip"];
+var GscPrioritySchema = import_zod21.z.enum(GSC_PRIORITIES);
+var GSC_STATUSES = ["pending", "flushed", "error", "skipped"];
+var GscStatusSchema = import_zod21.z.enum(GSC_STATUSES);
+var GscQueueItemSchema = import_zod21.z.object({
+  schemaVersion: import_zod21.z.literal(1).default(1),
+  id: import_zod21.z.string().min(1),
+  tenantId: import_zod21.z.string().min(1),
+  brandId: import_zod21.z.string().min(1),
+  url: import_zod21.z.string().url("URL absoluta del recurso a notificar a GSC"),
+  changeType: GscChangeTypeSchema,
+  priority: GscPrioritySchema,
+  /** Firestore Timestamp / Date / ISO — set por enqueueGscPing helper. */
+  enqueuedAt: import_zod21.z.unknown(),
+  status: GscStatusSchema,
+  /** Set cuando flushGscQueue procesa el item (status='flushed' o 'skipped'). */
+  flushedAt: import_zod21.z.unknown().nullable(),
+  errorMessage: import_zod21.z.string().nullable()
+}).strict();
+var BlogSchema = import_zod22.z.object({
+  schemaVersion: import_zod22.z.literal(1).default(1),
+  source: SourceSchema,
+  platformId: import_zod22.z.string().min(1, "ID del blog en la plataforma origen (Shopify blog ID)"),
+  handle: import_zod22.z.string().min(1, "Slug/handle del blog"),
+  title: import_zod22.z.string().min(1, "Titulo del blog"),
+  /** Si los articles aceptan comentarios. Shopify: 'no' | 'moderate' | 'yes' */
+  commentable: import_zod22.z.string().nullable().optional(),
+  feedburner: import_zod22.z.string().nullable().optional(),
+  tags: import_zod22.z.string().nullable().optional(),
+  templateSuffix: import_zod22.z.string().nullable().optional(),
+  /** Conteo de articles publicados (derivado al fetch — no oficial Shopify). */
+  articlesCount: import_zod22.z.number().int().nonnegative().nullable().optional(),
+  publishedAt: import_zod22.z.string().nullable().optional(),
+  updatedAt: import_zod22.z.string().nullable().optional(),
+  createdAt: import_zod22.z.string().nullable().optional()
+}).strict();
+var LocationSchema = import_zod23.z.object({
+  schemaVersion: import_zod23.z.literal(1).default(1),
+  source: SourceSchema,
+  platformId: import_zod23.z.string().min(1, "ID de la location en la plataforma origen"),
+  name: import_zod23.z.string().min(1, "Nombre de la location"),
+  address1: import_zod23.z.string().nullable().optional(),
+  address2: import_zod23.z.string().nullable().optional(),
+  city: import_zod23.z.string().nullable().optional(),
+  province: import_zod23.z.string().nullable().optional(),
+  provinceCode: import_zod23.z.string().nullable().optional(),
+  zip: import_zod23.z.string().nullable().optional(),
+  country: import_zod23.z.string().nullable().optional(),
+  countryCode: import_zod23.z.string().nullable().optional(),
+  countryName: import_zod23.z.string().nullable().optional(),
+  phone: import_zod23.z.string().nullable().optional(),
+  active: import_zod23.z.boolean().nullable().optional(),
+  legacy: import_zod23.z.boolean().nullable().optional(),
+  createdAt: import_zod23.z.string().nullable().optional(),
+  updatedAt: import_zod23.z.string().nullable().optional()
+}).strict();
+var StaffMemberSchema = import_zod24.z.object({
+  schemaVersion: import_zod24.z.literal(1).default(1),
+  source: SourceSchema,
+  platformId: import_zod24.z.string().min(1, "ID del staff member en la plataforma origen (Shopify GID o numeric ID)"),
+  /** Shopify GraphQL devuelve "name" combinado (ya no first_name/last_name separados). */
+  name: import_zod24.z.string().min(1, "Nombre del staff member"),
+  email: import_zod24.z.string().nullable().optional(),
+  /** Shopify GraphQL: isShopOwner indica si es el dueno principal. */
+  isShopOwner: import_zod24.z.boolean().nullable().optional(),
+  active: import_zod24.z.boolean().nullable().optional(),
+  accountType: import_zod24.z.string().nullable().optional(),
+  role: import_zod24.z.string().nullable().optional(),
+  locale: import_zod24.z.string().nullable().optional()
+}).strict();
+var ShopInfoSchema = import_zod25.z.object({
+  shopId: import_zod25.z.union([import_zod25.z.string(), import_zod25.z.number()]).nullable().optional(),
+  name: import_zod25.z.string().nullable().optional(),
+  email: import_zod25.z.string().nullable().optional(),
+  description: import_zod25.z.string().nullable().optional(),
+  currency: import_zod25.z.string().nullable().optional(),
+  moneyFormat: import_zod25.z.string().nullable().optional(),
+  timezone: import_zod25.z.string().nullable().optional(),
+  country: import_zod25.z.string().nullable().optional(),
+  countryCode: import_zod25.z.string().nullable().optional(),
+  province: import_zod25.z.string().nullable().optional(),
+  city: import_zod25.z.string().nullable().optional(),
+  address1: import_zod25.z.string().nullable().optional(),
+  phone: import_zod25.z.string().nullable().optional(),
+  domain: import_zod25.z.string().nullable().optional(),
+  myshopifyDomain: import_zod25.z.string().nullable().optional(),
+  planName: import_zod25.z.string().nullable().optional(),
+  planDisplayName: import_zod25.z.string().nullable().optional(),
+  weightUnit: import_zod25.z.string().nullable().optional(),
+  primaryLocale: import_zod25.z.string().nullable().optional(),
+  createdAt: import_zod25.z.string().nullable().optional(),
+  updatedAt: import_zod25.z.string().nullable().optional()
+}).strict().nullable();
+var ThemeSchema = import_zod25.z.object({
+  id: import_zod25.z.union([import_zod25.z.string(), import_zod25.z.number()]).nullable().optional(),
+  name: import_zod25.z.string().nullable().optional(),
+  role: import_zod25.z.string().nullable().optional(),
+  /** Mapa de menus asignados al tema (header, footer). */
+  themeMenus: import_zod25.z.object({
+    header: import_zod25.z.array(import_zod25.z.object({ handle: import_zod25.z.string() }).passthrough()).default([]),
+    footer: import_zod25.z.array(import_zod25.z.object({ handle: import_zod25.z.string() }).passthrough()).default([])
+  }).strict().nullable().optional(),
+  themeMenuHandle: import_zod25.z.string().nullable().optional(),
+  /** Settings del header section (sub-objeto del theme settings). */
+  headerSettings: import_zod25.z.unknown().nullable().optional(),
+  footerSettings: import_zod25.z.unknown().nullable().optional()
+}).strict().nullable();
+var OrdersSummarySchema = import_zod25.z.object({
+  totalOrders: import_zod25.z.number().int().nonnegative().default(0),
+  dateRange: import_zod25.z.object({
+    from: import_zod25.z.string(),
+    to: import_zod25.z.string()
+  }).strict().nullable().optional(),
+  topSkus: import_zod25.z.array(import_zod25.z.object({
+    sku: import_zod25.z.string(),
+    title: import_zod25.z.string().nullable().optional(),
+    quantity: import_zod25.z.number().nonnegative(),
+    revenue: import_zod25.z.number().nonnegative()
+  }).strict()).default([]),
+  avgOrderValue: import_zod25.z.number().nonnegative().default(0),
+  ordersPerDay: import_zod25.z.number().nonnegative().default(0),
+  totalRevenue: import_zod25.z.number().nonnegative().default(0),
+  financialStatusBreakdown: import_zod25.z.record(import_zod25.z.string(), import_zod25.z.number().nonnegative()).default({})
+}).strict().nullable();
+var CustomersSummarySchema = import_zod25.z.object({
+  totalCustomers: import_zod25.z.number().int().nonnegative().default(0),
+  topCustomers: import_zod25.z.array(import_zod25.z.object({
+    id: import_zod25.z.union([import_zod25.z.string(), import_zod25.z.number()]).nullable().optional(),
+    name: import_zod25.z.string().nullable().optional(),
+    ordersCount: import_zod25.z.number().int().nonnegative().nullable().optional(),
+    totalSpent: import_zod25.z.union([import_zod25.z.string(), import_zod25.z.number()]).nullable().optional(),
+    tags: import_zod25.z.string().nullable().optional(),
+    createdAt: import_zod25.z.string().nullable().optional()
+  }).strict()).default([])
+}).strict().nullable();
+var SnapshotCountsSchema = import_zod25.z.object({
+  products: import_zod25.z.number().int().nonnegative().default(0),
+  collections: import_zod25.z.number().int().nonnegative().default(0),
+  articles: import_zod25.z.number().int().nonnegative().default(0),
+  pages: import_zod25.z.number().int().nonnegative().default(0),
+  menus: import_zod25.z.number().int().nonnegative().default(0),
+  blogs: import_zod25.z.number().int().nonnegative().default(0),
+  locations: import_zod25.z.number().int().nonnegative().default(0),
+  staffMembers: import_zod25.z.number().int().nonnegative().default(0),
+  siteMeta: import_zod25.z.number().int().nonnegative().default(0)
+}).strict();
+var SnapshotMetaSchema = import_zod25.z.object({
+  schemaVersion: import_zod25.z.literal(1).default(1),
+  source: SourceSchema,
+  brandId: import_zod25.z.string().min(1),
+  /** Hostname del shop (atteyo.com / atteyo-com.myshopify.com). */
+  shop: import_zod25.z.string().min(1),
+  shopName: import_zod25.z.string().nullable().optional(),
+  /** Timestamp de la ultima sync exitosa. Firestore Timestamp/Date/string ISO. */
+  syncedAt: import_zod25.z.unknown().nullable().optional(),
+  /** ID del ultimo import que populo este snapshot. */
+  lastImportId: import_zod25.z.string().nullable().optional(),
+  counts: SnapshotCountsSchema,
+  shopInfo: ShopInfoSchema,
+  theme: ThemeSchema,
+  ordersSummary: OrdersSummarySchema,
+  customersSummary: CustomersSummarySchema
+}).strict();
 
 // src/tools/core.ts
 function registerCoreTools(server, session) {
@@ -2007,19 +2545,18 @@ function registerCoreTools(server, session) {
     "get_business_summary",
     "Resumen general del negocio: metricas clave, contenido pendiente, estado de conexiones, alertas.",
     {
-      brandId: import_zod14.z.string().optional().describe("ID de la brand. Si no se pasa, usa la brand del contexto.")
+      brandId: import_zod26.z.string().optional().describe("ID de la brand. Si no se pasa, usa la brand del contexto.")
     },
     async ({ brandId: inputBrandId }) => {
       const tenantId = session.requireTenant();
       const brandId = inputBrandId ?? session.brandId;
-      const config = await readDoc("marketing_config", tenantId);
-      if (!config) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: "No hay marketing_config para este tenant" }) }] };
-      }
-      const brands = config.brands ?? {};
       if (!brandId) {
-        const brandList = Object.entries(brands).map(([id, b]) => ({
-          id,
+        const brandsList = await queryByTenant(session, `tenants/${tenantId}/marketing_config`);
+        if (brandsList.length === 0) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: "No hay marketing_config para este tenant" }) }] };
+        }
+        const brandListSummary = brandsList.map((b) => ({
+          id: b.id,
           nombre: b.nombre,
           dominio: b.dominio
         }));
@@ -2028,13 +2565,13 @@ function registerCoreTools(server, session) {
             type: "text",
             text: JSON.stringify({
               mensaje: "No hay brand seleccionada. Brands disponibles:",
-              brands: brandList,
+              brands: brandListSummary,
               instruccion: "Usa set_context o pasa brandId al tool."
             })
           }]
         };
       }
-      const brand = brands[brandId];
+      const brand = await readDoc(`tenants/${tenantId}/marketing_config`, brandId);
       if (!brand) {
         return { content: [{ type: "text", text: JSON.stringify({ error: `Brand "${brandId}" no existe` }) }] };
       }
@@ -2084,7 +2621,7 @@ function registerCoreTools(server, session) {
     "get_pending_actions",
     "Lista todo lo que necesita atencion: contenido por aprobar, fotos sin procesar.",
     {
-      brandId: import_zod14.z.string().optional().describe("ID de la brand")
+      brandId: import_zod26.z.string().optional().describe("ID de la brand")
     },
     async ({ brandId: inputBrandId }) => {
       const tenantId = session.requireTenant();
@@ -2099,9 +2636,7 @@ function registerCoreTools(server, session) {
           { field: "estado", op: "==", value: ESTADO_FOTO.NUEVA }
         ])
       ]);
-      const config = await readDoc("marketing_config", tenantId);
-      const brands = config?.brands ?? {};
-      const brand = brands[brandId];
+      const brand = await readDoc(`tenants/${tenantId}/marketing_config`, brandId);
       const seo = brand?.seoSnapshot;
       const result = {
         contenidoPorAprobar: contenidoPendiente.map((c) => ({
@@ -2128,9 +2663,9 @@ function registerCoreTools(server, session) {
     "execute_action",
     "Ejecuta una accion sobre contenido o foto: aprobar, rechazar, descartar foto, usar foto tal cual.",
     {
-      accion: import_zod14.z.enum(["aprobar", "rechazar", "descartar_foto", "usar_foto_tal_cual"]).describe("Accion a ejecutar"),
-      targetId: import_zod14.z.string().describe("ID del contenido o foto"),
-      motivo: import_zod14.z.string().optional().describe("Motivo del rechazo (requerido para rechazar)")
+      accion: import_zod26.z.enum(["aprobar", "rechazar", "descartar_foto", "usar_foto_tal_cual"]).describe("Accion a ejecutar"),
+      targetId: import_zod26.z.string().describe("ID del contenido o foto"),
+      motivo: import_zod26.z.string().optional().describe("Motivo del rechazo (requerido para rechazar)")
     },
     async ({ accion, targetId, motivo }) => {
       session.requireTenant();
@@ -2191,17 +2726,31 @@ function registerCoreTools(server, session) {
 }
 
 // src/tools/marketing.ts
-var import_zod17 = require("zod");
+var import_zod37 = require("zod");
 
 // ../packages/marketing-business-logic/dist/index.js
 var import_firebase_admin2 = require("firebase-admin");
 var import_firebase_admin3 = require("firebase-admin");
+var import_zod27 = require("zod");
+var import_zod28 = require("zod");
+var import_zod29 = require("zod");
 var import_firebase_admin4 = require("firebase-admin");
 var import_firebase_admin5 = require("firebase-admin");
 var import_firebase_admin6 = require("firebase-admin");
+var import_zod30 = require("zod");
+var import_zod31 = require("zod");
 var import_firebase_admin7 = require("firebase-admin");
+var import_zod32 = require("zod");
 var import_firebase_admin8 = require("firebase-admin");
 var import_firebase_admin9 = require("firebase-admin");
+var import_firestore3 = require("firebase-admin/firestore");
+var import_firestore4 = require("firebase-admin/firestore");
+var import_firestore5 = require("firebase-admin/firestore");
+var import_firestore6 = require("firebase-admin/firestore");
+var import_zod33 = require("zod");
+var import_firestore7 = require("firebase-admin/firestore");
+var import_zod34 = require("zod");
+var import_firestore8 = require("firebase-admin/firestore");
 var RULE_NEGATIVES = {
   allowFaces: "no people, no faces, no hands",
   allowProductTransform: "no distorted products, no warped objects",
@@ -2351,14 +2900,9 @@ async function brandBriefWriter(input) {
       hint: "Revisa el ejemplo y corrige el campo indicado en path. Manda objeto/array nativo, NO string JSON."
     };
   }
-  const configRef = db.collection("marketing_config").doc(tenantId);
-  const configSnap = await configRef.get();
-  if (!configSnap.exists) {
-    return { ok: false, error: "No hay marketing_config" };
-  }
-  const config = configSnap.data();
-  const brands = config?.brands ?? {};
-  if (!brands[brandId]) {
+  const brandRef = db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId);
+  const brandSnap = await brandRef.get();
+  if (!brandSnap.exists) {
     return { ok: false, error: `Brand "${brandId}" no encontrada` };
   }
   const brief = validation.parsed;
@@ -2370,10 +2914,14 @@ async function brandBriefWriter(input) {
     validadoAt: null,
     _validatedFields: brief._validatedFields ?? {}
   };
-  await configRef.update({
-    [`brands.${brandId}.brandBrief`]: briefWithMeta,
+  await brandRef.set({
+    brandBrief: briefWithMeta,
+    id: brandId,
+    brandId,
+    tenantId,
+    schemaVersion: 1,
     updatedAt: import_firebase_admin2.firestore.FieldValue.serverTimestamp()
-  });
+  }, { merge: true });
   return {
     ok: true,
     mensaje: `Brand Brief guardado para "${brandId}". El tenant puede validar los campos en Config > Mi Negocio.`
@@ -2381,14 +2929,9 @@ async function brandBriefWriter(input) {
 }
 async function save(input) {
   const { db, tenantId, brandId, plan } = input;
-  const configRef = db.collection("marketing_config").doc(tenantId);
-  const configSnap = await configRef.get();
-  if (!configSnap.exists) {
-    return { ok: false, error: "No hay marketing_config" };
-  }
-  const config = configSnap.data();
-  const brands = config.brands ?? {};
-  if (!brands[brandId]) {
+  const brandRef = db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId);
+  const brandSnap = await brandRef.get();
+  if (!brandSnap.exists) {
     return { ok: false, error: `Brand "${brandId}" no encontrada` };
   }
   const { blogStrategy, ...planSinBlogStrategy } = plan;
@@ -2397,18 +2940,15 @@ async function save(input) {
     fechaCreacion: (/* @__PURE__ */ new Date()).toISOString(),
     creadoPorId: "mcp-cowork"
   };
-  const updatedBrands = { ...brands };
-  updatedBrands[brandId] = {
-    ...brands[brandId],
+  await brandRef.set({
     plan: planWithMeta,
-    ...blogStrategy ? { blogStrategy } : {}
-  };
-  await configRef.set({
-    id: config.id,
+    ...blogStrategy ? { blogStrategy } : {},
+    id: brandId,
+    brandId,
     tenantId,
-    brands: updatedBrands,
+    schemaVersion: 1,
     updatedAt: import_firebase_admin3.firestore.FieldValue.serverTimestamp()
-  });
+  }, { merge: true });
   return {
     ok: true,
     mensaje: `Plan de marketing guardado para brand "${brandId}"` + (blogStrategy ? " (incluye blogStrategy)" : "")
@@ -2416,16 +2956,12 @@ async function save(input) {
 }
 async function updateField(input) {
   const { db, tenantId, brandId, field, value } = input;
-  const configRef = db.collection("marketing_config").doc(tenantId);
-  const configSnap = await configRef.get();
-  if (!configSnap.exists) {
-    return { ok: false, error: "No hay marketing_config" };
-  }
-  const config = configSnap.data();
-  const brands = config.brands ?? {};
-  if (!brands[brandId]) {
+  const brandRef = db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId);
+  const brandSnap = await brandRef.get();
+  if (!brandSnap.exists) {
     return { ok: false, error: `Brand "${brandId}" no encontrada` };
   }
+  const brandData = brandSnap.data();
   let parsedValue = value;
   if (typeof value === "string") {
     const trimmed = value.trim();
@@ -2448,27 +2984,24 @@ async function updateField(input) {
       hint: "Manda el valor como objeto/array nativo, NO como string JSON. Usa el ejemplo arriba como referencia exacta del shape esperado."
     };
   }
-  const updatedBrands = { ...brands };
+  const updatePayload = {
+    id: brandId,
+    brandId,
+    tenantId,
+    schemaVersion: 1,
+    updatedAt: import_firebase_admin3.firestore.FieldValue.serverTimestamp()
+  };
   if (field === "blogStrategy") {
-    updatedBrands[brandId] = {
-      ...brands[brandId],
-      blogStrategy: validation.parsed
-    };
+    updatePayload.blogStrategy = validation.parsed;
   } else {
-    const currentPlan = brands[brandId].plan ?? {};
-    const updatedPlan = {
+    const currentPlan = brandData.plan ?? {};
+    updatePayload.plan = {
       ...currentPlan,
       [field]: validation.parsed,
       updatedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    updatedBrands[brandId] = { ...brands[brandId], plan: updatedPlan };
   }
-  await configRef.set({
-    id: config.id,
-    tenantId,
-    brands: updatedBrands,
-    updatedAt: import_firebase_admin3.firestore.FieldValue.serverTimestamp()
-  });
+  await brandRef.set(updatePayload, { merge: true });
   return {
     ok: true,
     mensaje: `Campo "${field}" actualizado en el plan de "${brandId}"`
@@ -2478,6 +3011,225 @@ var planWriter = {
   save,
   updateField
 };
+var DisabledReasonCodeSchema = import_zod29.z.enum([
+  "paywall",
+  // Acción requiere upgrade de plan
+  "oauth_missing",
+  // Falta conectar servicio externo (Shopify, GBP, etc.)
+  "data_missing",
+  // Falta información necesaria (brand brief, foto, etc.)
+  "plan_not_includes",
+  // Plan actual no incluye la feature
+  "feature_disabled",
+  // Feature deshabilitada admin-side para este tenant
+  "other"
+  // Caso explícito fuera del enum. Detail obligatorio.
+]);
+var DisabledOutputSchema = import_zod29.z.object({
+  disabled: import_zod29.z.literal(true),
+  code: DisabledReasonCodeSchema,
+  /**
+   * Variables para interpolar en el template del mensaje (`{key}` → value).
+   * Ejemplo: { service: 'Shopify' } para `oauth_missing`.
+   * Para `other`, requiere al menos { detail: '...' } para que el template
+   * '{detail}' interpole.
+   */
+  detail: import_zod29.z.record(import_zod29.z.string(), import_zod29.z.string()).optional()
+});
+var TEMPLATES = {
+  es: {
+    paywall: "Esta acci\xF3n requiere actualizar tu plan.",
+    oauth_missing: "Necesitas conectar {service} primero.",
+    data_missing: "Falta informaci\xF3n: {detail}",
+    plan_not_includes: "Tu plan no incluye {feature}",
+    feature_disabled: "Esta funci\xF3n est\xE1 deshabilitada para tu cuenta.",
+    other: "{detail}"
+  },
+  en: {
+    paywall: "This action requires upgrading your plan.",
+    oauth_missing: "You need to connect {service} first.",
+    data_missing: "Missing information: {detail}",
+    plan_not_includes: "Your plan doesn't include {feature}",
+    feature_disabled: "This feature is disabled for your account.",
+    other: "{detail}"
+  }
+};
+function getDisabledMessage(code, locale, vars) {
+  if (!(locale in TEMPLATES)) {
+    throw new Error(
+      `Locale '${locale}' no soportado en disabledMessages. Locales activos: ${Object.keys(TEMPLATES).join(", ")}.`
+    );
+  }
+  const template = TEMPLATES[locale][code];
+  if (!template) {
+    throw new Error(
+      `Disabled code '${code}' no tiene template definido para locale '${locale}'.`
+    );
+  }
+  return template.replace(/\{(\w+)\}/g, (_match, key) => {
+    if (!vars || !(key in vars)) {
+      throw new Error(
+        `getDisabledMessage: variable '${key}' del template '${code}' (${locale}) no provista en vars. Helper debe pasar { ${key}: '...' } en detail.`
+      );
+    }
+    return vars[key];
+  });
+}
+var SideEffectEnum = import_zod28.z.enum([
+  "reads_firestore",
+  "writes_firestore",
+  "updates_calendar_slot",
+  "updates_brand_config",
+  "modifies_quota_state",
+  "spends_credits",
+  "consumes_ai_tokens",
+  "sends_email",
+  "publishes_external"
+]);
+var WRITER_EFFECTS = [
+  "writes_firestore",
+  "updates_calendar_slot",
+  "updates_brand_config",
+  "modifies_quota_state",
+  "publishes_external"
+];
+var SummaryTemplateSchema = import_zod28.z.custom((val) => typeof val === "function", {
+  message: "martinSummaryTemplate debe ser funci\xF3n (input, output, locale) => string"
+});
+var ConfirmationTemplateSchema = import_zod28.z.custom((val) => typeof val === "function", {
+  message: "martinConfirmationTemplate debe ser funci\xF3n (input, locale) => string"
+});
+var ExtractTargetPathSchema = import_zod28.z.custom((val) => typeof val === "function", {
+  message: "extractTargetPath debe ser funci\xF3n (input, output) => string"
+});
+var ExtractChangesSchema = import_zod28.z.custom((val) => typeof val === "function", {
+  message: "extractChanges debe ser funci\xF3n (input, output) => { before, after }"
+});
+var MartinContractSchema = import_zod28.z.object({
+  // Schema versioning (Dim 4 backbone)
+  schemaVersion: import_zod28.z.literal(1).default(1),
+  // Identidad
+  name: import_zod28.z.string().min(1).regex(/^[a-z][a-z0-9_]*$/, "snake_case requerido (ej: descartar_contenido)"),
+  description: import_zod28.z.string().min(10),
+  // Validación I/O del helper
+  paramsSchema: import_zod28.z.instanceof(import_zod28.z.ZodType),
+  outputSchema: import_zod28.z.instanceof(import_zod28.z.ZodType),
+  // Reglas de comportamiento
+  requiresConfirmation: import_zod28.z.boolean(),
+  requiresDoubleConfirmation: import_zod28.z.boolean().optional(),
+  destructive: import_zod28.z.boolean(),
+  affectsPublication: import_zod28.z.boolean(),
+  affectsExternal: import_zod28.z.boolean(),
+  // Presentación al usuario (i18n)
+  martinSummaryTemplate: SummaryTemplateSchema,
+  martinConfirmationTemplate: ConfirmationTemplateSchema.optional(),
+  // Auditoría
+  auditAction: import_zod28.z.string().regex(/^[a-z][a-z0-9_]*\.[a-z][a-z0-9_.]*$/, "formato dominio.accion (ej: contenido.descartar)"),
+  extractTargetPath: ExtractTargetPathSchema.optional(),
+  extractChanges: ExtractChangesSchema.optional(),
+  // Governance
+  quotasConsumed: import_zod28.z.array(import_zod28.z.string()),
+  requiredRoles: import_zod28.z.array(import_zod28.z.string()).min(1),
+  sideEffects: import_zod28.z.array(SideEffectEnum),
+  // Disabled state declaration (HITO 6).
+  // Si el helper PUEDE retornar { disabled: true, code }, el author
+  // declara aquí los códigos posibles. El wrapper valida en runtime
+  // que el code retornado por el helper esté declarado — si no, throws.
+  // Sin esto declarado, el wrapper trata cualquier code como inválido.
+  disabledReasonCodes: import_zod28.z.array(DisabledReasonCodeSchema).optional()
+}).superRefine((contract, ctx) => {
+  const isWriter = contract.sideEffects.some((e) => WRITER_EFFECTS.includes(e));
+  if (isWriter && !contract.extractTargetPath) {
+    ctx.addIssue({
+      code: "custom",
+      message: `Contract "${contract.name}" tiene side effects de escritura \u2014 extractTargetPath es obligatorio`,
+      path: ["extractTargetPath"]
+    });
+  }
+  if (isWriter && !contract.extractChanges) {
+    ctx.addIssue({
+      code: "custom",
+      message: `Contract "${contract.name}" tiene side effects de escritura \u2014 extractChanges es obligatorio`,
+      path: ["extractChanges"]
+    });
+  }
+  if (contract.requiresConfirmation && !contract.martinConfirmationTemplate) {
+    ctx.addIssue({
+      code: "custom",
+      message: `Contract "${contract.name}" requiere confirmaci\xF3n \u2014 martinConfirmationTemplate es obligatorio`,
+      path: ["martinConfirmationTemplate"]
+    });
+  }
+  if (contract.requiresDoubleConfirmation && !contract.requiresConfirmation) {
+    ctx.addIssue({
+      code: "custom",
+      message: `Contract "${contract.name}" requiere doble confirmaci\xF3n pero requiresConfirmation es false`,
+      path: ["requiresDoubleConfirmation"]
+    });
+  }
+  if (contract.destructive && !contract.requiresConfirmation) {
+    ctx.addIssue({
+      code: "custom",
+      message: `Contract "${contract.name}" es destructivo pero NO requiere confirmaci\xF3n`,
+      path: ["requiresConfirmation"]
+    });
+  }
+});
+var ParamsSchema = import_zod27.z.object({
+  tenantId: import_zod27.z.string().min(1),
+  brandId: import_zod27.z.string().min(1),
+  /** Plan completo generado por Claude. Puede incluir blogStrategy. */
+  plan: import_zod27.z.record(import_zod27.z.string(), import_zod27.z.unknown())
+});
+var OutputSchema = import_zod27.z.discriminatedUnion("ok", [
+  import_zod27.z.object({
+    ok: import_zod27.z.literal(true),
+    mensaje: import_zod27.z.string()
+  }),
+  import_zod27.z.object({
+    ok: import_zod27.z.literal(false),
+    error: import_zod27.z.string(),
+    detalle: import_zod27.z.unknown().optional(),
+    path: import_zod27.z.string().optional(),
+    recibido: import_zod27.z.unknown().optional(),
+    ejemplo_correcto: import_zod27.z.unknown().optional(),
+    hint: import_zod27.z.string().optional()
+  })
+]);
+var rawContract = {
+  name: "save_marketing_plan",
+  description: "Guarda el plan de marketing de una brand. Si el plan incluye blogStrategy, la extrae al nivel brand (no dentro de plan).",
+  paramsSchema: ParamsSchema,
+  outputSchema: OutputSchema,
+  // No es destructivo (sobrescribe plan completo, pero plan se regenera fácil),
+  // no afecta publicación, no llama externo.
+  requiresConfirmation: false,
+  destructive: false,
+  affectsPublication: false,
+  affectsExternal: false,
+  martinSummaryTemplate: (input, output, locale) => {
+    if (!output.ok) {
+      if (locale === "en") return `I couldn't save the plan: ${output.error}`;
+      return `No pude guardar el plan: ${output.error}`;
+    }
+    if (locale === "en") return `I saved the marketing plan for ${input.brandId}.`;
+    return `Guard\xE9 el plan de marketing de ${input.brandId}.`;
+  },
+  // Auditoría — OBLIGATORIO porque writes_firestore + updates_brand_config.
+  auditAction: "marketing.plan.guardar",
+  extractTargetPath: (input) => `tenants/${input.tenantId}/marketing_config/${input.brandId}`,
+  extractChanges: (input, output) => ({
+    before: null,
+    // El helper no lee el plan previo en save (solo merge).
+    after: output.ok ? { plan: input.plan } : null
+  }),
+  quotasConsumed: [],
+  requiredRoles: ["admin", "encargado"],
+  sideEffects: ["writes_firestore", "updates_brand_config"]
+};
+var planWriterSaveContract = MartinContractSchema.parse(
+  rawContract
+);
 async function collectionSuggestionsWriter(input) {
   const { db, tenantId, brandId, suggestions } = input;
   const validation = validateCollectionSuggestions(suggestions);
@@ -2493,18 +3245,13 @@ async function collectionSuggestionsWriter(input) {
     };
   }
   const validSuggestions = validation.parsed;
-  const configRef = db.collection("marketing_config").doc(tenantId);
-  const configSnap = await configRef.get();
-  if (!configSnap.exists) {
-    return { ok: false, error: "marketing_config no existe" };
-  }
-  const config = configSnap.data();
-  const brands = config.brands ?? {};
-  const brand = brands[brandId];
-  if (!brand) {
+  const brandRef = db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId);
+  const brandSnap = await brandRef.get();
+  if (!brandSnap.exists) {
     return { ok: false, error: `Brand ${brandId} no encontrada` };
   }
-  const existing = brand.collectionSuggestions ?? {};
+  const brandData = brandSnap.data();
+  const existing = brandData.collectionSuggestions ?? {};
   const updated = { ...existing };
   for (const s of validSuggestions) {
     const id = String(s.collectionId);
@@ -2522,9 +3269,14 @@ async function collectionSuggestionsWriter(input) {
       generadoPor: "mcp-cowork"
     };
   }
-  await configRef.update({
-    [`brands.${brandId}.collectionSuggestions`]: updated
-  });
+  await brandRef.set({
+    collectionSuggestions: updated,
+    id: brandId,
+    brandId,
+    tenantId,
+    schemaVersion: 1,
+    updatedAt: import_firebase_admin4.firestore.FieldValue.serverTimestamp()
+  }, { merge: true });
   return {
     ok: true,
     saved: validSuggestions.length,
@@ -2631,7 +3383,7 @@ async function contenidoUpdater(input) {
     estado,
     calendarioItemRef
   } = input;
-  const docRef = db.collection("marketing_contenido").doc(contenidoId);
+  const docRef = db.doc(`tenants/${tenantId}/marketing_contenido/${contenidoId}`);
   const snap = await docRef.get();
   if (!snap.exists) {
     return { ok: false, error: `Contenido ${contenidoId} no existe` };
@@ -2691,12 +3443,29 @@ async function contenidoUpdater(input) {
   };
 }
 var CAMPOS_SEMANTICOS = ["keyword", "tema", "plataforma", "tipo"];
+function mapContenidoEstadoToSlotEstado(contenidoEstado) {
+  switch (contenidoEstado) {
+    case "pendiente_aprobacion":
+    case "generado":
+    case "editado":
+      return "generado";
+    case "aprobado":
+      return "aprobado";
+    case "publicado":
+      return "publicado";
+    case "rechazado":
+      return "rechazado";
+    // borrador + error_publicacion + estados desconocidos → no tocar slot
+    default:
+      return null;
+  }
+}
 async function calendarSlotUpdater(input) {
   const { db, tenantId, brandId, mes, semana, slotIndex, cambios, accionContenidoExistente } = input;
   if (slotIndex < 0) {
     return { ok: false, error: "slotIndex no puede ser negativo" };
   }
-  const calQuery = await db.collection("marketing_calendario").where("tenantId", "==", tenantId).where("brandId", "==", brandId).where("mes", "==", mes).limit(1).get();
+  const calQuery = await db.collection("tenants").doc(tenantId).collection("marketing_calendario").where("brandId", "==", brandId).where("mes", "==", mes).limit(1).get();
   if (calQuery.empty) {
     return { ok: false, error: "Calendario no encontrado" };
   }
@@ -2733,7 +3502,7 @@ async function calendarSlotUpdater(input) {
   }
   let contenidosADescartar = [];
   if (oldContenidoRef && (accionContenidoExistente === "descartar" || !tocaSemantica)) {
-    const contenidoQuery = await db.collection("marketing_contenido").where("tenantId", "==", tenantId).where("brandId", "==", brandId).where("calendarioItemRef", "==", oldContenidoRef).limit(10).get();
+    const contenidoQuery = await db.collection("tenants").doc(tenantId).collection("marketing_contenido").where("brandId", "==", brandId).where("calendarioItemRef", "==", oldContenidoRef).limit(10).get();
     contenidosADescartar = contenidoQuery.docs.filter((c) => {
       const data = c.data();
       return data.estado !== "descartado" && data.estado !== ESTADO_CONTENIDO.PUBLICADO;
@@ -2790,6 +3559,18 @@ async function calendarSlotUpdater(input) {
       targetRef: `semana:${targetSemanaNum}:slot:${targetSlotIdx}`
     };
   }
+  let movedSlotEstado = null;
+  if (moveTarget && oldContenidoRef) {
+    try {
+      const contenidoSnap = await db.doc(`tenants/${tenantId}/marketing_contenido/${oldContenidoRef}`).get();
+      if (contenidoSnap.exists) {
+        const estadoContenido = contenidoSnap.data().estado;
+        movedSlotEstado = mapContenidoEstadoToSlotEstado(estadoContenido);
+      }
+    } catch {
+      movedSlotEstado = null;
+    }
+  }
   let resultAction;
   let resultSlotIndex = slotIndex;
   let movedTo;
@@ -2825,10 +3606,14 @@ async function calendarSlotUpdater(input) {
       };
       const targetSemana = freshSemanas[moveTarget.targetSemanaNum - 1];
       const targetItems = targetSemana.items ?? [];
+      const targetSlotActual = targetItems[moveTarget.targetSlotIdx];
+      const targetEstadoActual = targetSlotActual.estado;
+      const shouldUpdateEstado = movedSlotEstado !== null && targetEstadoActual !== "publicado";
       targetItems[moveTarget.targetSlotIdx] = {
-        ...targetItems[moveTarget.targetSlotIdx],
+        ...targetSlotActual,
         contenidoRef: oldContenidoRef,
-        ...oldFotoIdAsignada ? { fotoIdAsignada: oldFotoIdAsignada } : {}
+        ...oldFotoIdAsignada ? { fotoIdAsignada: oldFotoIdAsignada } : {},
+        ...shouldUpdateEstado ? { estado: movedSlotEstado } : {}
       };
       targetSemana.items = targetItems;
       freshSemanas[moveTarget.targetSemanaNum - 1] = targetSemana;
@@ -2850,7 +3635,7 @@ async function calendarSlotUpdater(input) {
   });
   if (moveTarget && oldContenidoRef) {
     try {
-      await db.collection("marketing_contenido").doc(oldContenidoRef).update({
+      await db.doc(`tenants/${tenantId}/marketing_contenido/${oldContenidoRef}`).update({
         calendarioItemRef: moveTarget.targetRef
       });
     } catch (err) {
@@ -2949,6 +3734,134 @@ async function handleNuevoSlot(args) {
     descartados: 0
   };
 }
+var ParamsSchema2 = import_zod30.z.object({
+  tenantId: import_zod30.z.string().min(1),
+  brandId: import_zod30.z.string().min(1),
+  mes: import_zod30.z.string().regex(/^\d{4}-\d{2}$/, "Formato YYYY-MM"),
+  semana: import_zod30.z.number().int().min(1).max(5),
+  slotIndex: import_zod30.z.number().int().min(0),
+  cambios: import_zod30.z.record(import_zod30.z.string(), import_zod30.z.unknown()),
+  accionContenidoExistente: import_zod30.z.string().optional()
+});
+var OutputSchema2 = import_zod30.z.discriminatedUnion("ok", [
+  import_zod30.z.object({
+    ok: import_zod30.z.literal(true),
+    action: import_zod30.z.enum(["added", "updated", "nuevo_slot", "moved"]),
+    slotIndex: import_zod30.z.number().int(),
+    descartados: import_zod30.z.number().int(),
+    movedTo: import_zod30.z.string().optional()
+  }),
+  import_zod30.z.object({
+    ok: import_zod30.z.literal(false),
+    error: import_zod30.z.string(),
+    code: import_zod30.z.enum(["ACCION_CONTENIDO_EXISTENTE_REQUIRED", "MOVE_TARGET_OCCUPIED", "MOVE_TARGET_INVALID"]).optional(),
+    opciones: import_zod30.z.array(import_zod30.z.string()).optional()
+  })
+]);
+var rawContract2 = {
+  name: "update_calendar_slot",
+  description: "Modifica o agrega un slot del calendario editorial. Si slotIndex >= items.length agrega un slot nuevo. Si el slot ten\xEDa contenidoRef previo y los cambios tocan campos sem\xE1nticos (keyword/tema/plataforma/tipo), exige accionContenidoExistente con 4 opciones: descartar | mover:semana:N:slot:M | nuevo_slot | mantener.",
+  paramsSchema: ParamsSchema2,
+  outputSchema: OutputSchema2,
+  requiresConfirmation: false,
+  destructive: false,
+  // Mutación, pero reversible (puede deshacerse cambiando el slot).
+  affectsPublication: false,
+  affectsExternal: false,
+  martinSummaryTemplate: (input, output, locale) => {
+    if (!output.ok) {
+      if (locale === "en") return `I couldn't update the slot: ${output.error}`;
+      return `No pude actualizar el slot: ${output.error}`;
+    }
+    const verb = {
+      added: locale === "en" ? "added" : "agregu\xE9",
+      updated: locale === "en" ? "updated" : "actualic\xE9",
+      nuevo_slot: locale === "en" ? "created a new slot" : "cre\xE9 un slot nuevo",
+      moved: locale === "en" ? "moved" : "mov\xED"
+    }[output.action];
+    if (locale === "en") {
+      return `I ${verb} the slot in week ${input.semana} (${input.mes}).`;
+    }
+    return `${verb[0].toUpperCase() + verb.slice(1)} el slot en la semana ${input.semana} (${input.mes}).`;
+  },
+  auditAction: "marketing.calendario.slot.actualizar",
+  extractTargetPath: (input) => `tenants/${input.tenantId}/marketing_calendario/(brand=${input.brandId},mes=${input.mes}).semana=${input.semana}.slot=${input.slotIndex}`,
+  extractChanges: (input, output) => ({
+    before: null,
+    // Helper no devuelve estado previo del slot — captura el cambio aplicado.
+    after: output.ok ? {
+      action: output.action,
+      cambios: input.cambios,
+      accionContenidoExistente: input.accionContenidoExistente ?? null,
+      descartados: output.descartados,
+      movedTo: output.movedTo ?? null
+    } : null
+  }),
+  quotasConsumed: [],
+  requiredRoles: ["admin", "encargado"],
+  sideEffects: ["writes_firestore", "updates_calendar_slot"]
+};
+var calendarSlotUpdaterContract = MartinContractSchema.parse(
+  rawContract2
+);
+async function getCalendar(input) {
+  const { db, tenantId, brandId, mes } = input;
+  const snap = await db.collection("tenants").doc(tenantId).collection("marketing_calendario").where("brandId", "==", brandId).where("mes", "==", mes).limit(1).get();
+  if (snap.empty) {
+    return {
+      ok: true,
+      mes,
+      brandId,
+      calendario: null,
+      mensaje: "No hay calendario para este mes. Genera un plan de marketing primero."
+    };
+  }
+  const doc = snap.docs[0];
+  return {
+    ok: true,
+    mes,
+    brandId,
+    calendario: { id: doc.id, ...doc.data() }
+  };
+}
+var ParamsSchema3 = import_zod31.z.object({
+  tenantId: import_zod31.z.string().min(1),
+  brandId: import_zod31.z.string().min(1),
+  mes: import_zod31.z.string().regex(/^\d{4}-\d{2}$/, "Formato YYYY-MM")
+});
+var OutputSchema3 = import_zod31.z.object({
+  ok: import_zod31.z.literal(true),
+  mes: import_zod31.z.string(),
+  brandId: import_zod31.z.string(),
+  calendario: import_zod31.z.record(import_zod31.z.string(), import_zod31.z.unknown()).nullable(),
+  mensaje: import_zod31.z.string().optional()
+});
+var rawContract3 = {
+  name: "get_calendar",
+  description: "Lee el calendario editorial del mes para una brand. Retorna semanas con items planificados por plataforma.",
+  paramsSchema: ParamsSchema3,
+  outputSchema: OutputSchema3,
+  requiresConfirmation: false,
+  destructive: false,
+  affectsPublication: false,
+  affectsExternal: false,
+  martinSummaryTemplate: (input, output, locale) => {
+    if (!output.calendario) {
+      if (locale === "en") return `No calendar for ${output.mes}.`;
+      return `No hay calendario para ${output.mes}.`;
+    }
+    if (locale === "en") return `Here's the ${output.mes} calendar for ${input.brandId}.`;
+    return `Aqu\xED est\xE1 el calendario de ${output.mes} para ${input.brandId}.`;
+  },
+  // AUDITA SIEMPRE — regla A5. Lectura no muta, changes son null/null.
+  auditAction: "marketing.calendario.leer",
+  quotasConsumed: [],
+  requiredRoles: ["admin", "encargado", "empleado"],
+  sideEffects: ["reads_firestore"]
+};
+var getCalendarContract = MartinContractSchema.parse(
+  rawContract3
+);
 var PLATAFORMA_A_FORMATO = {
   gbp: "gbp_4_3",
   shopify_blog: "blog_3_2",
@@ -2957,7 +3870,7 @@ var PLATAFORMA_A_FORMATO = {
 };
 async function photoAssigner(input) {
   const { db, tenantId, brandId, contenidoRef, fotoId, calendarioItemRef } = input;
-  const contenidoRefDoc = db.collection("marketing_contenido").doc(contenidoRef);
+  const contenidoRefDoc = db.doc(`tenants/${tenantId}/marketing_contenido/${contenidoRef}`);
   const contenidoSnap = await contenidoRefDoc.get();
   if (!contenidoSnap.exists) {
     return { ok: false, error: `Contenido ${contenidoRef} no encontrado` };
@@ -2966,7 +3879,7 @@ async function photoAssigner(input) {
   if (contenido.tenantId !== tenantId) {
     return { ok: false, error: "Contenido no pertenece a este tenant" };
   }
-  const fotoQuery = await db.collection("marketing_fotos").where("tenantId", "==", tenantId).where("id", "==", fotoId).limit(1).get();
+  const fotoQuery = await db.collection("tenants").doc(tenantId).collection("marketing_fotos").where("id", "==", fotoId).limit(1).get();
   if (fotoQuery.empty) {
     return { ok: false, error: `Foto ${fotoId} no encontrada` };
   }
@@ -2998,7 +3911,7 @@ async function photoAssigner(input) {
     if (match) {
       const semanaNum = parseInt(match[1], 10);
       const slotIdx = parseInt(match[2], 10);
-      const calQuery = await db.collection("marketing_calendario").where("tenantId", "==", tenantId).where("brandId", "==", brandId).limit(12).get();
+      const calQuery = await db.collection("tenants").doc(tenantId).collection("marketing_calendario").where("brandId", "==", brandId).limit(12).get();
       for (const calDoc of calQuery.docs) {
         const cal = calDoc.data();
         const semanas = cal.semanas ?? [];
@@ -3055,101 +3968,87 @@ async function photoAssigner(input) {
     formato
   };
 }
-async function resolveLastImportId(db, tenantId, brandId) {
-  const configSnap = await db.collection("marketing_config").doc(tenantId).get();
-  const config = configSnap.data();
-  const brands = config?.brands ?? {};
-  const brand = brands[brandId];
-  const canalId = brand?.canalId;
-  if (!canalId) return null;
-  const canalSnap = await db.collection("canales_venta").doc(canalId).get();
-  const canal = canalSnap.data();
-  const app = canal?.app ?? {};
-  return app.lastImportId ?? null;
+function findPageByHeuristic(pages, pattern) {
+  return pages.find((p) => pattern.test(p.title || "")) || pages.find((p) => pattern.test(p.handle || "")) || null;
 }
+var ABOUT_PATTERN = /about|nosotros|sobre|quien|historia|story|filosof|esencia/i;
+var FAQ_PATTERN = /faq|preguntas|frecuent|frequent|questions|ayuda|soporte/i;
 async function brandBriefBuilder(input) {
   const { db, tenantId, brandId } = input;
-  const configSnap = await db.collection("marketing_config").doc(tenantId).get();
+  const configSnap = await db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId).get();
   if (!configSnap.exists) {
-    return { ok: false, error: "No hay marketing_config" };
-  }
-  const config = configSnap.data();
-  const brands = config.brands ?? {};
-  const brand = brands[brandId];
-  if (!brand) {
     return { ok: false, error: `Brand "${brandId}" no encontrada` };
   }
-  const [lastImportId, tenantSnap] = await Promise.all([
-    resolveLastImportId(db, tenantId, brandId),
+  const brand = configSnap.data();
+  const [snapshotMetaSnap, productsSnap, collectionsSnap, pagesSnap, siteMetaSnap, tenantSnap] = await Promise.all([
+    db.doc(`tenants/${tenantId}/marketing_snapshots/${brandId}`).get().catch(() => null),
+    db.collection(`tenants/${tenantId}/marketing_snapshots/${brandId}/products`).get().catch(() => null),
+    db.collection(`tenants/${tenantId}/marketing_snapshots/${brandId}/collections`).get().catch(() => null),
+    db.collection(`tenants/${tenantId}/marketing_snapshots/${brandId}/pages`).get().catch(() => null),
+    db.doc(`tenants/${tenantId}/marketing_site_meta/${brandId}`).get().catch(() => null),
     db.collection("tenants").doc(tenantId).get()
   ]);
   const tenantDoc = tenantSnap.data();
-  let shopProducts = [];
-  let shopCollections = [];
-  let shopOrders = null;
-  let shopInfo = null;
-  if (lastImportId) {
-    const basePath = `tenants/${tenantId}/shopify_imports/${lastImportId}/data`;
-    const [prodSnap, colSnap, ordSnap, infoSnap] = await Promise.all([
-      db.doc(`${basePath}/products`).get().catch(() => null),
-      db.doc(`${basePath}/collections`).get().catch(() => null),
-      db.doc(`${basePath}/orders_summary`).get().catch(() => null),
-      db.doc(`${basePath}/shop_info`).get().catch(() => null)
-    ]);
-    const prodDoc = prodSnap?.exists ? prodSnap.data() : null;
-    const colDoc = colSnap?.exists ? colSnap.data() : null;
-    const ordDoc = ordSnap?.exists ? ordSnap.data() : null;
-    const infoDoc = infoSnap?.exists ? infoSnap.data() : null;
-    shopProducts = (prodDoc?.items ?? []).map((p) => ({
+  const snapshotMeta = snapshotMetaSnap?.exists ? snapshotMetaSnap.data() : null;
+  const lastImportId = snapshotMeta?.lastImportId || null;
+  const shopInfo = snapshotMeta?.shopInfo || null;
+  const ordersSummary = snapshotMeta?.ordersSummary || null;
+  const shopOrders = ordersSummary ? {
+    totalOrders: ordersSummary.totalOrders,
+    averageOrderValue: ordersSummary.avgOrderValue,
+    ordersPerDay: ordersSummary.ordersPerDay,
+    totalRevenue: ordersSummary.totalRevenue,
+    topSkus: ordersSummary.topSkus,
+    dateRange: ordersSummary.dateRange
+  } : null;
+  const shopProducts = (productsSnap?.docs || []).map((doc) => {
+    const p = doc.data();
+    const firstVariant = p.variants?.[0];
+    const firstVariantPrice = firstVariant?.price?.amount;
+    return {
       title: p.title,
-      product_type: p.product_type,
-      tags: p.tags,
-      price_min: p.price_min ?? p.variants?.[0]?.price,
-      price_max: p.price_max,
-      status: p.status
-    }));
-    shopCollections = (colDoc?.items ?? []).map((c) => ({
-      id: c.id,
+      product_type: p.productType,
+      tags: Array.isArray(p.tags) ? p.tags.join(", ") : p.tags,
+      price_min: p.price?.amount ?? firstVariantPrice ?? null,
+      price_max: null,
+      // canonical no tiene price_max separado, derivable de variants si necesita
+      status: p.available !== false ? "active" : "draft"
+    };
+  });
+  const shopCollections = (collectionsSnap?.docs || []).map((doc) => {
+    const c = doc.data();
+    return {
+      id: c.platformId,
       title: c.title,
       handle: c.handle,
-      products_count: c.products_count,
-      collectionType: c.collectionType
-    }));
-    shopOrders = ordDoc ? {
-      totalOrders: ordDoc.totalOrders,
-      averageOrderValue: ordDoc.averageOrderValue,
-      topProducts: ordDoc.topProducts,
-      repeatRate: ordDoc.repeatRate,
-      currency: ordDoc.currency
-    } : null;
-    shopInfo = infoDoc ? {
-      name: infoDoc.name,
-      domain: infoDoc.domain,
-      myshopifyDomain: infoDoc.myshopifyDomain,
-      country: infoDoc.country,
-      currency: infoDoc.currency,
-      timezone: infoDoc.timezone,
-      plan: infoDoc.plan_name ?? infoDoc.plan,
-      languages: infoDoc.languages,
-      shippingZones: infoDoc.shippingZones
-    } : null;
-  }
-  const siteSnap = await db.collection("shopify_site_content").doc(`${tenantId}_${brandId}`).get().catch(() => null);
-  const siteContentDoc = siteSnap?.exists ? siteSnap.data() : null;
-  const sitePages = siteContentDoc?.pages || {};
-  const home = sitePages["/"] || {};
-  const aboutEn = sitePages["/pages/about"] || {};
-  const aboutEs = sitePages["/pages/nosotros"] || {};
-  const faqEn = sitePages["/pages/faq"] || {};
-  const faqEs = sitePages["/pages/preguntas-frecuentes"] || {};
-  const sitePayload = siteContentDoc ? {
-    homeTitle: home.title || null,
-    homeMeta: home.metaDescription || null,
-    homeH1: home.h1 || null,
-    homeOgDescription: home.ogDescription || null,
-    aboutFirstParagraph: aboutEn.firstParagraph || aboutEs.firstParagraph || null,
-    aboutH1: aboutEn.h1 || aboutEs.h1 || null,
-    faqQuestions: faqEn.h2s || faqEs.h2s || null
+      products_count: null,
+      // adapter v2 no calcula products_count por collection todavia
+      collectionType: "canonical"
+    };
+  });
+  const siteMetaDoc = siteMetaSnap?.exists ? siteMetaSnap.data() : null;
+  const homepage = siteMetaDoc?.homepage || null;
+  const extraPagesMeta = siteMetaDoc?.extraPages || {};
+  const allPagesCanonical = (pagesSnap?.docs || []).map((doc) => {
+    const p = doc.data();
+    return {
+      handle: p.handle || "",
+      title: p.title || "",
+      firstParagraph: p.firstParagraph || null,
+      h1: p.extractedHeadings?.h1 || null,
+      h2s: p.extractedHeadings?.h2s || []
+    };
+  });
+  const aboutPage = findPageByHeuristic(allPagesCanonical, ABOUT_PATTERN);
+  const faqPage = findPageByHeuristic(allPagesCanonical, FAQ_PATTERN);
+  const sitePayload = siteMetaDoc || homepage ? {
+    homeTitle: homepage?.title || null,
+    homeMeta: homepage?.metaDescription || null,
+    homeH1: homepage?.h1 || null,
+    homeOgDescription: homepage?.ogDescription || null,
+    aboutFirstParagraph: aboutPage?.firstParagraph || null,
+    aboutH1: aboutPage?.h1 || null,
+    faqQuestions: faqPage?.h2s?.length ? faqPage.h2s : null
   } : null;
   const seo = brand.seoSnapshot;
   const gbpPerfiles = brand.gbpPerfiles ?? [];
@@ -3182,14 +4081,20 @@ async function brandBriefBuilder(input) {
   }
   const topTags = Object.entries(tagCount).sort(([, a], [, b]) => b - a).slice(0, 20).map(([tag, count]) => ({ tag, count }));
   const instruccionBase = `Genera un brandBrief completo para "${brand.nombre ?? brandId}". Pre-llena TODOS los campos bas\xE1ndote en los datos a continuaci\xF3n. El 80% debe ser inferido autom\xE1ticamente. Marca lo que el tenant debe validar. Guarda con save_brand_brief.`;
-  const instruccionSiteContent = sitePayload ? " Tienes site_content REAL scrapeado del sitio en datosDisponibles.sitePayload. Usa: homeMeta y homeOgDescription para descripcionCorta; aboutFirstParagraph para propuestaDeValor (texto real, no inventes); faqQuestions para inferir mensajesClave y dudas frecuentes; aboutH1 para inferir tono y posicionamiento. Si algun campo es null, infierelo de Shopify + GBP." : ' No hay site_content disponible (sitePayload es null). Recomienda al tenant correr "Sincronizar Shopify" con modo full para mejor calidad del brief.';
+  const instruccionSiteContent = sitePayload ? " Tienes site_content REAL scrapeado del sitio en datosDisponibles.sitePayload. Usa: homeMeta y homeOgDescription para descripcionCorta; aboutFirstParagraph para propuestaDeValor (texto real, no inventes); faqQuestions para inferir mensajesClave y dudas frecuentes; aboutH1 para inferir tono y posicionamiento. Si algun campo es null, intenta identificar la pagina correcta en datosDisponibles.availablePages (titles + handles) y usa ese contenido \u2014 la heuristica regex puede haber fallado para un tenant con nombres creativos. Si igual no aparece, infierelo de Shopify + GBP." : ' No hay site_content disponible (sitePayload es null). Recomienda al tenant correr "Sincronizar Shopify" con modo full para mejor calidad del brief.';
+  const availablePages = allPagesCanonical.map((p) => ({
+    handle: p.handle,
+    title: p.title,
+    h1: p.h1
+  }));
   const payload = {
     instruccion: instruccionBase + instruccionSiteContent,
-    _siteContentVersion: siteContentDoc?.importId || null,
+    _lastImportId: lastImportId,
     _schema: BRAND_BRIEF_SCHEMA_HINT,
     datosDisponibles: {
       shopInfo,
       sitePayload,
+      availablePages,
       precioStats,
       productTypes: typeCount,
       topTags,
@@ -3250,11 +4155,51 @@ var BRAND_BRIEF_SCHEMA_HINT = {
     escenas: [{ id: string, nombre: string, promptHint: string }]
   }`
 };
-async function resolveLastImportId2(db, tenantId, brandId) {
-  const configSnap = await db.collection("marketing_config").doc(tenantId).get();
-  const config = configSnap.data();
-  const brands = config?.brands ?? {};
-  const brand = brands[brandId];
+var ParamsSchema4 = import_zod32.z.object({
+  tenantId: import_zod32.z.string().min(1),
+  brandId: import_zod32.z.string().min(1)
+});
+var OutputSchema4 = import_zod32.z.discriminatedUnion("ok", [
+  import_zod32.z.object({
+    ok: import_zod32.z.literal(true),
+    /** Payload con instrucción + datos del negocio para que Claude genere el brief. */
+    payload: import_zod32.z.record(import_zod32.z.string(), import_zod32.z.unknown())
+  }),
+  import_zod32.z.object({
+    ok: import_zod32.z.literal(false),
+    error: import_zod32.z.string()
+  })
+]);
+var rawContract4 = {
+  name: "generate_brand_brief",
+  description: "Prepara los datos del negocio (Shopify, SEO, GBP, site_content scrape, brand config, ubicaciones del tenant) para que el sistema genere un Brand Brief pre-llenado. NO escribe el brief \u2014 s\xF3lo arma el payload.",
+  paramsSchema: ParamsSchema4,
+  outputSchema: OutputSchema4,
+  // Lectura pura, sin side effects de escritura ni publicación.
+  requiresConfirmation: false,
+  destructive: false,
+  affectsPublication: false,
+  affectsExternal: false,
+  martinSummaryTemplate: (_input, output, locale) => {
+    if (!output.ok) {
+      if (locale === "en") return `I couldn't gather the data: ${output.error}`;
+      return `No pude reunir los datos: ${output.error}`;
+    }
+    if (locale === "en") return `I gathered the data for the brief.`;
+    return `Reun\xED los datos para el brief.`;
+  },
+  auditAction: "marketing.brand_brief.preparar",
+  // No extractTargetPath/extractChanges — no es writer.
+  quotasConsumed: [],
+  requiredRoles: ["admin", "encargado"],
+  sideEffects: ["reads_firestore"]
+};
+var brandBriefBuilderContract = MartinContractSchema.parse(
+  rawContract4
+);
+async function resolveLastImportId(db, tenantId, brandId) {
+  const configSnap = await db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId).get();
+  const brand = configSnap.data();
   const canalId = brand?.canalId;
   if (!canalId) return null;
   const canalSnap = await db.collection("canales_venta").doc(canalId).get();
@@ -3264,16 +4209,11 @@ async function resolveLastImportId2(db, tenantId, brandId) {
 }
 async function marketingPlanBuilder(input) {
   const { db, tenantId, brandId } = input;
-  const configSnap = await db.collection("marketing_config").doc(tenantId).get();
+  const configSnap = await db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId).get();
   if (!configSnap.exists) {
-    return { ok: false, error: "No hay marketing_config" };
-  }
-  const config = configSnap.data();
-  const brands = config.brands ?? {};
-  const brand = brands[brandId];
-  if (!brand) {
     return { ok: false, error: `Brand "${brandId}" no encontrada` };
   }
+  const brand = configSnap.data();
   if (!brand.seoSnapshot) {
     return {
       ok: false,
@@ -3282,9 +4222,9 @@ async function marketingPlanBuilder(input) {
   }
   const productosQ = await db.collection("productos").where("tenantId", "==", tenantId).limit(100).get();
   const productos = productosQ.docs.map((d) => d.data());
-  const histQ = await db.collection("marketing_contenido").where("tenantId", "==", tenantId).where("brandId", "==", brandId).where("estado", "==", ESTADO_CONTENIDO.PUBLICADO).limit(20).get();
+  const histQ = await db.collection("tenants").doc(tenantId).collection("marketing_contenido").where("brandId", "==", brandId).where("estado", "==", ESTADO_CONTENIDO.PUBLICADO).limit(20).get();
   const historial = histQ.docs.map((d) => d.data());
-  const lastImportId = await resolveLastImportId2(db, tenantId, brandId);
+  const lastImportId = await resolveLastImportId(db, tenantId, brandId);
   let colecciones = [];
   let shopifyBlogs = [];
   if (lastImportId) {
@@ -3459,13 +4399,11 @@ async function contenidoWriter(input) {
     calendarioItemRef,
     linkPipeline
   } = input;
-  const configSnap = await db.collection("marketing_config").doc(tenantId).get();
-  const config = configSnap.data();
-  const brands = config?.brands ?? {};
-  const brand = brands[brandId];
+  const configSnap = await db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId).get();
+  const brand = configSnap.exists ? configSnap.data() : void 0;
   const frecuencia = brand?.frecuencia ?? {};
   const estadosQueOcupanSlot = ["aprobado", "publicado"];
-  const contenidoQ = await db.collection("marketing_contenido").where("tenantId", "==", tenantId).where("brandId", "==", brandId).where("plataforma", "==", plataforma).limit(100).get();
+  const contenidoQ = await db.collection("tenants").doc(tenantId).collection("marketing_contenido").where("brandId", "==", brandId).where("plataforma", "==", plataforma).limit(100).get();
   const contenidoEstaSemana = contenidoQ.docs.map((d2) => ({ id: d2.id, ...d2.data() }));
   const now = /* @__PURE__ */ new Date();
   const startOfWeek = new Date(now);
@@ -3498,7 +4436,7 @@ async function contenidoWriter(input) {
       (c) => c.calendarioItemRef === calendarioItemRef && c.estado !== "descartado"
     );
     for (const existente of existentes) {
-      await db.collection("marketing_contenido").doc(existente.id).update({
+      await db.doc(`tenants/${tenantId}/marketing_contenido/${existente.id}`).update({
         estado: "descartado",
         rechazadoMotivo: "Reemplazado por contenido nuevo para el mismo slot",
         rechazadoAt: import_firebase_admin8.firestore.FieldValue.serverTimestamp()
@@ -3542,6 +4480,11 @@ async function contenidoWriter(input) {
     }
   }
   const id = buildGenId();
+  if (!languageCode) {
+    throw new Error(
+      `contenidoWriter requiere languageCode expl\xEDcito. Resolver desde brand.idiomas.primario o tenant.idiomaPrincipal antes de invocar.`
+    );
+  }
   const contenido = buildContenido({
     id,
     tenantId,
@@ -3549,7 +4492,7 @@ async function contenidoWriter(input) {
     plataforma,
     tipo: tipo ?? "post",
     keyword: keyword ?? null,
-    languageCode: languageCode ?? "es",
+    languageCode,
     estado: ESTADO_CONTENIDO.PENDIENTE_APROBACION,
     fotoId: fotoId ?? null,
     mediaUrl: null,
@@ -3559,14 +4502,14 @@ async function contenidoWriter(input) {
     creadoPorId: "mcp-cowork",
     origen: "ai_assisted"
   });
-  const contenidoRef = db.collection("marketing_contenido").doc(id);
+  const contenidoRef = db.doc(`tenants/${tenantId}/marketing_contenido/${id}`);
   let slotResolved = null;
   if (calendarioItemRef) {
     const match = calendarioItemRef.match(/^semana:(\d+):slot:(\d+)$/);
     if (match) {
       const semanaNum = parseInt(match[1], 10);
       const slotIdx = parseInt(match[2], 10);
-      const calQ = await db.collection("marketing_calendario").where("tenantId", "==", tenantId).where("brandId", "==", brandId).limit(12).get();
+      const calQ = await db.collection("tenants").doc(tenantId).collection("marketing_calendario").where("brandId", "==", brandId).limit(12).get();
       for (const calDoc of calQ.docs) {
         const cal = calDoc.data();
         const semanas = cal.semanas ?? [];
@@ -3715,14 +4658,12 @@ async function weeklyContentBuilder(input) {
   const now = /* @__PURE__ */ new Date();
   const targetMes = now.toISOString().slice(0, 7);
   const targetSemana = semana ?? Math.ceil(now.getDate() / 7);
-  const configSnap = await db.collection("marketing_config").doc(tenantId).get();
+  const configSnap = await db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId).get();
   if (!configSnap.exists) {
-    return { ok: false, error: "No hay marketing_config" };
+    return { ok: false, error: `Brand "${brandId}" no encontrada` };
   }
-  const config = configSnap.data();
-  const brands = config.brands ?? {};
-  const brand = brands[brandId];
-  const calQuery = await db.collection("marketing_calendario").where("tenantId", "==", tenantId).where("brandId", "==", brandId).where("mes", "==", targetMes).limit(1).get();
+  const brand = configSnap.data();
+  const calQuery = await db.collection("tenants").doc(tenantId).collection("marketing_calendario").where("brandId", "==", brandId).where("mes", "==", targetMes).limit(1).get();
   let calendario = calQuery.empty ? null : { id: calQuery.docs[0].id, ...calQuery.docs[0].data() };
   if (!calendario) {
     const calId = `${tenantId}_${brandId}_${targetMes}`;
@@ -3737,14 +4678,14 @@ async function weeklyContentBuilder(input) {
       creadoPorId: "mcp-cowork",
       updatedAt: null
     };
-    await db.collection("marketing_calendario").doc(calId).set(calDoc);
+    await db.doc(`tenants/${tenantId}/marketing_calendario/${calId}`).set(calDoc);
     calendario = { ...calDoc, semanas };
   }
   const semanasArr = calendario.semanas ?? [];
   const semanaData = semanasArr[targetSemana - 1] ?? null;
   const slotsExistentes = semanaData?.items ?? [];
   if (targetModo === "planificar") {
-    const histQ2 = await db.collection("marketing_contenido").where("tenantId", "==", tenantId).where("brandId", "==", brandId).limit(20).get();
+    const histQ2 = await db.collection("tenants").doc(tenantId).collection("marketing_contenido").where("brandId", "==", brandId).limit(20).get();
     const historial2 = histQ2.docs.map((d) => d.data());
     return {
       ok: true,
@@ -3802,9 +4743,9 @@ async function weeklyContentBuilder(input) {
       }
     };
   }
-  const fotosQ = await db.collection("marketing_fotos").where("tenantId", "==", tenantId).where("brandId", "==", brandId).where("estado", "==", ESTADO_FOTO.EDITADA).limit(20).get();
+  const fotosQ = await db.collection("tenants").doc(tenantId).collection("marketing_fotos").where("brandId", "==", brandId).where("estado", "==", ESTADO_FOTO.EDITADA).limit(20).get();
   const fotosDisponibles = fotosQ.docs.map((d) => d.data());
-  const histQ = await db.collection("marketing_contenido").where("tenantId", "==", tenantId).where("brandId", "==", brandId).limit(20).get();
+  const histQ = await db.collection("tenants").doc(tenantId).collection("marketing_contenido").where("brandId", "==", brandId).limit(20).get();
   const historial = histQ.docs.map((d) => d.data());
   const hasBlogSlots = slotsParaGenerar.some((s) => s.plataforma === "shopify_blog");
   let blogJIT = null;
@@ -3812,7 +4753,7 @@ async function weeklyContentBuilder(input) {
     const blogStrategy = brand.blogStrategy;
     const blogs = blogStrategy?.blogs ?? [];
     const idiomas = brand.idiomas;
-    const articulosQ = await db.collection("marketing_contenido").where("tenantId", "==", tenantId).where("brandId", "==", brandId).where("plataforma", "==", "shopify_blog").where("estado", "==", ESTADO_CONTENIDO.PUBLICADO).limit(20).get();
+    const articulosQ = await db.collection("tenants").doc(tenantId).collection("marketing_contenido").where("brandId", "==", brandId).where("plataforma", "==", "shopify_blog").where("estado", "==", ESTADO_CONTENIDO.PUBLICADO).limit(20).get();
     const articulosExistentes = articulosQ.docs.map(
       (d) => d.data()
     );
@@ -3848,7 +4789,15 @@ async function weeklyContentBuilder(input) {
           userId: blogStrategy?.defaultAuthorId ?? null,
           name: blogStrategy?.defaultAuthorName ?? null
         },
-        languageCode: idiomas?.primario ?? "es"
+        languageCode: (() => {
+          const lc = idiomas?.primario;
+          if (!lc) {
+            throw new Error(
+              `weeklyContentBuilder requiere brand.idiomas.primario. Configurar antes de generar weekly content.`
+            );
+          }
+          return lc;
+        })()
       });
     }
     blogJIT = {
@@ -3981,10 +4930,8 @@ async function contentFinder(input) {
   const textThreshold = deps.thresholds?.text ?? DEFAULT_TEXT_THRESHOLD;
   const imageThreshold = deps.thresholds?.image ?? DEFAULT_IMAGE_THRESHOLD;
   const conflictThreshold = deps.thresholds?.conflictSimilarity ?? DEFAULT_CONFLICT_THRESHOLD;
-  const configSnap = await db.collection("marketing_config").doc(tenantId).get();
-  const config = configSnap.exists ? configSnap.data() : null;
-  const brands = config?.brands ?? {};
-  const brand = brands[brandId] ?? null;
+  const configSnap = await db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId).get();
+  const brand = configSnap.exists ? configSnap.data() : null;
   const brandBrief = brand?.brandBrief ?? null;
   const visualRules = brandBrief?.visualRules ?? {};
   const plan = brand?.plan ?? null;
@@ -4041,22 +4988,22 @@ async function contentFinder(input) {
   const productsLimit = include.products ? collFilter ? limit.products * 4 : limit.products * 2 : 0;
   const [productsRaw, collectionsRaw, articlesRaw, pagesRaw] = await Promise.all([
     searchCollection(
-      "shopify_products",
+      "products",
       include.products && limit.products > 0,
       productsLimit
     ),
     searchCollection(
-      "shopify_collections",
+      "collections",
       include.collections && limit.collections > 0,
       limit.collections * 2
     ),
     searchCollection(
-      "shopify_articles",
+      "articles",
       include.articles && limit.articles > 0,
       limit.articles * 2
     ),
     searchCollection(
-      "shopify_pages",
+      "pages",
       include.pages && limit.pages > 0,
       limit.pages * 2
     )
@@ -4161,16 +5108,11 @@ async function slotAssetFinder(input) {
   const limit = input.limit ?? 5;
   const photoThreshold = deps.thresholds?.photos ?? DEFAULT_PHOTO_THRESHOLD;
   const shopifyThreshold = deps.thresholds?.shopify ?? DEFAULT_SHOPIFY_THRESHOLD;
-  const configSnap = await db.collection("marketing_config").doc(tenantId).get();
+  const configSnap = await db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId).get();
   if (!configSnap.exists) {
-    return { ok: false, error: `Brand "${brandId}" no encontrada (no marketing_config)` };
-  }
-  const config = configSnap.data();
-  const brands = config.brands ?? {};
-  const brand = brands[brandId] ?? null;
-  if (!brand) {
     return { ok: false, error: `Brand "${brandId}" no encontrada` };
   }
+  const brand = configSnap.data();
   const brandBrief = brand.brandBrief ?? null;
   const visualRules = brandBrief?.visualRules ?? {};
   const plan = brand.plan ?? null;
@@ -4196,7 +5138,7 @@ async function slotAssetFinder(input) {
     try {
       const fetchLimit = bloqueoProducto && temporada?.coleccion?.handle ? limit * 4 : limit;
       const nearest = await deps.findNearestInCollection({
-        collection: "shopify_products",
+        collection: "products",
         tenantId,
         brandId,
         queryEmbedding: queryEmbedding ?? void 0,
@@ -4298,16 +5240,11 @@ function cosineSimilarity(a, b) {
 async function canvaTemplateSelector(input) {
   const { db, tenantId, brandId, plataforma, tipoContenido, keyword, deps } = input;
   const threshold = deps.threshold ?? DEFAULT_SIMILARITY_THRESHOLD;
-  const configSnap = await db.collection("marketing_config").doc(tenantId).get();
+  const configSnap = await db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId).get();
   if (!configSnap.exists) {
     return { plantillaId: null, motivo: "brand_no_encontrada" };
   }
-  const config = configSnap.data();
-  const brands = config.brands ?? {};
-  const brand = brands[brandId] ?? null;
-  if (!brand) {
-    return { plantillaId: null, motivo: "brand_no_encontrada" };
-  }
+  const brand = configSnap.data();
   const canva = brand.canva ?? {};
   if (!canva.connected || !Array.isArray(canva.templates) || canva.templates.length === 0) {
     return {
@@ -4465,7 +5402,7 @@ var ERROR_MESSAGES = {
     en: () => `External infrastructure failure. You can retry ONCE. If it persists, report the error and try another photo.`
   }
 };
-function instruccionesParaError(code, details, lang = "es") {
+function instruccionesParaError(code, details, lang) {
   const messages = ERROR_MESSAGES[code];
   if (!messages) {
     return lang === "en" ? `Unknown error. Report code=${code} and details to the tech team.` : `Error desconocido. Reporta el code=${code} y detalles al equipo tecnico.`;
@@ -4474,16 +5411,14 @@ function instruccionesParaError(code, details, lang = "es") {
 }
 async function photoDirectorPlan(input) {
   const { db, tenantId, fotoId, deps } = input;
-  const fotoQ = await db.collection("marketing_fotos").where("tenantId", "==", tenantId).where("id", "==", fotoId).limit(1).get();
+  const fotoQ = await db.collection("tenants").doc(tenantId).collection("marketing_fotos").where("id", "==", fotoId).limit(1).get();
   if (fotoQ.empty) {
     return { ok: false, code: "FOTO_NOT_FOUND", error: `Foto ${fotoId} no encontrada` };
   }
   const foto = fotoQ.docs[0].data();
   const brandId = foto.brandId;
-  const configSnap = await db.collection("marketing_config").doc(tenantId).get();
-  const config = configSnap.exists ? configSnap.data() : null;
-  const brands = config?.brands ?? {};
-  const brand = brands[brandId] ?? null;
+  const configSnap = await db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId).get();
+  const brand = configSnap.exists ? configSnap.data() : null;
   const brandBrief = (brand?.brandBrief ?? null) || {};
   const visualRules = brandBrief.visualRules ?? {};
   const catalogoVisual = brandBrief.catalogoVisual;
@@ -4910,15 +5845,12 @@ Campos comunes de save_generated_content:
   tipo: string (del slot)
 `;
 async function buildTenantContext(db, tenantId, brandId) {
-  const configSnap = await db.collection("marketing_config").doc(tenantId).get();
+  const configSnap = await db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId).get();
   if (!configSnap.exists) return "";
-  const config = configSnap.data();
-  const brands = config.brands ?? {};
-  const brand = brands[brandId];
-  if (!brand) return "";
+  const brand = configSnap.data();
   const [fotosQ, contenidoQ, productosQ] = await Promise.all([
-    db.collection("marketing_fotos").where("tenantId", "==", tenantId).where("brandId", "==", brandId).where("estado", "==", ESTADO_FOTO.EDITADA).limit(10).get(),
-    db.collection("marketing_contenido").where("tenantId", "==", tenantId).where("brandId", "==", brandId).where("estado", "==", ESTADO_CONTENIDO.PUBLICADO).limit(10).get(),
+    db.collection("tenants").doc(tenantId).collection("marketing_fotos").where("brandId", "==", brandId).where("estado", "==", ESTADO_FOTO.EDITADA).limit(10).get(),
+    db.collection("tenants").doc(tenantId).collection("marketing_contenido").where("brandId", "==", brandId).where("estado", "==", ESTADO_CONTENIDO.PUBLICADO).limit(10).get(),
     db.collection("productos").where("tenantId", "==", tenantId).limit(50).get()
   ]);
   const fotosEditadas = fotosQ.docs.map((d) => d.data());
@@ -4943,7 +5875,12 @@ Dominio: ${brand.dominio ?? "sin dominio"}
   ctx += `Tono: ${plan?.tonoMarca ?? "profesional y cercano"}
 `;
   if (idiomas) {
-    ctx += `Idioma principal: ${idiomas.primario ?? "es"}
+    if (!idiomas.primario) {
+      throw new Error(
+        `systemPromptBuilder requiere idiomas.primario. Brand sin idioma configurado \u2014 completar marketing_config.brands[bId].idiomas.`
+      );
+    }
+    ctx += `Idioma principal: ${idiomas.primario}
 `;
     if (idiomas.distribucion) {
       ctx += `Distribucion de idiomas: ${JSON.stringify(idiomas.distribucion)}
@@ -5122,10 +6059,8 @@ async function buildSystemPrompt(input) {
     const p2 = PARTE_2_REGLAS.replace("{{SHAPES_BLOCK}}", shapesBlock);
     return p1 + p2;
   }
-  const configSnap = await db.collection("marketing_config").doc(tenantId).get();
-  const config = configSnap.exists ? configSnap.data() : null;
-  const brands = config?.brands ?? {};
-  const brand = brands[brandId];
+  const configSnap = await db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId).get();
+  const brand = configSnap.exists ? configSnap.data() : null;
   let prompt = PARTE_1_IDENTIDAD.replace(
     "{{brand_nombre}}",
     brand?.nombre ?? brandId
@@ -5137,6 +6072,451 @@ async function buildSystemPrompt(input) {
   }
   return prompt;
 }
+async function writeAuditLog(input) {
+  try {
+    const db = (0, import_firestore3.getFirestore)();
+    const eventId = `evt_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const entryInput = {
+      schemaVersion: 1,
+      id: eventId,
+      tenantId: input.tenantId,
+      brandId: input.brandId ?? null,
+      actor: input.actor,
+      action: input.action,
+      targetType: input.targetType ?? "",
+      targetPath: input.targetPath ?? "",
+      targetId: input.targetId ?? "",
+      changes: input.changes ?? { before: null, after: null },
+      motivo: input.motivo ?? null,
+      conversacionId: input.conversacionId ?? null,
+      status: input.status ?? "success",
+      errorMessage: input.errorMessage ?? null,
+      durationMs: input.durationMs ?? 0,
+      timestamp: import_firestore3.FieldValue.serverTimestamp()
+    };
+    if (input.origenTecnico !== void 0) {
+      entryInput.origenTecnico = input.origenTecnico;
+    }
+    const entry = buildAuditLogEntry(entryInput);
+    await db.doc(`tenants/${input.tenantId}/audit_log/${eventId}`).set(entry);
+  } catch (err) {
+    console.error("[auditLog] Failed to write:", err, {
+      action: input.action,
+      tenantId: input.tenantId
+    });
+  }
+}
+async function getEffectiveLimits(tenantId) {
+  const db = (0, import_firestore4.getFirestore)();
+  const tenantSnap = await db.doc(`tenants/${tenantId}`).get();
+  if (!tenantSnap.exists) {
+    throw new Error(`Tenant ${tenantId} no existe`);
+  }
+  const tenant = tenantSnap.data();
+  const membresiaId = tenant.membresiaId;
+  if (!membresiaId) {
+    throw new Error(`Tenant ${tenantId} no tiene membresiaId`);
+  }
+  const membresiaSnap = await db.doc(`membresias/${membresiaId}`).get();
+  if (!membresiaSnap.exists) {
+    throw new Error(`Membresia ${membresiaId} no existe`);
+  }
+  const membresia = membresiaSnap.data();
+  const membresiaLimites = membresia.limites ?? {};
+  const limits = {
+    weeklyContentsPerMonth: membresiaLimites.weeklyContentsPerMonth ?? null,
+    fotosPorMes: membresiaLimites.fotosPorMes ?? null,
+    auditOptimizationsPerMonth: membresiaLimites.auditOptimizationsPerMonth ?? null,
+    aiCostBudgetUSD: membresiaLimites.aiCostBudgetUSD ?? null,
+    brandsIncluidas: membresiaLimites.brandsIncluidas ?? null,
+    usuarios: membresiaLimites.usuarios ?? null,
+    ubicaciones: membresiaLimites.ubicaciones ?? null,
+    productos: membresiaLimites.productos ?? null,
+    insumos: membresiaLimites.insumos ?? null,
+    ordenesMes: membresiaLimites.ordenesMes ?? null,
+    almacenamientoGB: membresiaLimites.almacenamientoGB ?? null,
+    creditosMes: membresiaLimites.creditosMes ?? null
+  };
+  const addonsActivos = tenant.addonsActivos ?? [];
+  const now = Date.now();
+  const activeAddons = addonsActivos.filter((a) => {
+    if (a.estado !== "active") return false;
+    const finVigencia = a.finVigencia;
+    if (finVigencia && typeof finVigencia.toMillis === "function" && finVigencia.toMillis() < now) {
+      return false;
+    }
+    return true;
+  });
+  if (activeAddons.length === 0) return limits;
+  const addonDocs = await Promise.all(
+    activeAddons.map(
+      (a) => db.doc(`membresia_addons/${a.addonId}`).get()
+    )
+  );
+  for (let i = 0; i < activeAddons.length; i++) {
+    const addonSnap = addonDocs[i];
+    if (!addonSnap.exists) continue;
+    const addon = addonSnap.data();
+    const cantidad = activeAddons[i].cantidad;
+    for (const [key, increment] of Object.entries(addon.incrementa ?? {})) {
+      const k = key;
+      if (limits[k] === null) continue;
+      limits[k] = (limits[k] ?? 0) + increment * cantidad;
+    }
+  }
+  return limits;
+}
+async function checkQuota(tenantId, quotaName) {
+  const limits = await getEffectiveLimits(tenantId);
+  const limit = limits[quotaName];
+  if (limit === null) {
+    return { ok: true, limit: null, current: 0, remaining: null };
+  }
+  const current = await getCurrentUsage(tenantId, quotaName);
+  const remaining = Math.max(0, limit - current);
+  const ok = current < limit;
+  return {
+    ok,
+    limit,
+    current,
+    remaining,
+    reason: ok ? void 0 : `Alcanzaste el l\xEDmite de ${quotaName}: ${current}/${limit}`
+  };
+}
+async function getCurrentUsage(_tenantId, _quotaName) {
+  return 0;
+}
+async function resolveTenantIdioma(tenantId) {
+  const db = (0, import_firestore5.getFirestore)();
+  const tenantSnap = await db.doc(`tenants/${tenantId}`).get();
+  if (!tenantSnap.exists) {
+    throw new Error(`Tenant ${tenantId} no existe`);
+  }
+  const data = tenantSnap.data();
+  const idioma = data.idiomaPrincipal ?? data.idioma;
+  if (!idioma) {
+    throw new Error(
+      `Tenant ${tenantId} sin idiomaPrincipal configurado. Completar tenants/${tenantId}.idiomaPrincipal antes de invocar helpers que generen contenido.`
+    );
+  }
+  return idioma;
+}
+var MESSAGES = {
+  es: {
+    generic: "Tuve un problema. Intent\xE9moslo de nuevo en un momento.",
+    quota_exceeded: "Alcanzaste el l\xEDmite mensual.",
+    not_found: "No lo encontr\xE9. \xBFPodr\xEDas verificar el dato?",
+    permission: "No tengo permiso para hacer eso desde tu cuenta.",
+    timeout: "Esto est\xE1 tardando m\xE1s de lo normal. \xBFLo intento de nuevo?"
+  },
+  en: {
+    generic: "I had a problem. Let's try again in a moment.",
+    quota_exceeded: "You reached the monthly limit.",
+    not_found: "I couldn't find it. Could you verify the data?",
+    permission: "I don't have permission to do that from your account.",
+    timeout: "This is taking longer than usual. Should I try again?"
+  }
+};
+function martinSafeError(err, locale) {
+  if (!(locale in MESSAGES)) {
+    throw new Error(
+      `Locale '${locale}' no soportado en martinSafeError. Locales activos: ${Object.keys(MESSAGES).join(", ")}. Agregar traducciones antes de usar.`
+    );
+  }
+  const msgs = MESSAGES[locale];
+  const e = err;
+  const message = e?.message ?? "";
+  const code = e?.code ?? "";
+  if (/quota|límite|limit/i.test(message)) return msgs.quota_exceeded;
+  if (/not.found|no.encontrado|no existe/i.test(message)) return msgs.not_found;
+  if (/permission|permiso/i.test(message)) return msgs.permission;
+  if (code === "deadline-exceeded" || /timeout/i.test(message)) return msgs.timeout;
+  return msgs.generic;
+}
+var MESSAGES2 = {
+  es: {
+    denied_role: "No tengo permiso para hacer eso desde tu cuenta. P\xEDdelo al encargado o admin que te autorice.",
+    input_invalido: "Falta algo o est\xE1 mal. \xBFLo intentamos de nuevo?",
+    confirm_default: "\xBFConfirmas?"
+  },
+  en: {
+    denied_role: "I don't have permission to do that from your account. Ask the manager or admin to authorize it.",
+    input_invalido: "Something is missing or off. Could you try again?",
+    confirm_default: "Are you sure?"
+  }
+};
+function getWrapperMessage(key, locale) {
+  if (!(locale in MESSAGES2)) {
+    throw new Error(
+      `Locale '${locale}' no soportado en getWrapperMessage. Locales activos: ${Object.keys(MESSAGES2).join(", ")}. Agregar traducciones antes de usar.`
+    );
+  }
+  const msg = MESSAGES2[locale][key];
+  if (!msg) {
+    throw new Error(
+      `Mensaje '${key}' no definido en wrapperMessages para locale '${locale}'.`
+    );
+  }
+  return msg;
+}
+function hasRequiredRole(userRol, required) {
+  if (required.includes("*")) return true;
+  return required.includes(userRol);
+}
+function wrapWithContract(contract, helper) {
+  return async function wrappedTool(input, ctx) {
+    const startMs = Date.now();
+    const locale = ctx.user.idiomaPreferido;
+    if (!hasRequiredRole(ctx.user.rol, contract.requiredRoles)) {
+      await writeAuditLog({
+        tenantId: ctx.tenantId,
+        brandId: ctx.brandId ?? null,
+        actor: { type: "martin", uid: ctx.user.uid, nombre: ctx.user.nombre },
+        action: contract.auditAction,
+        motivo: `Acceso denegado \u2014 rol '${ctx.user.rol}' no autorizado`,
+        conversacionId: ctx.conversacionId ?? null,
+        status: "error",
+        errorMessage: `Required: ${contract.requiredRoles.join(",")}, got: ${ctx.user.rol}`,
+        durationMs: Date.now() - startMs
+      });
+      return {
+        text: getWrapperMessage("denied_role", locale),
+        structuredOutput: null,
+        state: "denied_role"
+      };
+    }
+    const parseResult = contract.paramsSchema.safeParse(input);
+    if (!parseResult.success) {
+      await writeAuditLog({
+        tenantId: ctx.tenantId,
+        brandId: ctx.brandId ?? null,
+        actor: { type: "martin", uid: ctx.user.uid, nombre: ctx.user.nombre },
+        action: contract.auditAction,
+        motivo: "Input inv\xE1lido \u2014 Zod parse failed",
+        conversacionId: ctx.conversacionId ?? null,
+        status: "error",
+        errorMessage: `Input shape inv\xE1lido: ${parseResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`,
+        durationMs: Date.now() - startMs
+      });
+      return {
+        text: getWrapperMessage("input_invalido", locale),
+        structuredOutput: null,
+        state: "error"
+      };
+    }
+    const parsedInput = parseResult.data;
+    if (contract.requiresConfirmation && !ctx.confirmationGranted) {
+      const confirmMsg = contract.martinConfirmationTemplate ? contract.martinConfirmationTemplate(parsedInput, locale) : getWrapperMessage("confirm_default", locale);
+      return {
+        text: confirmMsg,
+        structuredOutput: null,
+        state: "pending_confirmation"
+      };
+    }
+    if (contract.requiresDoubleConfirmation && !ctx.doubleConfirmationGranted) {
+      const msg = contract.martinConfirmationTemplate ? contract.martinConfirmationTemplate(parsedInput, locale) : getWrapperMessage("confirm_default", locale);
+      return {
+        text: msg,
+        structuredOutput: null,
+        state: "pending_double_confirmation"
+      };
+    }
+    for (const quotaName of contract.quotasConsumed) {
+      const check = await checkQuota(
+        ctx.tenantId,
+        quotaName
+      );
+      if (!check.ok) {
+        await writeAuditLog({
+          tenantId: ctx.tenantId,
+          brandId: ctx.brandId ?? null,
+          actor: { type: "martin", uid: ctx.user.uid, nombre: ctx.user.nombre },
+          action: contract.auditAction,
+          motivo: `Quota excedida \u2014 ${quotaName}: ${check.current}/${check.limit}`,
+          conversacionId: ctx.conversacionId ?? null,
+          status: "error",
+          errorMessage: check.reason ?? "quota exceeded",
+          durationMs: Date.now() - startMs
+        });
+        return {
+          text: martinSafeError(new Error(check.reason ?? "quota"), locale),
+          structuredOutput: null,
+          state: "quota_exceeded"
+        };
+      }
+    }
+    let output;
+    try {
+      output = await helper(parsedInput);
+      contract.outputSchema.parse(output);
+    } catch (err) {
+      await writeAuditLog({
+        tenantId: ctx.tenantId,
+        brandId: ctx.brandId ?? null,
+        actor: { type: "martin", uid: ctx.user.uid, nombre: ctx.user.nombre },
+        action: contract.auditAction,
+        motivo: "Acci\xF3n solicitada v\xEDa Martin",
+        conversacionId: ctx.conversacionId ?? null,
+        status: "error",
+        errorMessage: err?.message ?? "unknown",
+        durationMs: Date.now() - startMs
+      });
+      return {
+        text: martinSafeError(err, locale),
+        structuredOutput: null,
+        state: "error"
+      };
+    }
+    const maybeDisabled = output;
+    if (maybeDisabled.disabled === true) {
+      const code = maybeDisabled.code;
+      if (!code) {
+        throw new Error(
+          `Wrapper: helper "${contract.name}" retorn\xF3 disabled:true pero sin 'code'. Helper debe retornar { disabled:true, code, detail? }.`
+        );
+      }
+      if (contract.disabledReasonCodes && !contract.disabledReasonCodes.includes(code)) {
+        throw new Error(
+          `Wrapper: helper "${contract.name}" retorn\xF3 disabled code "${code}" que NO est\xE1 declarado en contract.disabledReasonCodes [${contract.disabledReasonCodes.join(",")}]. Actualizar el contract antes de que el helper retorne c\xF3digos nuevos.`
+        );
+      }
+      const detail = maybeDisabled.detail;
+      const disabledText = getDisabledMessage(code, locale, detail);
+      await writeAuditLog({
+        tenantId: ctx.tenantId,
+        brandId: ctx.brandId ?? null,
+        actor: { type: "martin", uid: ctx.user.uid, nombre: ctx.user.nombre },
+        action: contract.auditAction,
+        motivo: `disabled \u2014 ${code}${detail ? `: ${JSON.stringify(detail)}` : ""}`,
+        conversacionId: ctx.conversacionId ?? null,
+        status: "partial",
+        durationMs: Date.now() - startMs
+      });
+      return {
+        text: disabledText,
+        structuredOutput: output,
+        state: "disabled",
+        disabledReason: code
+      };
+    }
+    const targetPath = contract.extractTargetPath ? contract.extractTargetPath(parsedInput, output) : "";
+    const changes = contract.extractChanges ? contract.extractChanges(parsedInput, output) : { before: null, after: null };
+    await writeAuditLog({
+      tenantId: ctx.tenantId,
+      brandId: ctx.brandId ?? null,
+      actor: { type: "martin", uid: ctx.user.uid, nombre: ctx.user.nombre },
+      action: contract.auditAction,
+      targetPath,
+      changes,
+      motivo: "Acci\xF3n solicitada v\xEDa Martin",
+      conversacionId: ctx.conversacionId ?? null,
+      status: "success",
+      durationMs: Date.now() - startMs
+    });
+    const summary = contract.martinSummaryTemplate(parsedInput, output, locale);
+    return {
+      text: summary,
+      structuredOutput: output,
+      state: "success"
+    };
+  };
+}
+var RecordarMemoriaParamsSchema = import_zod33.z.object({
+  tipo: TipoMemoriaEnum,
+  categoria: CategoriaMemoriaEnum,
+  contenido: import_zod33.z.string().min(3).max(500)
+});
+var RecordarMemoriaOutputSchema = import_zod33.z.object({
+  memoriaId: import_zod33.z.string(),
+  status: import_zod33.z.literal("creada")
+});
+var OlvidarMemoriaParamsSchema = import_zod33.z.object({
+  memoriaId: import_zod33.z.string(),
+  motivo: import_zod33.z.string().optional()
+});
+var OlvidarMemoriaOutputSchema = import_zod33.z.object({
+  status: import_zod33.z.literal("archivada")
+});
+var ConfigInputSchema = import_zod34.z.object({
+  diaSemana: import_zod34.z.number().int().min(0).max(6).nullable(),
+  diaMes: import_zod34.z.number().int().min(1).max(31).nullable(),
+  hora: import_zod34.z.string().regex(/^\d{2}:\d{2}$/),
+  // Timezone NO viene en input — hereda de tenants/{tid}.zonaHoraria (audit fix 2).
+  fechaPuntual: import_zod34.z.string().datetime({ offset: true }).nullable()
+}).strict();
+var AccionInputSchema = import_zod34.z.object({
+  tool: import_zod34.z.string().min(1),
+  params: import_zod34.z.record(import_zod34.z.string(), import_zod34.z.unknown())
+}).strict();
+var ProgramarRutinaParamsSchema = import_zod34.z.object({
+  tipo: TipoRutinaEnum,
+  frecuencia: FrecuenciaRutinaEnum,
+  config: ConfigInputSchema,
+  accion: AccionInputSchema,
+  uidDestinatario: import_zod34.z.string()
+});
+var ProgramarRutinaOutputSchema = import_zod34.z.object({
+  rutinaId: import_zod34.z.string(),
+  proximaEjecucionAt: import_zod34.z.string().datetime()
+});
+var PausarRutinaParamsSchema = import_zod34.z.object({
+  rutinaId: import_zod34.z.string(),
+  motivo: import_zod34.z.string().optional()
+});
+var PausarRutinaOutputSchema = import_zod34.z.object({
+  status: import_zod34.z.literal("pausada")
+});
+var ArchivarRutinaParamsSchema = import_zod34.z.object({
+  rutinaId: import_zod34.z.string(),
+  motivo: import_zod34.z.string().optional()
+});
+var ArchivarRutinaOutputSchema = import_zod34.z.object({
+  status: import_zod34.z.literal("archivada")
+});
+var ListarRutinasParamsSchema = import_zod34.z.object({
+  uid: import_zod34.z.string().optional()
+});
+var ListarRutinasOutputSchema = import_zod34.z.object({
+  rutinas: import_zod34.z.array(MartinRutinaSchema)
+});
+
+// src/tools/martinContext.ts
+function buildMartinContext(session, brandId, opts = {}) {
+  return {
+    tenantId: session.requireTenant(),
+    brandId,
+    user: {
+      uid: session.userId ?? "cowork-admin",
+      nombre: session.userName ?? "Cowork Admin",
+      rol: session.rol ?? "super_admin",
+      idiomaPreferido: "es"
+      // TODO HITO 8: leer usuarios/{uid}.idiomaPreferido
+    },
+    conversacionId: opts.conversacionId ?? null,
+    confirmationGranted: opts.confirmationGranted ?? true,
+    doubleConfirmationGranted: opts.doubleConfirmationGranted ?? false
+  };
+}
+async function dispatchWithContract(args) {
+  const { contract, helper, callable, input, ctx } = args;
+  if (getMode() === "admin") {
+    const db = getAdminDb();
+    const wrapped = wrapWithContract(
+      contract,
+      async (i) => helper({ ...i, db })
+    );
+    return wrapped(input, ctx);
+  }
+  return callable({
+    ...input,
+    _martinContext: {
+      conversacionId: ctx.conversacionId ?? null,
+      confirmationGranted: ctx.confirmationGranted === true,
+      doubleConfirmationGranted: ctx.doubleConfirmationGranted === true,
+      userIdiomaPreferido: ctx.user.idiomaPreferido
+    }
+  });
+}
 
 // src/services/marketingHelperCallables.ts
 var import_app3 = require("firebase/app");
@@ -5156,6 +6536,9 @@ async function callCF(name, input) {
   const result = await fn(input);
   return result.data;
 }
+function callGetCalendar(input) {
+  return callCF("marketingGetCalendarCallable", input);
+}
 function callBrandBriefWriter(input) {
   return callCF("marketingBrandBriefWriterCallable", input);
 }
@@ -5206,7 +6589,7 @@ function callPhotoDirectorExecute(input) {
 }
 
 // src/tools/marketing/photos.ts
-var import_zod16 = require("zod");
+var import_zod36 = require("zod");
 
 // src/services/marketingEmbeddings.ts
 var import_google_auth_library = require("google-auth-library");
@@ -5292,7 +6675,7 @@ var MARKETING_THRESHOLDS = {
     gbp: 0.4
   },
   content: {
-    // find_content_for_topic busca text→text en shopify_products / collections /
+    // find_content_for_topic busca text→text en products / collections /
     // articles / pages. Scores reales de top-10 andan 0.45-0.50, umbral 0.35
     // deja pasar los relevantes sin ser laxo.
     text: 0.35,
@@ -5379,12 +6762,12 @@ async function findNearestInCollection(params) {
     );
   }
   const db = getAdminDb();
-  const FieldValue = import_firebase_admin.default.firestore.FieldValue;
+  const FieldValue3 = import_firebase_admin.default.firestore.FieldValue;
   const fetchLimit = extraFilters.length > 0 ? Math.max(limit * 4, 20) : limit;
   const baseQ = db.collection(collection).where("tenantId", "==", tenantId).where("brandId", "==", brandId);
   const q = baseQ.findNearest({
     vectorField,
-    queryVector: FieldValue.vector(queryEmbedding),
+    queryVector: FieldValue3.vector(queryEmbedding),
     limit: fetchLimit,
     distanceMeasure: "COSINE",
     distanceResultField: "_distance"
@@ -5474,7 +6857,7 @@ async function findNearestInCollectionWithOverride(params) {
 }
 
 // src/tools/marketing/content.ts
-var import_zod15 = require("zod");
+var import_zod35 = require("zod");
 var _logOverride = null;
 async function logToMcpLogs(entry) {
   if (_logOverride) return _logOverride(entry);
@@ -5487,22 +6870,22 @@ async function logToMcpLogs(entry) {
   } catch {
   }
 }
-var IncludeSchema = import_zod15.z.object({
-  products: import_zod15.z.boolean().default(true),
-  collections: import_zod15.z.boolean().default(true),
-  articles: import_zod15.z.boolean().default(true),
-  pages: import_zod15.z.boolean().default(false)
+var IncludeSchema = import_zod35.z.object({
+  products: import_zod35.z.boolean().default(true),
+  collections: import_zod35.z.boolean().default(true),
+  articles: import_zod35.z.boolean().default(true),
+  pages: import_zod35.z.boolean().default(false)
 }).default({
   products: true,
   collections: true,
   articles: true,
   pages: false
 });
-var LimitSchema = import_zod15.z.object({
-  products: import_zod15.z.number().int().min(0).max(20).default(5),
-  collections: import_zod15.z.number().int().min(0).max(10).default(3),
-  articles: import_zod15.z.number().int().min(0).max(20).default(5),
-  pages: import_zod15.z.number().int().min(0).max(10).default(2)
+var LimitSchema = import_zod35.z.object({
+  products: import_zod35.z.number().int().min(0).max(20).default(5),
+  collections: import_zod35.z.number().int().min(0).max(10).default(3),
+  articles: import_zod35.z.number().int().min(0).max(20).default(5),
+  pages: import_zod35.z.number().int().min(0).max(10).default(2)
 }).default({ products: 5, collections: 3, articles: 5, pages: 2 });
 async function findContentForTopicHandler(input, session) {
   const tenantId = session.requireTenant();
@@ -5588,13 +6971,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_zod15.z.string().optional().describe("ID de la brand"),
-      contexto: import_zod15.z.string().min(1).describe("Parrafo, keyword o intencion"),
-      fecha: import_zod15.z.string().describe("Fecha del contenido en ISO YYYY-MM-DD"),
+      brandId: import_zod35.z.string().optional().describe("ID de la brand"),
+      contexto: import_zod35.z.string().min(1).describe("Parrafo, keyword o intencion"),
+      fecha: import_zod35.z.string().describe("Fecha del contenido en ISO YYYY-MM-DD"),
       include: IncludeSchema.optional(),
       limit: LimitSchema.optional(),
-      diversidad: import_zod15.z.boolean().default(true),
-      mode: import_zod15.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_zod35.z.boolean().default(true),
+      mode: import_zod35.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: mode2 }) => {
       const brandId = inputBrandId ?? session.requireBrand();
@@ -5698,11 +7081,11 @@ REGLAS:
 
 USAR: antes de generar contenido de cualquier slot del calendario.`,
     {
-      brandId: import_zod16.z.string().optional().describe("ID de la brand"),
-      keyword: import_zod16.z.string().describe("Keyword del slot"),
-      plataforma: import_zod16.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Plataforma destino del slot"),
-      fecha: import_zod16.z.string().describe("Fecha del slot en ISO YYYY-MM-DD"),
-      limit: import_zod16.z.number().int().min(1).max(10).default(5)
+      brandId: import_zod36.z.string().optional().describe("ID de la brand"),
+      keyword: import_zod36.z.string().describe("Keyword del slot"),
+      plataforma: import_zod36.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Plataforma destino del slot"),
+      fecha: import_zod36.z.string().describe("Fecha del slot en ISO YYYY-MM-DD"),
+      limit: import_zod36.z.number().int().min(1).max(10).default(5)
     },
     async ({ brandId: inputBrandId, keyword, plataforma, fecha, limit }) => {
       const tenantId = session.requireTenant();
@@ -5743,15 +7126,17 @@ DESPUES de ver la foto, decide:
 
 Luego llama execute_photo_edit con tu analisis y prompt.`,
     {
-      fotoId: import_zod16.z.string().describe("ID de la foto")
+      fotoId: import_zod36.z.string().describe("ID de la foto")
     },
     async ({ fotoId }) => {
       const tenantId = session.requireTenant();
+      const lang = await resolveTenantIdioma(tenantId);
       const result = getMode() === "admin" ? await photoDirectorPlan({
         db: getAdminDb(),
         tenantId,
         fotoId,
-        deps: { compressImageForTransport }
+        deps: { compressImageForTransport },
+        lang
       }) : await callPhotoDirectorPlan({ tenantId, fotoId });
       if (!result.ok) {
         return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
@@ -5774,16 +7159,18 @@ 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_zod16.z.string(),
-      prompt: import_zod16.z.string().nullable().describe("Prompt en ingles para Gemini Image Edit. null si tal_cual"),
-      acciones: import_zod16.z.array(import_zod16.z.enum(["edit_background", "none"])),
-      descripcion: import_zod16.z.string().describe("Descripcion semantica en espanol"),
-      tipo: import_zod16.z.string().nullable().describe("Tipo del catalogoVisual del tenant"),
-      tagsPrimarios: import_zod16.z.array(import_zod16.z.string()),
-      tagsSecundarios: import_zod16.z.array(import_zod16.z.string()),
-      tagsContexto: import_zod16.z.array(import_zod16.z.string())
+      fotoId: import_zod36.z.string(),
+      prompt: import_zod36.z.string().nullable().describe("Prompt en ingles para Gemini Image Edit. null si tal_cual"),
+      acciones: import_zod36.z.array(import_zod36.z.enum(["edit_background", "none"])),
+      descripcion: import_zod36.z.string().describe("Descripcion semantica en espanol"),
+      tipo: import_zod36.z.string().nullable().describe("Tipo del catalogoVisual del tenant"),
+      tagsPrimarios: import_zod36.z.array(import_zod36.z.string()),
+      tagsSecundarios: import_zod36.z.array(import_zod36.z.string()),
+      tagsContexto: import_zod36.z.array(import_zod36.z.string())
     },
     async ({ fotoId, prompt, acciones, descripcion, tipo, tagsPrimarios, tagsSecundarios, tagsContexto }) => {
+      const tenantId = session.requireTenant();
+      const lang = await resolveTenantIdioma(tenantId);
       if (getMode() === "admin") {
         const executePhotoEditAdapter = async (payload) => {
           const cfUrl = process.env.MARKETING_PHOTO_EDIT_CF_URL || "https://us-central1-atteyo-ops.cloudfunctions.net/marketingExecutePhotoEdit";
@@ -5807,7 +7194,8 @@ Si estrategia era 'tal_cual', pasa acciones=['none'] \u2014 no se edita pero si
           tagsPrimarios,
           tagsSecundarios,
           tagsContexto,
-          deps: { compressImageForTransport, executePhotoEdit: executePhotoEditAdapter }
+          deps: { compressImageForTransport, executePhotoEdit: executePhotoEditAdapter },
+          lang
         });
         if (!result2.ok) {
           return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
@@ -5821,7 +7209,7 @@ Si estrategia era 'tal_cual', pasa acciones=['none'] \u2014 no se edita pero si
         return { content: contentArray2 };
       }
       const result = await callPhotoDirectorExecute({
-        tenantId: session.requireTenant(),
+        tenantId,
         fotoId,
         prompt,
         acciones,
@@ -5855,7 +7243,7 @@ Retorna:
   - creditos: { balance, planId, periodEnd, costoPhotoEdit }
   - _instrucciones: que hacer segun el estado`,
     {
-      fotoId: import_zod16.z.string().describe("ID de la foto")
+      fotoId: import_zod36.z.string().describe("ID de la foto")
     },
     async ({ fotoId }) => {
       const tenantId = session.requireTenant();
@@ -5898,7 +7286,7 @@ Retorna:
           };
         }
       }
-      const creditsDoc = await readDoc("brand_credits", `${tenantId}_${brandId}`);
+      const creditsDoc = await readDoc(`tenants/${tenantId}/brand_credits`, brandId);
       const balance = creditsDoc?.balance ?? 0;
       const planId = creditsDoc?.planId ?? null;
       const periodEnd = creditsDoc?.periodEnd ?? null;
@@ -5955,11 +7343,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_zod16.z.string().optional().describe("ID de la brand"),
-      contexto: import_zod16.z.string().describe("Parrafo, keyword o intencion del contenido"),
-      fecha: import_zod16.z.string().describe("Fecha del contenido en ISO YYYY-MM-DD"),
-      limit: import_zod16.z.number().int().min(1).max(10).default(5),
-      diversidad: import_zod16.z.boolean().default(true)
+      brandId: import_zod36.z.string().optional().describe("ID de la brand"),
+      contexto: import_zod36.z.string().describe("Parrafo, keyword o intencion del contenido"),
+      fecha: import_zod36.z.string().describe("Fecha del contenido en ISO YYYY-MM-DD"),
+      limit: import_zod36.z.number().int().min(1).max(10).default(5),
+      diversidad: import_zod36.z.boolean().default(true)
     },
     async ({ brandId: inputBrandId, contexto, fecha, limit, diversidad }) => {
       console.warn(
@@ -6010,12 +7398,12 @@ Retorna:
 
 RETORNA { plantillaId, titulo, thumbnailUrl } o { plantillaId: null, motivo: 'no_canva' } si tenant no tiene Canva conectado.
 
-USAR: solo si tenant tiene Canva conectado (marketing_config.brands[brandId].canva.connected=true).`,
+USAR: solo si tenant tiene Canva conectado (tenants/{tenantId}/marketing_config/{brandId}.canva.connected=true).`,
     {
-      brandId: import_zod16.z.string().optional().describe("ID de la brand"),
-      plataforma: import_zod16.z.string().describe("gbp | instagram | shopify_blog"),
-      tipoContenido: import_zod16.z.string().describe("post | carousel | story | blog"),
-      keyword: import_zod16.z.string().describe("Keyword del slot")
+      brandId: import_zod36.z.string().optional().describe("ID de la brand"),
+      plataforma: import_zod36.z.string().describe("gbp | instagram | shopify_blog"),
+      tipoContenido: import_zod36.z.string().describe("post | carousel | story | blog"),
+      keyword: import_zod36.z.string().describe("Keyword del slot")
     },
     async ({ brandId: inputBrandId, plataforma, tipoContenido, keyword }) => {
       const tenantId = session.requireTenant();
@@ -6045,15 +7433,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_zod16.z.string().optional().describe("ID de la brand"),
-      semana: import_zod16.z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "semana debe ser ISO YYYY-MM-DD").describe("Semana en ISO del lunes"),
-      necesidades: import_zod16.z.array(
-        import_zod16.z.object({
-          tema: import_zod16.z.string(),
-          keyword: import_zod16.z.string(),
-          cantidadSugerida: import_zod16.z.number().int().positive(),
-          razon: import_zod16.z.string(),
-          slotsAfectados: import_zod16.z.array(import_zod16.z.string()).optional().describe('Refs de slots afectados (formato "semana:N:slot:M")')
+      brandId: import_zod36.z.string().optional().describe("ID de la brand"),
+      semana: import_zod36.z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "semana debe ser ISO YYYY-MM-DD").describe("Semana en ISO del lunes"),
+      necesidades: import_zod36.z.array(
+        import_zod36.z.object({
+          tema: import_zod36.z.string(),
+          keyword: import_zod36.z.string(),
+          cantidadSugerida: import_zod36.z.number().int().positive(),
+          razon: import_zod36.z.string(),
+          slotsAfectados: import_zod36.z.array(import_zod36.z.string()).optional().describe('Refs de slots afectados (formato "semana:N:slot:M")')
         })
       ).min(1)
     },
@@ -6192,16 +7580,6 @@ async function linkContenidoAPasoPipeline(params) {
 }
 
 // src/tools/marketing.ts
-async function resolveLastImportId3(tenantId, brandId) {
-  const config = await readDoc("marketing_config", tenantId);
-  const brands = config?.brands ?? {};
-  const brand = brands[brandId];
-  const canalId = brand?.canalId;
-  if (!canalId) return null;
-  const canal = await readDoc("canales_venta", canalId);
-  const app = canal?.app ?? {};
-  return app.lastImportId ?? null;
-}
 function registerMarketingTools(server, session) {
   registerPhotoTools(server, session);
   registerContentTools(server, session);
@@ -6209,48 +7587,46 @@ function registerMarketingTools(server, session) {
     "get_calendar",
     "Lee el calendario editorial del mes. Muestra semanas con items planificados por plataforma.",
     {
-      brandId: import_zod17.z.string().optional().describe("ID de la brand"),
-      mes: import_zod17.z.string().optional().describe("Mes en formato YYYY-MM (default: mes actual)")
+      brandId: import_zod37.z.string().optional().describe("ID de la brand"),
+      mes: import_zod37.z.string().optional().describe("Mes en formato YYYY-MM (default: mes actual)")
     },
     async ({ brandId: inputBrandId, mes }) => {
-      session.requireTenant();
+      const tenantId = session.requireTenant();
       const brandId = inputBrandId ?? session.requireBrand();
       const targetMes = mes ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 7);
-      const calendarios = await queryByTenant(session, "marketing_calendario", [
-        { field: "brandId", op: "==", value: brandId },
-        { field: "mes", op: "==", value: targetMes }
-      ], { limit: 1 });
-      if (calendarios.length === 0) {
-        return {
-          content: [{
-            type: "text",
-            text: JSON.stringify({
-              mes: targetMes,
-              brandId,
-              semanas: [],
-              mensaje: "No hay calendario para este mes. Genera un plan de marketing primero."
-            })
-          }]
+      const ctx = buildMartinContext(session, brandId);
+      const result = await dispatchWithContract({
+        contract: getCalendarContract,
+        helper: getCalendar,
+        callable: callGetCalendar,
+        input: { tenantId, brandId, mes: targetMes },
+        ctx
+      });
+      let payload;
+      if (result.state === "success" && result.structuredOutput) {
+        const out = result.structuredOutput;
+        payload = out.calendario ?? {
+          mes: out.mes,
+          brandId: out.brandId,
+          semanas: [],
+          mensaje: out.mensaje
         };
+      } else {
+        payload = { ok: false, state: result.state, mensaje: result.text };
       }
-      return { content: [{ type: "text", text: JSON.stringify(calendarios[0], null, 2) }] };
+      return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
     }
   );
   server.tool(
     "get_seo_snapshot",
     "Lee el snapshot SEO de la brand: rank, keywords, oportunidades, competidores.",
     {
-      brandId: import_zod17.z.string().optional().describe("ID de la brand")
+      brandId: import_zod37.z.string().optional().describe("ID de la brand")
     },
     async ({ brandId: inputBrandId }) => {
       const tenantId = session.requireTenant();
       const brandId = inputBrandId ?? session.requireBrand();
-      const config = await readDoc("marketing_config", tenantId);
-      if (!config) {
-        return { content: [{ type: "text", text: JSON.stringify({ error: "No hay marketing_config" }) }] };
-      }
-      const brands = config.brands ?? {};
-      const brand = brands[brandId];
+      const brand = await readDoc(`tenants/${tenantId}/marketing_config`, brandId);
       if (!brand) {
         return { content: [{ type: "text", text: JSON.stringify({ error: `Brand "${brandId}" no encontrada` }) }] };
       }
@@ -6264,8 +7640,8 @@ function registerMarketingTools(server, session) {
     "get_photo_gallery",
     "Fotos disponibles filtradas por estado. Muestra fotos con metadata y conteo.",
     {
-      brandId: import_zod17.z.string().optional().describe("ID de la brand"),
-      estado: import_zod17.z.string().optional().describe("Filtrar por estado (nueva, procesando, editada, usada, descartada, error)")
+      brandId: import_zod37.z.string().optional().describe("ID de la brand"),
+      estado: import_zod37.z.string().optional().describe("Filtrar por estado (nueva, procesando, editada, usada, descartada, error)")
     },
     async ({ brandId: inputBrandId, estado }) => {
       session.requireTenant();
@@ -6305,7 +7681,7 @@ function registerMarketingTools(server, session) {
     "generate_marketing_plan",
     "Prepara los datos necesarios para generar un plan de marketing estrategico. Retorna snapshot SEO + productos para que Claude genere el plan con el system prompt.",
     {
-      brandId: import_zod17.z.string().optional().describe("ID de la brand")
+      brandId: import_zod37.z.string().optional().describe("ID de la brand")
     },
     async ({ brandId: inputBrandId }) => {
       const tenantId = session.requireTenant();
@@ -6317,25 +7693,33 @@ function registerMarketingTools(server, session) {
   );
   server.tool(
     "save_marketing_plan",
-    "Guarda el plan de marketing generado por Claude en la configuracion de la brand. Escribe en marketing_config.brands[brandId].plan.",
+    "Guarda el plan de marketing generado por Claude en la configuracion de la brand. Escribe en tenants/{tenantId}/marketing_config/{brandId}.plan.",
     {
-      brandId: import_zod17.z.string().optional().describe("ID de la brand"),
-      plan: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.unknown()).describe("Plan de marketing generado (keywordsPrioritarios, gapsCompetencia, temporadas, tonoMarca, quickWins, etc.)")
+      brandId: import_zod37.z.string().optional().describe("ID de la brand"),
+      plan: import_zod37.z.record(import_zod37.z.string(), import_zod37.z.unknown()).describe("Plan de marketing generado (keywordsPrioritarios, gapsCompetencia, temporadas, tonoMarca, quickWins, etc.)")
     },
     async ({ brandId: inputBrandId, plan }) => {
       const tenantId = session.requireTenant();
       const brandId = inputBrandId ?? session.requireBrand();
-      const result = getMode() === "admin" ? await planWriter.save({ db: getAdminDb(), tenantId, brandId, plan }) : await callPlanWriterSave({ tenantId, brandId, plan });
-      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      const ctx = buildMartinContext(session, brandId);
+      const result = await dispatchWithContract({
+        contract: planWriterSaveContract,
+        helper: planWriter.save,
+        callable: callPlanWriterSave,
+        input: { tenantId, brandId, plan },
+        ctx
+      });
+      const payload = result.state === "success" ? result.structuredOutput : { ok: false, state: result.state, mensaje: result.text };
+      return { content: [{ type: "text", text: JSON.stringify(payload) }] };
     }
   );
   server.tool(
     "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_zod17.z.string().optional().describe("ID de la brand"),
-      field: import_zod17.z.string().describe('Nombre del campo a actualizar (ej: "coleccionesPriorizadas", "quickWins", "temporadas")'),
-      value: import_zod17.z.unknown().describe("Valor del campo")
+      brandId: import_zod37.z.string().optional().describe("ID de la brand"),
+      field: import_zod37.z.string().describe('Nombre del campo a actualizar (ej: "coleccionesPriorizadas", "quickWins", "temporadas")'),
+      value: import_zod37.z.unknown().describe("Valor del campo")
     },
     async ({ brandId: inputBrandId, field, value }) => {
       const tenantId = session.requireTenant();
@@ -6348,22 +7732,36 @@ function registerMarketingTools(server, session) {
     "generate_brand_brief",
     "Prepara todos los datos del negocio para que Claude genere un Brand Brief pre-llenado. Retorna Shopify + SEO + GBP + tenant data. Claude genera el brief, luego usa save_brand_brief para guardar.",
     {
-      brandId: import_zod17.z.string().optional().describe("ID de la brand")
+      brandId: import_zod37.z.string().optional().describe("ID de la brand")
     },
     async ({ brandId: inputBrandId }) => {
       const tenantId = session.requireTenant();
       const brandId = inputBrandId ?? session.requireBrand();
-      const result = getMode() === "admin" ? await brandBriefBuilder({ db: getAdminDb(), tenantId, brandId }) : await callBrandBriefBuilder({ tenantId, brandId });
-      const payload = result.ok ? result.payload : result;
-      return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+      const ctx = buildMartinContext(session, brandId);
+      const result = await dispatchWithContract({
+        contract: brandBriefBuilderContract,
+        helper: brandBriefBuilder,
+        callable: callBrandBriefBuilder,
+        input: { tenantId, brandId },
+        ctx
+      });
+      let returnPayload;
+      if (result.state === "success" && result.structuredOutput?.ok === true) {
+        returnPayload = result.structuredOutput.payload;
+      } else if (result.state === "success") {
+        returnPayload = result.structuredOutput;
+      } else {
+        returnPayload = { ok: false, state: result.state, mensaje: result.text };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(returnPayload, null, 2) }] };
     }
   );
   server.tool(
     "save_brand_brief",
-    "Guarda el Brand Brief generado por Claude en marketing_config.brands[brandId].brandBrief. Escribe solo ese campo (merge parcial, no rebuild del doc).",
+    "Guarda el Brand Brief generado por Claude en tenants/{tenantId}/marketing_config/{brandId}.brandBrief. Escribe solo ese campo (merge parcial, no rebuild del doc).",
     {
-      brandId: import_zod17.z.string().optional().describe("ID de la brand"),
-      brandBrief: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.unknown()).describe("Brand Brief completo generado por Claude")
+      brandId: import_zod37.z.string().optional().describe("ID de la brand"),
+      brandBrief: import_zod37.z.record(import_zod37.z.string(), import_zod37.z.unknown()).describe("Brand Brief completo generado por Claude")
     },
     async ({ brandId: inputBrandId, brandBrief }) => {
       const tenantId = session.requireTenant();
@@ -6376,9 +7774,9 @@ function registerMarketingTools(server, session) {
     "generate_weekly_content",
     "Prepara datos del calendario + fotos + plan para generar el contenido de la semana. Claude genera con el system prompt, luego usa save_generated_content para guardar.",
     {
-      brandId: import_zod17.z.string().optional().describe("ID de la brand"),
-      semana: import_zod17.z.number().optional().describe("Numero de semana (1-5). Default: semana actual del mes."),
-      modo: import_zod17.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_zod37.z.string().optional().describe("ID de la brand"),
+      semana: import_zod37.z.number().optional().describe("Numero de semana (1-5). Default: semana actual del mes."),
+      modo: import_zod37.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();
@@ -6394,14 +7792,14 @@ function registerMarketingTools(server, session) {
 
 IMPORTANTE: Si seleccionaste una foto con get_photos_for_slot, SIEMPRE pasa fotoId aqu\xED. Sin fotoId el post se publica sin imagen.`,
     {
-      brandId: import_zod17.z.string().optional().describe("ID de la brand"),
-      plataforma: import_zod17.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Plataforma destino"),
-      tipo: import_zod17.z.string().optional().describe("Tipo de contenido (post, blog, carousel, etc.)"),
-      keyword: import_zod17.z.string().optional().describe("Keyword target"),
-      languageCode: import_zod17.z.string().optional().describe("Idioma (es/en)"),
-      fotoId: import_zod17.z.string().optional().describe("ID de la foto a asociar"),
-      datos: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.unknown()).describe("Datos especificos de la plataforma (output de buildDatos*)"),
-      calendarioItemRef: import_zod17.z.string().optional().describe("Referencia al item del calendario")
+      brandId: import_zod37.z.string().optional().describe("ID de la brand"),
+      plataforma: import_zod37.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Plataforma destino"),
+      tipo: import_zod37.z.string().optional().describe("Tipo de contenido (post, blog, carousel, etc.)"),
+      keyword: import_zod37.z.string().optional().describe("Keyword target"),
+      languageCode: import_zod37.z.string().optional().describe("Idioma (es/en)"),
+      fotoId: import_zod37.z.string().optional().describe("ID de la foto a asociar"),
+      datos: import_zod37.z.record(import_zod37.z.string(), import_zod37.z.unknown()).describe("Datos especificos de la plataforma (output de buildDatos*)"),
+      calendarioItemRef: import_zod37.z.string().optional().describe("Referencia al item del calendario")
     },
     async ({ brandId: inputBrandId, plataforma, tipo, keyword, languageCode, fotoId, datos, calendarioItemRef }) => {
       const tenantId = session.requireTenant();
@@ -6446,13 +7844,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_zod17.z.string().describe("ID del doc en marketing_contenido"),
-      datos: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.unknown()).optional().describe('Campos de datos a actualizar (merge parcial sobre datos existentes). Ej: { body: "...", metaTitle: "..." }'),
-      fotoId: import_zod17.z.string().nullable().optional().describe("Actualizar foto asociada"),
-      keyword: import_zod17.z.string().nullable().optional().describe("Actualizar keyword"),
-      languageCode: import_zod17.z.string().optional().describe("Actualizar idioma"),
-      estado: import_zod17.z.enum(["borrador", "generado", "pendiente_aprobacion", "aprobado", "rechazado"]).optional().describe("Cambiar estado manualmente"),
-      calendarioItemRef: import_zod17.z.string().nullable().optional().describe("Vincular a un slot del calendario")
+      contenidoId: import_zod37.z.string().describe("ID del doc en marketing_contenido"),
+      datos: import_zod37.z.record(import_zod37.z.string(), import_zod37.z.unknown()).optional().describe('Campos de datos a actualizar (merge parcial sobre datos existentes). Ej: { body: "...", metaTitle: "..." }'),
+      fotoId: import_zod37.z.string().nullable().optional().describe("Actualizar foto asociada"),
+      keyword: import_zod37.z.string().nullable().optional().describe("Actualizar keyword"),
+      languageCode: import_zod37.z.string().optional().describe("Actualizar idioma"),
+      estado: import_zod37.z.enum(["borrador", "generado", "pendiente_aprobacion", "aprobado", "rechazado"]).optional().describe("Cambiar estado manualmente"),
+      calendarioItemRef: import_zod37.z.string().nullable().optional().describe("Vincular a un slot del calendario")
     },
     async ({ contenidoId, datos: newDatos, fotoId, keyword, languageCode, estado, calendarioItemRef }) => {
       const tenantId = session.requireTenant();
@@ -6483,27 +7881,27 @@ Si pasas campos dentro de "datos", se hace merge con los datos existentes (no lo
     "update_calendar_slot",
     "Modifica o agrega un slot del calendario editorial. Si slotIndex >= items.length, agrega un slot nuevo.",
     {
-      brandId: import_zod17.z.string().optional().describe("ID de la brand"),
-      mes: import_zod17.z.string().describe("Mes del calendario (YYYY-MM)"),
-      semana: import_zod17.z.number().describe("Numero de semana (1-5)"),
-      slotIndex: import_zod17.z.number().describe("Indice del slot (0-based). Si >= items.length, agrega nuevo slot al final."),
-      cambios: import_zod17.z.object({
-        dia: import_zod17.z.string().nullable().optional(),
-        plataforma: import_zod17.z.enum(["gbp", "shopify_blog", "instagram", "review"]).nullable().optional(),
-        tipo: import_zod17.z.enum(["post", "blog", "carousel", "reel", "story", "review_response"]).nullable().optional(),
-        keyword: import_zod17.z.string().nullable().optional(),
-        tema: import_zod17.z.string().nullable().optional(),
-        productoId: import_zod17.z.string().nullable().optional(),
-        estado: import_zod17.z.enum(["planificado", "pre_aprobado", "generado", "revisar", "aprobado", "publicado", "rechazado"]).optional(),
-        contenidoRef: import_zod17.z.string().nullable().optional(),
-        fotoIdAsignada: import_zod17.z.string().nullable().optional(),
-        notas: import_zod17.z.array(NotaCalendarioSchema).optional(),
-        locationId: import_zod17.z.string().nullable().optional().describe("GBP location ID \u2014 a qu\xE9 sucursal publicar el post"),
-        locationNombre: import_zod17.z.string().nullable().optional().describe("Nombre de la sucursal GBP (para UI)")
+      brandId: import_zod37.z.string().optional().describe("ID de la brand"),
+      mes: import_zod37.z.string().describe("Mes del calendario (YYYY-MM)"),
+      semana: import_zod37.z.number().describe("Numero de semana (1-5)"),
+      slotIndex: import_zod37.z.number().describe("Indice del slot (0-based). Si >= items.length, agrega nuevo slot al final."),
+      cambios: import_zod37.z.object({
+        dia: import_zod37.z.string().nullable().optional(),
+        plataforma: import_zod37.z.enum(["gbp", "shopify_blog", "instagram", "review"]).nullable().optional(),
+        tipo: import_zod37.z.enum(["post", "blog", "carousel", "reel", "story", "review_response"]).nullable().optional(),
+        keyword: import_zod37.z.string().nullable().optional(),
+        tema: import_zod37.z.string().nullable().optional(),
+        productoId: import_zod37.z.string().nullable().optional(),
+        estado: import_zod37.z.enum(["planificado", "pre_aprobado", "generado", "revisar", "aprobado", "publicado", "rechazado"]).optional(),
+        contenidoRef: import_zod37.z.string().nullable().optional(),
+        fotoIdAsignada: import_zod37.z.string().nullable().optional(),
+        notas: import_zod37.z.array(NotaCalendarioSchema).optional(),
+        locationId: import_zod37.z.string().nullable().optional().describe("GBP location ID \u2014 a qu\xE9 sucursal publicar el post"),
+        locationNombre: import_zod37.z.string().nullable().optional().describe("Nombre de la sucursal GBP (para UI)")
       }).strict().describe("Campos del slot. Solo acepta campos validos del schema. Campos no reconocidos seran rechazados."),
-      accionContenidoExistente: import_zod17.z.union([
-        import_zod17.z.enum(["descartar", "nuevo_slot", "mantener"]),
-        import_zod17.z.string().regex(/^mover:semana:\d+:slot:\d+$/, "Formato: mover:semana:N:slot:M")
+      accionContenidoExistente: import_zod37.z.union([
+        import_zod37.z.enum(["descartar", "nuevo_slot", "mantener"]),
+        import_zod37.z.string().regex(/^mover:semana:\d+:slot:\d+$/, "Formato: mover:semana:N:slot:M")
       ]).optional().describe(
         "Decision del tenant cuando el slot ya tiene un contenidoRef existente Y los cambios tocan keyword/tema/plataforma/tipo. Requerido en ese escenario (si no se pasa, el helper retorna ACCION_CONTENIDO_EXISTENTE_REQUIRED con las 4 opciones para que preguntes al tenant). Valores: 'descartar' (marca el contenido existente como descartado y aplica cambios al slot) | 'mover:semana:N:slot:M' (mueve el contenido existente al slot destino vacio y aplica cambios al slot origen) | 'nuevo_slot' (NO toca este slot ni su contenido; crea un slot nuevo el mismo dia con los cambios \u2014 util para multiples publicaciones/dia) | 'mantener' (conserva el contenido existente aqui y aplica los cambios igualmente \u2014 caso typo fix)."
       )
@@ -6511,9 +7909,16 @@ Si pasas campos dentro de "datos", se hace merge con los datos existentes (no lo
     async ({ brandId: inputBrandId, mes, semana, slotIndex, cambios, accionContenidoExistente }) => {
       const tenantId = session.requireTenant();
       const brandId = inputBrandId ?? session.requireBrand();
-      const accionTyped = accionContenidoExistente;
-      const result = getMode() === "admin" ? await calendarSlotUpdater({ db: getAdminDb(), tenantId, brandId, mes, semana, slotIndex, cambios, accionContenidoExistente: accionTyped }) : await callCalendarSlotUpdater({ tenantId, brandId, mes, semana, slotIndex, cambios, accionContenidoExistente });
-      return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      const ctx = buildMartinContext(session, brandId);
+      const result = await dispatchWithContract({
+        contract: calendarSlotUpdaterContract,
+        helper: calendarSlotUpdater,
+        callable: callCalendarSlotUpdater,
+        input: { tenantId, brandId, mes, semana, slotIndex, cambios, accionContenidoExistente },
+        ctx
+      });
+      const payload = result.state === "success" ? result.structuredOutput : { ok: false, state: result.state, mensaje: result.text };
+      return { content: [{ type: "text", text: JSON.stringify(payload) }] };
     }
   );
   server.tool(
@@ -6526,9 +7931,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_zod17.z.string().describe("ID del doc en marketing_contenido"),
-      fotoId: import_zod17.z.string().describe("ID de la foto en marketing_fotos (estado editada)"),
-      calendarioItemRef: import_zod17.z.string().optional().describe('Ref del slot (formato "semana:N:slot:M") para actualizar fotoIdAsignada')
+      contenidoRef: import_zod37.z.string().describe("ID del doc en marketing_contenido"),
+      fotoId: import_zod37.z.string().describe("ID de la foto en marketing_fotos (estado editada)"),
+      calendarioItemRef: import_zod37.z.string().optional().describe('Ref del slot (formato "semana:N:slot:M") para actualizar fotoIdAsignada')
     },
     async ({ contenidoRef, fotoId, calendarioItemRef }) => {
       const tenantId = session.requireTenant();
@@ -6541,7 +7946,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_zod17.z.string().describe("ID del contenido a aprobar")
+      contenidoId: import_zod37.z.string().describe("ID del contenido a aprobar")
     },
     async ({ contenidoId }) => {
       session.requireTenant();
@@ -6565,8 +7970,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_zod17.z.string().describe("ID del contenido a rechazar"),
-      motivo: import_zod17.z.string().describe("Motivo del rechazo")
+      contenidoId: import_zod37.z.string().describe("ID del contenido a rechazar"),
+      motivo: import_zod37.z.string().describe("Motivo del rechazo")
     },
     async ({ contenidoId, motivo }) => {
       session.requireTenant();
@@ -6586,44 +7991,44 @@ NUNCA uses update_calendar_slot para asignar fotos \u2014 eso escribe en la agen
     }
   );
   server.tool(
-    "get_shopify_collections",
-    "Lee todas las colecciones de Shopify con sus 6 campos SEO actuales. Incluye best practices 2026.",
+    "get_collections",
+    "Lee todas las colecciones canonicas (Shopify/WordPress/webonly) con sus 6 campos SEO actuales. Incluye best practices 2026.",
     {
-      brandId: import_zod17.z.string().optional().describe("ID de la brand")
+      brandId: import_zod37.z.string().optional().describe("ID de la brand")
     },
     async ({ brandId: inputBrandId }) => {
       const tenantId = session.requireTenant();
       const brandId = inputBrandId ?? session.requireBrand();
-      const lastImportId = await resolveLastImportId3(tenantId, brandId);
-      if (!lastImportId) {
+      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({
           ok: false,
-          error: "No hay import de Shopify. El tenant debe sincronizar desde Marketing > Mi Plan > Shopify."
+          error: "No hay colecciones nested. El tenant debe sincronizar desde Marketing > Configuraci\xF3n > Shopify > Sincronizar."
         }) }] };
       }
-      const collectionsDoc = await readDoc(
-        `tenants/${tenantId}/shopify_imports/${lastImportId}/data`,
-        "collections"
-      );
-      const items = collectionsDoc?.items ?? [];
-      const config = await readDoc("marketing_config", tenantId);
-      const brands = config?.brands ?? {};
-      const brand = brands[brandId];
+      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) => ({
-        id: c.id,
-        title: c.title,
-        handle: c.handle,
-        body_html: typeof c.body_html === "string" ? c.body_html.slice(0, 500) : null,
-        metaTitle: c.metaTitle ?? null,
-        metaDescription: c.metaDescription ?? null,
-        products_count: c.products_count ?? null,
-        collectionType: c.collectionType ?? null,
-        image: c.image ? { src: c.image.src, alt: c.image.alt } : null,
-        existingSuggestion: existingSuggestions[String(c.id)] ?? null
-      }));
+      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
+        };
+      });
       return { content: [{ type: "text", text: JSON.stringify({
         ok: true,
         totalCollections: collections.length,
@@ -6676,7 +8081,7 @@ NUNCA uses update_calendar_slot para asignar fotos \u2014 eso escribe en la agen
     "save_collection_suggestions",
     "Guarda sugerencias SEO para colecciones de Shopify. El tenant las aprueba en la UI.",
     {
-      brandId: import_zod17.z.string().optional().describe("ID de la brand"),
+      brandId: import_zod37.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 }) => {