ponch-mcp-server 1.0.87 → 1.0.89

package/dist/index.js

@@ -170,6 +170,41 @@ var Session = class {
     this.context.tenantId = tenantId;
     this.context.brandId = brandId;
   }
+  /**
+   * Cambia la brand activa SIN cambiar tenant. Disponible para:
+   *   - User Modo B con multi-brand (brands.length > 1) — agency mode.
+   *   - Super_admin Modo A (canSwitchTenant=true) — service account
+   *     puede operar cualquier brand dentro del tenant activo seteado
+   *     previamente vía set_context.
+   *
+   * DEUDA 3 sesión 211.1 H/I + fix J post-smoke 1.0.88.
+   *
+   * Lanza si:
+   *   - El user no es super_admin Y no tiene multi-brand.
+   *   - El brandId NO está en lista del user (defensa cross-brand Modo B).
+   *     Para super_admin Modo A se delega validación al helper (Firestore
+   *     existence check) — no hay "lista accesible" porque tiene acceso
+   *     total al tenant.
+   */
+  setBrand(brandId) {
+    const brands = this._authContext.brands ?? [];
+    const isSuperAdmin = this._authContext.canSwitchTenant;
+    if (!isSuperAdmin && brands.length <= 1) {
+      throw new Error(
+        `select_brand requires multi-brand access or super_admin. This user has access to ${brands.length} brand(s) and is not super_admin.`
+      );
+    }
+    if (!isSuperAdmin) {
+      const allowed = brands.some((b) => b.id === brandId);
+      if (!allowed) {
+        throw new Error(
+          `Brand "${brandId}" is not in the user's accessible brands list [${brands.map((b) => b.id).join(", ")}].`
+        );
+      }
+    }
+    this.context.brandId = brandId;
+    this._authContext.brandId = brandId;
+  }
   /**
    * Revoca canSwitchTenant en runtime. Usado cuando el bootstrap detecta
    * token expirado — el usuario debe re-autenticar via connect_account
@@ -433,7 +468,7 @@ function serverTimestamp() {
 }
 
 // src/tools/context.ts
-var import_zod60 = require("zod");
+var import_zod63 = require("zod");
 var import_functions2 = require("firebase/functions");
 var import_app3 = require("firebase/app");
 
@@ -1632,12 +1667,25 @@ var ContenidoSchema = import_zod12.z.object({
   mediaVariante: MediaVarianteSchema.nullable().optional(),
   creadoAt: import_zod12.z.unknown().nullable().optional(),
   creadoPorId: import_zod12.z.string().nullable().optional(),
+  // §9.2 PLAN_C2 — actor canónico de la creación. Auto-poblado desde
+  // ctx.user.{nombre,clientType,clientMetadata} en server.tool.
+  creadoPorNombre: import_zod12.z.string().nullable().optional(),
+  creadoPorClient: import_zod12.z.string().nullable().optional(),
+  creadoPorClientMetadata: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown()).nullable().optional(),
   origen: import_zod12.z.enum(ORIGENES_CONTENIDO).nullable().optional(),
   aprobadoAt: import_zod12.z.unknown().nullable().optional(),
   aprobadoPorId: import_zod12.z.string().nullable().optional(),
   aprobadoPorNombre: import_zod12.z.string().nullable().optional(),
+  // §9.2 — extendido en Sub-A2.1; agregado al schema canónico aquí.
+  aprobadoPorClient: import_zod12.z.string().nullable().optional(),
+  aprobadoPorClientMetadata: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown()).nullable().optional(),
   rechazadoAt: import_zod12.z.unknown().nullable().optional(),
   rechazadoMotivo: import_zod12.z.string().nullable().optional(),
+  // §9.2 — extendido en Sub-A2.2; agregado al schema canónico aquí.
+  rechazadoPorId: import_zod12.z.string().nullable().optional(),
+  rechazadoPorNombre: import_zod12.z.string().nullable().optional(),
+  rechazadoPorClient: import_zod12.z.string().nullable().optional(),
+  rechazadoPorClientMetadata: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown()).nullable().optional(),
   editadoAt: import_zod12.z.unknown().nullable().optional(),
   publicadoAt: import_zod12.z.unknown().nullable().optional(),
   errorPublicacion: import_zod12.z.string().nullable().optional(),
@@ -1665,6 +1713,9 @@ function buildContenido(input) {
     mediaVariante: input.mediaVariante ?? null,
     creadoAt: input.creadoAt ?? null,
     creadoPorId: input.creadoPorId ?? null,
+    creadoPorNombre: input.creadoPorNombre ?? null,
+    creadoPorClient: input.creadoPorClient ?? null,
+    creadoPorClientMetadata: input.creadoPorClientMetadata ?? null,
     origen: input.origen ?? null
   });
 }
@@ -3510,17 +3561,17 @@ var PolyDateFormatter = class {
   constructor(dt, intl, opts) {
     this.opts = opts;
     this.originalZone = void 0;
-    let z36 = void 0;
+    let z39 = void 0;
     if (this.opts.timeZone) {
       this.dt = dt;
     } else if (dt.zone.type === "fixed") {
       const gmtOffset = -1 * (dt.offset / 60);
       const offsetZ = gmtOffset >= 0 ? `Etc/GMT+${gmtOffset}` : `Etc/GMT${gmtOffset}`;
       if (dt.offset !== 0 && IANAZone.create(offsetZ).valid) {
-        z36 = offsetZ;
+        z39 = offsetZ;
         this.dt = dt;
       } else {
-        z36 = "UTC";
+        z39 = "UTC";
         this.dt = dt.offset === 0 ? dt : dt.setZone("UTC").plus({ minutes: dt.offset });
         this.originalZone = dt.zone;
       }
@@ -3528,14 +3579,14 @@ var PolyDateFormatter = class {
       this.dt = dt;
     } else if (dt.zone.type === "iana") {
       this.dt = dt;
-      z36 = dt.zone.name;
+      z39 = dt.zone.name;
     } else {
-      z36 = "UTC";
+      z39 = "UTC";
       this.dt = dt.setZone("UTC").plus({ minutes: dt.offset });
       this.originalZone = dt.zone;
     }
     const intlOpts = { ...this.opts };
-    intlOpts.timeZone = intlOpts.timeZone || z36;
+    intlOpts.timeZone = intlOpts.timeZone || z39;
     this.dtf = getCachedDTF(intl, intlOpts);
   }
   format() {
@@ -10837,16 +10888,21 @@ var import_zod49 = require("zod");
 var import_zod50 = require("zod");
 var import_firebase_admin11 = require("firebase-admin");
 var import_zod51 = require("zod");
+var import_firebase_admin12 = require("firebase-admin");
 var import_zod52 = require("zod");
 var import_zod53 = require("zod");
-var import_firebase_admin12 = require("firebase-admin");
-var import_zod54 = require("zod");
 var import_firebase_admin13 = require("firebase-admin");
+var import_zod54 = require("zod");
 var import_zod55 = require("zod");
 var import_zod56 = require("zod");
+var import_firebase_admin14 = require("firebase-admin");
 var import_zod57 = require("zod");
+var import_firebase_admin15 = require("firebase-admin");
 var import_zod58 = require("zod");
 var import_zod59 = require("zod");
+var import_zod60 = require("zod");
+var import_zod61 = require("zod");
+var import_zod62 = require("zod");
 var import_firestore4 = require("firebase-admin/firestore");
 var RULE_NEGATIVES = {
   allowFaces: "no people, no faces, no hands",
@@ -11088,7 +11144,7 @@ var brandBriefWriterContract = MartinContractSchema.parse(
   rawContract
 );
 async function save(input) {
-  const { db, tenantId, brandId, plan } = input;
+  const { db, tenantId, brandId, plan, actor } = input;
   const brandRef = db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId);
   const brandSnap = await brandRef.get();
   if (!brandSnap.exists) {
@@ -11098,7 +11154,11 @@ async function save(input) {
   const planWithMeta = {
     ...planSinBlogStrategy,
     fechaCreacion: (/* @__PURE__ */ new Date()).toISOString(),
-    creadoPorId: "mcp-cowork"
+    // §9.2 PLAN_C2 — actor real desde ctx.user (NO 'mcp-cowork' hardcoded).
+    creadoPorId: actor.uid,
+    creadoPorNombre: actor.nombre,
+    creadoPorClient: actor.clientType,
+    creadoPorClientMetadata: actor.clientMetadata ?? null
   };
   await brandRef.set({
     plan: planWithMeta,
@@ -11177,7 +11237,13 @@ var ParamsSchema2 = import_zod36.z.object({
   brandId: import_zod36.z.string().min(1).describe("Brand identifier within the tenant."),
   plan: import_zod36.z.record(import_zod36.z.string(), import_zod36.z.unknown()).describe(
     "Full marketing plan object generated by the LLM. May include a blogStrategy field \u2014 if present, it is extracted and stored at brand level (not nested inside plan)."
-  )
+  ),
+  actor: import_zod36.z.object({
+    uid: import_zod36.z.string().min(1).describe('User id who is saving the plan. Example: "your-user-uid".'),
+    nombre: import_zod36.z.string().min(1).describe('Human-readable user name. Example: "Daniel Gonz\xE1lez".'),
+    clientType: import_zod36.z.string().min(1).describe('Client surface origin. Example: one of "mcp_client" | "martin" | "web" | "admin".'),
+    clientMetadata: import_zod36.z.record(import_zod36.z.string(), import_zod36.z.unknown()).nullable().optional().describe("Optional metadata about the client.")
+  }).describe("Actor (user) saving the plan \u2014 extracted by the server.tool from ctx.user (\xA79.2).")
 });
 var OutputSchema2 = import_zod36.z.discriminatedUnion("ok", [
   import_zod36.z.object({
@@ -13110,6 +13176,255 @@ var rawContract15 = {
 var tenantContextSetterContract = MartinContractSchema.parse(
   rawContract15
 );
+async function photoDescarter(input) {
+  const { db, tenantId, fotoId, actor } = input;
+  const ref = db.collection("tenants").doc(tenantId).collection("marketing_fotos").doc(fotoId);
+  const snap = await ref.get();
+  if (!snap.exists) {
+    return { ok: false, code: "FOTO_NOT_FOUND" };
+  }
+  const data = snap.data();
+  const estadoActual = typeof data.estado === "string" ? data.estado : "";
+  if (!validarTransicionFoto(estadoActual, ESTADO_FOTO.DESCARTADA)) {
+    return {
+      ok: false,
+      code: "INVALID_STATE_TRANSITION",
+      estadoActual
+    };
+  }
+  await ref.update({
+    estado: ESTADO_FOTO.DESCARTADA,
+    descartadaAt: import_firebase_admin11.firestore.FieldValue.serverTimestamp(),
+    descartadaPorId: actor.uid,
+    descartadaPorNombre: actor.nombre,
+    descartadaPorClient: actor.clientType,
+    descartadaPorClientMetadata: actor.clientMetadata ?? null
+  });
+  return {
+    ok: true,
+    fotoId,
+    estadoAnterior: estadoActual,
+    nuevoEstado: ESTADO_FOTO.DESCARTADA
+  };
+}
+var ParamsSchema16 = import_zod51.z.object({
+  tenantId: import_zod51.z.string().min(1).describe('Tenant identifier (the business account). Example: "your-tenant-id".'),
+  fotoId: import_zod51.z.string().min(1).describe('Photo identifier. Example: "your-tenant_your-brand_1234567890_abcdef".'),
+  actor: import_zod51.z.object({
+    uid: import_zod51.z.string().min(1).describe('User id who is discarding. Example: "your-user-uid".'),
+    nombre: import_zod51.z.string().min(1).describe('Human-readable user name. Example: "Daniel Gonz\xE1lez".'),
+    clientType: import_zod51.z.string().min(1).describe('Client surface origin. Example: one of "mcp_client" | "martin" | "web" | "admin".'),
+    clientMetadata: import_zod51.z.record(import_zod51.z.string(), import_zod51.z.unknown()).nullable().optional().describe("Optional metadata about the client.")
+  }).describe("Actor (user) performing the discard \u2014 extracted by the server.tool from ctx.user.")
+});
+var SuccessSchema7 = import_zod51.z.object({
+  ok: import_zod51.z.literal(true),
+  fotoId: import_zod51.z.string(),
+  estadoAnterior: import_zod51.z.string(),
+  nuevoEstado: import_zod51.z.literal("descartada")
+});
+var FailureSchema7 = import_zod51.z.object({
+  ok: import_zod51.z.literal(false),
+  code: import_zod51.z.enum(["FOTO_NOT_FOUND", "INVALID_STATE_TRANSITION"]),
+  estadoActual: import_zod51.z.string().optional()
+});
+var OutputSchema16 = import_zod51.z.discriminatedUnion("ok", [SuccessSchema7, FailureSchema7]);
+var rawContract16 = {
+  name: "discard_photo",
+  description: "Mark a marketing photo as discarded. Validates state transition (nueva|editada|error \u2192 descartada). Use when the photo is no longer needed or has issues. Requires confirmation.",
+  paramsSchema: ParamsSchema16,
+  outputSchema: OutputSchema16,
+  requiresConfirmation: true,
+  destructive: false,
+  affectsPublication: false,
+  affectsExternal: false,
+  martinConfirmationTemplate: (input, locale) => {
+    return locale === "en" ? `Discard photo "${input.fotoId}"? The photo will be marked as descartada and won't be used in content.` : `\xBFDescartar la foto "${input.fotoId}"? La foto se marcar\xE1 como descartada y no se usar\xE1 en contenido.`;
+  },
+  martinSummaryTemplate: (input, output, locale) => {
+    if (!output.ok) {
+      if (output.code === "FOTO_NOT_FOUND") {
+        return locale === "en" ? `Photo ${input.fotoId} not found.` : `No encontr\xE9 la foto ${input.fotoId}.`;
+      }
+      return locale === "en" ? `Cannot discard photo from state "${output.estadoActual ?? "unknown"}".` : `No se puede descartar la foto desde el estado "${output.estadoActual ?? "desconocido"}".`;
+    }
+    return locale === "en" ? `Photo ${output.fotoId} discarded (was ${output.estadoAnterior}).` : `Foto ${output.fotoId} descartada (estaba en ${output.estadoAnterior}).`;
+  },
+  auditAction: "marketing.foto.descartar",
+  extractTargetPath: (input) => `tenants/${input.tenantId}/marketing_fotos/${input.fotoId}`,
+  extractChanges: (_input, output) => ({
+    before: output.ok ? { estado: output.estadoAnterior } : null,
+    after: output.ok ? { estado: output.nuevoEstado } : null
+  }),
+  quotasConsumed: [],
+  permissionScope: "module",
+  permissionKey: "marketing",
+  permissionAction: "editar",
+  sideEffects: ["writes_firestore"]
+};
+var photoDescarterContract = MartinContractSchema.parse(
+  rawContract16
+);
+async function photoEditadaMarker(input) {
+  const { db, tenantId, fotoId, actor } = input;
+  const ref = db.collection("tenants").doc(tenantId).collection("marketing_fotos").doc(fotoId);
+  const snap = await ref.get();
+  if (!snap.exists) {
+    return { ok: false, code: "FOTO_NOT_FOUND" };
+  }
+  const data = snap.data();
+  const estadoActual = typeof data.estado === "string" ? data.estado : "";
+  const archivoOriginal = typeof data.archivoOriginal === "string" ? data.archivoOriginal : null;
+  if (!validarTransicionFoto(estadoActual, ESTADO_FOTO.EDITADA)) {
+    return {
+      ok: false,
+      code: "INVALID_STATE_TRANSITION",
+      estadoActual
+    };
+  }
+  if (!archivoOriginal) {
+    return { ok: false, code: "FOTO_SIN_ARCHIVO_ORIGINAL", estadoActual };
+  }
+  await ref.update({
+    estado: ESTADO_FOTO.EDITADA,
+    archivoEditado: archivoOriginal,
+    fechaEdicion: import_firebase_admin12.firestore.FieldValue.serverTimestamp(),
+    marcadaEditadaPorId: actor.uid,
+    marcadaEditadaPorNombre: actor.nombre,
+    marcadaEditadaPorClient: actor.clientType,
+    marcadaEditadaPorClientMetadata: actor.clientMetadata ?? null
+  });
+  return {
+    ok: true,
+    fotoId,
+    estadoAnterior: estadoActual,
+    nuevoEstado: ESTADO_FOTO.EDITADA,
+    archivoEditado: archivoOriginal
+  };
+}
+var ParamsSchema17 = import_zod52.z.object({
+  tenantId: import_zod52.z.string().min(1).describe('Tenant identifier. Example: "your-tenant-id".'),
+  fotoId: import_zod52.z.string().min(1).describe('Photo identifier. Example: "your-tenant_your-brand_1234567890_abcdef".'),
+  actor: import_zod52.z.object({
+    uid: import_zod52.z.string().min(1).describe('User id who marks the photo. Example: "your-user-uid".'),
+    nombre: import_zod52.z.string().min(1).describe('Human-readable user name. Example: "Daniel Gonz\xE1lez".'),
+    clientType: import_zod52.z.string().min(1).describe('Client surface origin. Example: one of "mcp_client" | "martin" | "web" | "admin".'),
+    clientMetadata: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown()).nullable().optional().describe("Optional metadata about the client.")
+  }).describe("Actor (user) marking the photo \u2014 extracted by the server.tool from ctx.user.")
+});
+var SuccessSchema8 = import_zod52.z.object({
+  ok: import_zod52.z.literal(true),
+  fotoId: import_zod52.z.string(),
+  estadoAnterior: import_zod52.z.string(),
+  nuevoEstado: import_zod52.z.literal("editada"),
+  archivoEditado: import_zod52.z.string()
+});
+var FailureSchema8 = import_zod52.z.object({
+  ok: import_zod52.z.literal(false),
+  code: import_zod52.z.enum(["FOTO_NOT_FOUND", "INVALID_STATE_TRANSITION", "FOTO_SIN_ARCHIVO_ORIGINAL"]),
+  estadoActual: import_zod52.z.string().optional()
+});
+var OutputSchema17 = import_zod52.z.discriminatedUnion("ok", [SuccessSchema8, FailureSchema8]);
+var rawContract17 = {
+  name: "use_photo_as_is",
+  description: "Mark a photo as editada using the original file (no Gemini edit). Validates state transition (procesando \u2192 editada). Use when the original photo is already good enough for publication and no editing is required. archivoEditado is set to the original URL.",
+  paramsSchema: ParamsSchema17,
+  outputSchema: OutputSchema17,
+  requiresConfirmation: false,
+  destructive: false,
+  affectsPublication: false,
+  affectsExternal: false,
+  martinSummaryTemplate: (input, output, locale) => {
+    if (!output.ok) {
+      if (output.code === "FOTO_NOT_FOUND") {
+        return locale === "en" ? `Photo ${input.fotoId} not found.` : `No encontr\xE9 la foto ${input.fotoId}.`;
+      }
+      if (output.code === "FOTO_SIN_ARCHIVO_ORIGINAL") {
+        return locale === "en" ? `Photo ${input.fotoId} has no original file to use.` : `La foto ${input.fotoId} no tiene archivo original que usar.`;
+      }
+      return locale === "en" ? `Cannot mark photo as edited from state "${output.estadoActual ?? "unknown"}".` : `No se puede marcar como editada desde el estado "${output.estadoActual ?? "desconocido"}".`;
+    }
+    return locale === "en" ? `Photo ${output.fotoId} marked as editada using the original (was ${output.estadoAnterior}).` : `Foto ${output.fotoId} marcada como editada usando la original (estaba en ${output.estadoAnterior}).`;
+  },
+  auditAction: "marketing.foto.usar_tal_cual",
+  extractTargetPath: (input) => `tenants/${input.tenantId}/marketing_fotos/${input.fotoId}`,
+  extractChanges: (_input, output) => ({
+    before: output.ok ? { estado: output.estadoAnterior } : null,
+    after: output.ok ? { estado: output.nuevoEstado, archivoEditado: output.archivoEditado } : null
+  }),
+  quotasConsumed: [],
+  permissionScope: "module",
+  permissionKey: "marketing",
+  permissionAction: "editar",
+  sideEffects: ["writes_firestore"]
+};
+var photoEditadaMarkerContract = MartinContractSchema.parse(
+  rawContract17
+);
+async function brandContextSetter(input) {
+  const { db, tenantId, brandId } = input;
+  const brandRef = db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId);
+  const brandSnap = await brandRef.get();
+  if (!brandSnap.exists) {
+    return {
+      ok: false,
+      code: "BRAND_NOT_FOUND_IN_TENANT",
+      tenantId,
+      brandId
+    };
+  }
+  const data = brandSnap.data();
+  return {
+    ok: true,
+    tenantId,
+    brandId,
+    brandNombre: typeof data.nombre === "string" ? data.nombre : null,
+    brandDominio: typeof data.dominio === "string" ? data.dominio : null
+  };
+}
+var ParamsSchema18 = import_zod53.z.object({
+  tenantId: import_zod53.z.string().min(1).describe(`Tenant identifier (always the user's own tenant). Example: "your-tenant-id".`),
+  brandId: import_zod53.z.string().min(1).describe(`Target brand identifier within the user's tenant. Example: "your-brand-id".`)
+});
+var SuccessSchema9 = import_zod53.z.object({
+  ok: import_zod53.z.literal(true),
+  tenantId: import_zod53.z.string(),
+  brandId: import_zod53.z.string(),
+  brandNombre: import_zod53.z.string().nullable(),
+  brandDominio: import_zod53.z.string().nullable()
+});
+var FailureSchema9 = import_zod53.z.object({
+  ok: import_zod53.z.literal(false),
+  code: import_zod53.z.literal("BRAND_NOT_FOUND_IN_TENANT"),
+  tenantId: import_zod53.z.string(),
+  brandId: import_zod53.z.string()
+});
+var OutputSchema18 = import_zod53.z.discriminatedUnion("ok", [SuccessSchema9, FailureSchema9]);
+var rawContract18 = {
+  name: "select_brand",
+  description: "Switch the active brand within the user's tenant. Validates that the target brand exists in the tenant. Helper does not mutate Firestore \u2014 caller (MCP server) updates session local state after success. Audit log writes who switched brand (forensics for agency mode). Use when the user has multiple brands and wants to work with a different one without passing brandId on every tool call.",
+  paramsSchema: ParamsSchema18,
+  outputSchema: OutputSchema18,
+  requiresConfirmation: false,
+  destructive: false,
+  affectsPublication: false,
+  affectsExternal: false,
+  martinSummaryTemplate: (input, output, locale) => {
+    if (!output.ok) {
+      return locale === "en" ? `Brand "${input.brandId}" does not exist in your tenant.` : `La brand "${input.brandId}" no existe en tu tenant.`;
+    }
+    return locale === "en" ? `Active brand set to ${output.brandNombre ?? output.brandId}.` : `Brand activa establecida: ${output.brandNombre ?? output.brandId}.`;
+  },
+  auditAction: "self.brand_context.cambiar",
+  quotasConsumed: [],
+  // scope='self' — operación sobre la sesión del propio user. NO requiere
+  // permissionKey/permissionAction (superRefine de MartinContractSchema).
+  permissionScope: "self",
+  sideEffects: ["reads_firestore"]
+};
+var brandContextSetterContract = MartinContractSchema.parse(
+  rawContract18
+);
 var PLATAFORMA_A_FORMATO = {
   gbp: "gbp_4_3",
   shopify_blog: "blog_3_2",
@@ -13151,12 +13466,12 @@ async function photoAssigner(input) {
     mediaVariante: {
       url: varianteUrl,
       formato,
-      linkedAt: import_firebase_admin11.firestore.FieldValue.serverTimestamp(),
+      linkedAt: import_firebase_admin13.firestore.FieldValue.serverTimestamp(),
       permalink: null,
       // lo llenara publishToInstagram/etc en el futuro
       mediaExternalId: null
     },
-    editadoAt: import_firebase_admin11.firestore.FieldValue.serverTimestamp()
+    editadoAt: import_firebase_admin13.firestore.FieldValue.serverTimestamp()
   };
   let slotResolved = null;
   if (calendarioItemRef) {
@@ -13206,7 +13521,7 @@ async function photoAssigner(input) {
       tx.update(contenidoRefDoc, contenidoUpdatePayload);
       tx.update(calDocRef, {
         semanas,
-        updatedAt: import_firebase_admin11.firestore.FieldValue.serverTimestamp()
+        updatedAt: import_firebase_admin13.firestore.FieldValue.serverTimestamp()
       });
     });
   } else {
@@ -13221,35 +13536,35 @@ async function photoAssigner(input) {
     formato
   };
 }
-var ParamsSchema16 = import_zod51.z.object({
-  tenantId: import_zod51.z.string().min(1).describe("Tenant identifier (the business account)."),
-  brandId: import_zod51.z.string().min(1).describe("Brand identifier within the tenant."),
-  contenidoRef: import_zod51.z.string().min(1).describe("Document ID in marketing_contenido (the post receiving the photo)."),
-  fotoId: import_zod51.z.string().min(1).describe("Photo ID in marketing_fotos. Photo must be in state='editada'."),
-  calendarioItemRef: import_zod51.z.string().regex(/^semana:\d+:slot:\d+$/).optional().describe(
+var ParamsSchema19 = import_zod54.z.object({
+  tenantId: import_zod54.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod54.z.string().min(1).describe("Brand identifier within the tenant."),
+  contenidoRef: import_zod54.z.string().min(1).describe("Document ID in marketing_contenido (the post receiving the photo)."),
+  fotoId: import_zod54.z.string().min(1).describe("Photo ID in marketing_fotos. Photo must be in state='editada'."),
+  calendarioItemRef: import_zod54.z.string().regex(/^semana:\d+:slot:\d+$/).optional().describe(
     'Calendar slot reference in format "semana:N:slot:M". Optional \u2014 if provided, syncs the slot.fotoIdAsignada UI snapshot atomically with the content update. OMIT if there is no calendar slot to sync.'
   )
 });
-var OutputSchema16 = import_zod51.z.discriminatedUnion("ok", [
-  import_zod51.z.object({
-    ok: import_zod51.z.literal(true),
-    fotoId: import_zod51.z.string(),
-    contenidoRef: import_zod51.z.string(),
-    plataforma: import_zod51.z.string(),
-    varianteUrl: import_zod51.z.string().nullable(),
-    formato: import_zod51.z.string()
+var OutputSchema19 = import_zod54.z.discriminatedUnion("ok", [
+  import_zod54.z.object({
+    ok: import_zod54.z.literal(true),
+    fotoId: import_zod54.z.string(),
+    contenidoRef: import_zod54.z.string(),
+    plataforma: import_zod54.z.string(),
+    varianteUrl: import_zod54.z.string().nullable(),
+    formato: import_zod54.z.string()
   }),
-  import_zod51.z.object({
-    ok: import_zod51.z.literal(false),
-    error: import_zod51.z.string(),
-    code: import_zod51.z.enum(["CONTENT_NOT_FOUND", "CONTENT_TENANT_MISMATCH", "PHOTO_NOT_FOUND", "PHOTO_NOT_READY"]).optional()
+  import_zod54.z.object({
+    ok: import_zod54.z.literal(false),
+    error: import_zod54.z.string(),
+    code: import_zod54.z.enum(["CONTENT_NOT_FOUND", "CONTENT_TENANT_MISMATCH", "PHOTO_NOT_FOUND", "PHOTO_NOT_READY"]).optional()
   })
 ]);
-var rawContract16 = {
+var rawContract19 = {
   name: "assign_photo_to_content",
   description: 'Assign an edited photo to an existing content. Writes atomically to BOTH marketing_contenido.fotoId+mediaVariante (canonical for publish) AND marketing_calendario slot.fotoIdAsignada (UI snapshot, only if calendarioItemRef provided). NEVER use update_calendar_slot for this \u2014 that one writes to the agenda, not the post. The photo must be in state="editada".',
-  paramsSchema: ParamsSchema16,
-  outputSchema: OutputSchema16,
+  paramsSchema: ParamsSchema19,
+  outputSchema: OutputSchema19,
   // Cambia la foto vinculada al contenido — reversible (volver a llamar con
   // otra fotoId), no publica nada externo. La foto editada queda intacta;
   // solo se actualiza la referencia.
@@ -13291,7 +13606,7 @@ var rawContract16 = {
   sideEffects: ["writes_firestore", "updates_calendar_slot"]
 };
 var photoAssignerContract = MartinContractSchema.parse(
-  rawContract16
+  rawContract19
 );
 function findPageByHeuristic(pages, pattern) {
   return pages.find((p) => pattern.test(p.title || "")) || pages.find((p) => pattern.test(p.handle || "")) || null;
@@ -13480,27 +13795,27 @@ var BRAND_BRIEF_SCHEMA_HINT = {
     escenas: [{ id: string, nombre: string, promptHint: string }]
   }`
 };
-var ParamsSchema17 = import_zod52.z.object({
-  tenantId: import_zod52.z.string().min(1).describe("Tenant identifier (the business account)."),
-  brandId: import_zod52.z.string().min(1).describe("Brand identifier within the tenant.")
+var ParamsSchema20 = import_zod55.z.object({
+  tenantId: import_zod55.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod55.z.string().min(1).describe("Brand identifier within the tenant.")
 });
-var OutputSchema17 = import_zod52.z.discriminatedUnion("ok", [
-  import_zod52.z.object({
-    ok: import_zod52.z.literal(true),
+var OutputSchema20 = import_zod55.z.discriminatedUnion("ok", [
+  import_zod55.z.object({
+    ok: import_zod55.z.literal(true),
     /** Payload con instrucción + datos del negocio para que Claude genere el brief. */
-    payload: import_zod52.z.record(import_zod52.z.string(), import_zod52.z.unknown())
+    payload: import_zod55.z.record(import_zod55.z.string(), import_zod55.z.unknown())
   }),
-  import_zod52.z.object({
-    ok: import_zod52.z.literal(false),
-    error: import_zod52.z.string(),
-    code: import_zod52.z.enum(["BRAND_NOT_FOUND"]).optional()
+  import_zod55.z.object({
+    ok: import_zod55.z.literal(false),
+    error: import_zod55.z.string(),
+    code: import_zod55.z.enum(["BRAND_NOT_FOUND"]).optional()
   })
 ]);
-var rawContract17 = {
+var rawContract20 = {
   name: "generate_brand_brief",
   description: "Aggregate business data (Shopify, SEO, GBP, scraped site_content, brand config, tenant locations) into a payload to generate a pre-filled Brand Brief. Read-only \u2014 does NOT write the brief; the caller saves it via save_brand_brief.",
-  paramsSchema: ParamsSchema17,
-  outputSchema: OutputSchema17,
+  paramsSchema: ParamsSchema20,
+  outputSchema: OutputSchema20,
   // Lectura pura, sin side effects de escritura ni publicación.
   requiresConfirmation: false,
   destructive: false,
@@ -13525,7 +13840,7 @@ var rawContract17 = {
   sideEffects: ["reads_firestore"]
 };
 var brandBriefBuilderContract = MartinContractSchema.parse(
-  rawContract17
+  rawContract20
 );
 async function resolveLastImportId(db, tenantId, brandId) {
   const configSnap = await db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId).get();
@@ -13713,28 +14028,28 @@ var BLOG_STRATEGY_REGLAS = [
   "blogId, handle, title, ultimoPostFecha, ultimoPostKeyword, totalArticulos \u2014 copiar del shopifyBlogs (datos reales del import)",
   "defaultBlogId y defaultBlogHandle \u2014 usar el primer blog de la lista"
 ];
-var ParamsSchema18 = import_zod53.z.object({
-  tenantId: import_zod53.z.string().min(1).describe("Tenant identifier (the business account)."),
-  brandId: import_zod53.z.string().min(1).describe("Brand identifier within the tenant.")
+var ParamsSchema21 = import_zod56.z.object({
+  tenantId: import_zod56.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod56.z.string().min(1).describe("Brand identifier within the tenant.")
 });
-var OutputSchema18 = import_zod53.z.discriminatedUnion("ok", [
-  import_zod53.z.object({
-    ok: import_zod53.z.literal(true),
-    payload: import_zod53.z.record(import_zod53.z.string(), import_zod53.z.unknown()).describe(
+var OutputSchema21 = import_zod56.z.discriminatedUnion("ok", [
+  import_zod56.z.object({
+    ok: import_zod56.z.literal(true),
+    payload: import_zod56.z.record(import_zod56.z.string(), import_zod56.z.unknown()).describe(
       "Aggregated business data + instructions + schema hints for the LLM to generate a marketing plan. Includes seoSnapshot, productos, historialReciente, shopifyColecciones, shopifyBlogs, brandBrief, planActual, and schema/rules hints for coleccionesPriorizadas and blogStrategy."
     )
   }),
-  import_zod53.z.object({
-    ok: import_zod53.z.literal(false),
-    error: import_zod53.z.string(),
-    code: import_zod53.z.enum(["BRAND_NOT_FOUND", "SEO_SNAPSHOT_MISSING"]).optional()
+  import_zod56.z.object({
+    ok: import_zod56.z.literal(false),
+    error: import_zod56.z.string(),
+    code: import_zod56.z.enum(["BRAND_NOT_FOUND", "SEO_SNAPSHOT_MISSING"]).optional()
   })
 ]);
-var rawContract18 = {
+var rawContract21 = {
   name: "generate_marketing_plan",
   description: "Aggregate business data (seoSnapshot, productos, brand config, brandBrief, historial, Shopify collections + blogs) into a payload for the LLM to generate a marketing plan. Read-only \u2014 does NOT save the plan. The caller saves via save_marketing_plan or update_marketing_plan_field after generating. Requires an existing seoSnapshot on the brand (returns SEO_SNAPSHOT_MISSING otherwise).",
-  paramsSchema: ParamsSchema18,
-  outputSchema: OutputSchema18,
+  paramsSchema: ParamsSchema21,
+  outputSchema: OutputSchema21,
   // Lectura pura, no muta nada.
   requiresConfirmation: false,
   destructive: false,
@@ -13759,7 +14074,7 @@ var rawContract18 = {
   sideEffects: ["reads_firestore"]
 };
 var marketingPlanBuilderContract = MartinContractSchema.parse(
-  rawContract18
+  rawContract21
 );
 function buildGenId() {
   return `mkt_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
@@ -13776,6 +14091,7 @@ async function contenidoWriter(input) {
     fotoId,
     datos,
     calendarioItemRef,
+    actor,
     linkPipeline
   } = input;
   const configSnap = await db.collection("tenants").doc(tenantId).collection("marketing_config").doc(brandId).get();
@@ -13819,7 +14135,7 @@ async function contenidoWriter(input) {
       await db.doc(`tenants/${tenantId}/marketing_contenido/${existente.id}`).update({
         estado: "descartado",
         rechazadoMotivo: "Reemplazado por contenido nuevo para el mismo slot",
-        rechazadoAt: import_firebase_admin12.firestore.FieldValue.serverTimestamp()
+        rechazadoAt: import_firebase_admin14.firestore.FieldValue.serverTimestamp()
       });
       descartados++;
     }
@@ -13878,8 +14194,13 @@ async function contenidoWriter(input) {
     mediaUrl: null,
     calendarioItemRef: calendarioItemRef ?? null,
     datos,
-    creadoAt: import_firebase_admin12.firestore.FieldValue.serverTimestamp(),
-    creadoPorId: "mcp-cowork",
+    creadoAt: import_firebase_admin14.firestore.FieldValue.serverTimestamp(),
+    // Decisión canónica §9.2 PLAN_C2: actor real desde ctx.user (NO
+    // 'mcp-cowork' hardcoded). Reportado en smoke 1.0.86 final.
+    creadoPorId: actor.uid,
+    creadoPorNombre: actor.nombre,
+    creadoPorClient: actor.clientType,
+    creadoPorClientMetadata: actor.clientMetadata ?? null,
     origen: "ai_assisted"
   });
   const contenidoRef = db.doc(`tenants/${tenantId}/marketing_contenido/${id}`);
@@ -13936,7 +14257,7 @@ async function contenidoWriter(input) {
       tx.create(contenidoRef, contenido);
       tx.update(calDocRef, {
         semanas,
-        updatedAt: import_firebase_admin12.firestore.FieldValue.serverTimestamp()
+        updatedAt: import_firebase_admin14.firestore.FieldValue.serverTimestamp()
       });
     });
   } else {
@@ -14000,54 +14321,60 @@ async function contenidoWriter(input) {
     pipelineLinked
   };
 }
-var ParamsSchema19 = import_zod54.z.object({
-  tenantId: import_zod54.z.string().min(1).describe("Tenant identifier (the business account)."),
-  brandId: import_zod54.z.string().min(1).describe("Brand identifier within the tenant."),
-  plataforma: import_zod54.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Target platform for the content."),
-  tipo: import_zod54.z.string().optional().describe(
+var ParamsSchema22 = import_zod57.z.object({
+  tenantId: import_zod57.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod57.z.string().min(1).describe("Brand identifier within the tenant."),
+  plataforma: import_zod57.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Target platform for the content."),
+  tipo: import_zod57.z.string().optional().describe(
     "Content type ('post', 'blog', 'carousel', 'reel', 'story', 'review_response'). Match to the platform."
   ),
-  keyword: import_zod54.z.string().optional().describe("Primary keyword for the content. OMIT if not applicable."),
-  languageCode: import_zod54.z.string().optional().describe(
+  keyword: import_zod57.z.string().optional().describe("Primary keyword for the content. OMIT if not applicable."),
+  languageCode: import_zod57.z.string().optional().describe(
     "Content language code (e.g. 'es', 'en'). For shopify_blog auto-injects to datos.languageCode if not present."
   ),
-  fotoId: import_zod54.z.string().optional().describe("Linked photo ID. OMIT if no photo associated yet (use assign_photo_to_content later)."),
-  datos: import_zod54.z.record(import_zod54.z.string(), import_zod54.z.unknown()).describe(
+  fotoId: import_zod57.z.string().optional().describe("Linked photo ID. OMIT if no photo associated yet (use assign_photo_to_content later)."),
+  datos: import_zod57.z.record(import_zod57.z.string(), import_zod57.z.unknown()).describe(
     "Platform-specific content payload. Validated against Blog/GBP/IG/Review schemas. Use buildDatosBlog/GBP/IG/Review helpers to construct safely."
   ),
-  calendarioItemRef: import_zod54.z.string().optional().describe(
+  calendarioItemRef: import_zod57.z.string().optional().describe(
     'Calendar slot reference (format "semana:N:slot:M"). If provided, links content to that slot AND discards prior non-discarded content of the same slot.'
-  )
+  ),
+  actor: import_zod57.z.object({
+    uid: import_zod57.z.string().min(1).describe('User id who is creating the content. Example: "your-user-uid".'),
+    nombre: import_zod57.z.string().min(1).describe('Human-readable user name. Example: "Daniel Gonz\xE1lez".'),
+    clientType: import_zod57.z.string().min(1).describe('Client surface origin. Example: one of "mcp_client" | "martin" | "web" | "admin".'),
+    clientMetadata: import_zod57.z.record(import_zod57.z.string(), import_zod57.z.unknown()).nullable().optional().describe("Optional metadata about the client (session id, device, etc.).")
+  }).describe("Actor (user) creating the content \u2014 extracted by the server.tool from ctx.user (\xA79.2).")
 });
-var PipelineLinkResultSchema = import_zod54.z.object({
-  linked: import_zod54.z.boolean(),
-  paso: import_zod54.z.string().nullable(),
-  motivo: import_zod54.z.string().optional(),
-  code: import_zod54.z.string().optional(),
-  _instrucciones: import_zod54.z.string().optional()
+var PipelineLinkResultSchema = import_zod57.z.object({
+  linked: import_zod57.z.boolean(),
+  paso: import_zod57.z.string().nullable(),
+  motivo: import_zod57.z.string().optional(),
+  code: import_zod57.z.string().optional(),
+  _instrucciones: import_zod57.z.string().optional()
 });
-var OutputSchema19 = import_zod54.z.discriminatedUnion("ok", [
-  import_zod54.z.object({
-    ok: import_zod54.z.literal(true),
-    contenidoId: import_zod54.z.string(),
-    estado: import_zod54.z.string(),
-    plataforma: import_zod54.z.enum(["gbp", "shopify_blog", "instagram", "review"]),
-    descartados: import_zod54.z.number().int().nonnegative(),
+var OutputSchema22 = import_zod57.z.discriminatedUnion("ok", [
+  import_zod57.z.object({
+    ok: import_zod57.z.literal(true),
+    contenidoId: import_zod57.z.string(),
+    estado: import_zod57.z.string(),
+    plataforma: import_zod57.z.enum(["gbp", "shopify_blog", "instagram", "review"]),
+    descartados: import_zod57.z.number().int().nonnegative(),
     pipelineLinked: PipelineLinkResultSchema
   }),
-  import_zod54.z.object({
-    ok: import_zod54.z.literal(false),
-    error: import_zod54.z.string(),
-    code: import_zod54.z.enum(["CONTENT_FREQUENCY_LIMIT", "CONTENT_DATA_VALIDATION_FAILED"]).optional(),
-    activosEstaSemana: import_zod54.z.number().int().optional(),
-    limite: import_zod54.z.number().int().optional()
+  import_zod57.z.object({
+    ok: import_zod57.z.literal(false),
+    error: import_zod57.z.string(),
+    code: import_zod57.z.enum(["CONTENT_FREQUENCY_LIMIT", "CONTENT_DATA_VALIDATION_FAILED"]).optional(),
+    activosEstaSemana: import_zod57.z.number().int().optional(),
+    limite: import_zod57.z.number().int().optional()
   })
 ]);
-var rawContract19 = {
+var rawContract22 = {
   name: "save_generated_content",
   description: "Save newly generated marketing content to marketing_contenido. The content is saved as pendiente_aprobacion \u2014 it is NOT published until the tenant approves it. Enforces weekly frequency limits per platform. If calendarioItemRef is provided, links to the slot and discards any prior content of the same slot. Validates datos against the platform schema.",
-  paramsSchema: ParamsSchema19,
-  outputSchema: OutputSchema19,
+  paramsSchema: ParamsSchema22,
+  outputSchema: OutputSchema22,
   // Crea borrador + descarta borrador previo del mismo slot. Reversible
   // (volver a llamar con datos corregidos crea un nuevo borrador y descarta
   // el actual). NO publica nada externo — la CF de publish se encarga
@@ -14092,7 +14419,7 @@ var rawContract19 = {
   sideEffects: ["writes_firestore", "updates_calendar_slot"]
 };
 var contenidoWriterContract = MartinContractSchema.parse(
-  rawContract19
+  rawContract22
 );
 function fmtDate(d) {
   const y = d.getFullYear();
@@ -14127,7 +14454,7 @@ function generarEstructuraCalendario(mes) {
   return semanas;
 }
 async function weeklyContentBuilder(input) {
-  const { db, tenantId, brandId, semana, modo } = input;
+  const { db, tenantId, brandId, semana, modo, actor } = input;
   const targetModo = modo ?? "planificar";
   const now2 = /* @__PURE__ */ new Date();
   const targetMes = now2.toISOString().slice(0, 7);
@@ -14148,8 +14475,12 @@ async function weeklyContentBuilder(input) {
       brandId,
       mes: targetMes,
       semanas,
-      creadoAt: import_firebase_admin13.firestore.FieldValue.serverTimestamp(),
-      creadoPorId: "mcp-cowork",
+      creadoAt: import_firebase_admin15.firestore.FieldValue.serverTimestamp(),
+      // §9.2 PLAN_C2 — actor real desde ctx.user (NO 'mcp-cowork' hardcoded).
+      creadoPorId: actor.uid,
+      creadoPorNombre: actor.nombre,
+      creadoPorClient: actor.clientType,
+      creadoPorClientMetadata: actor.clientMetadata ?? null,
       updatedAt: null
     };
     await db.doc(`tenants/${tenantId}/marketing_calendario/${calId}`).set(calDoc);
@@ -14367,34 +14698,40 @@ OBLIGATORIO: calendarioItemRef con formato EXACTO "semana:N:slot:M" (ej: "semana
 OBLIGATORIO: fotoId \u2014 SIEMPRE pasa el ID de la foto que elegiste con get_photos_for_slot.
 Si el slot tiene notas[], LEERLAS y usarlas como contexto. Si estado es revisar, regenerar adaptando a las notas.
 BLOG SLOTS: Usa _blogJIT para el contexto de cada slot shopify_blog \u2014 blogTarget, tono, author, articulosExistentes para interlinking.`;
-var ParamsSchema20 = import_zod55.z.object({
-  tenantId: import_zod55.z.string().min(1).describe("Tenant identifier (the business account)."),
-  brandId: import_zod55.z.string().min(1).describe("Brand identifier within the tenant."),
-  semana: import_zod55.z.number().int().min(1).max(5).optional().describe(
+var ParamsSchema23 = import_zod58.z.object({
+  tenantId: import_zod58.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod58.z.string().min(1).describe("Brand identifier within the tenant."),
+  semana: import_zod58.z.number().int().min(1).max(5).optional().describe(
     "Week number within the current month (1-5). OMIT to default to the current week inferred from today."
   ),
-  modo: import_zod55.z.enum(["planificar", "generar"]).optional().describe(
+  modo: import_zod58.z.enum(["planificar", "generar"]).optional().describe(
     "Operation mode. 'planificar' (default): propose distribution platform+keyword+tipo per day. 'generar': requires slots in pre_aprobado/revisar \u2014 generate actual content. OMIT to default to 'planificar'."
-  )
+  ),
+  actor: import_zod58.z.object({
+    uid: import_zod58.z.string().min(1).describe('User id who is generating the weekly content. Example: "your-user-uid".'),
+    nombre: import_zod58.z.string().min(1).describe('Human-readable user name. Example: "Daniel Gonz\xE1lez".'),
+    clientType: import_zod58.z.string().min(1).describe('Client surface origin. Example: one of "mcp_client" | "martin" | "web" | "admin".'),
+    clientMetadata: import_zod58.z.record(import_zod58.z.string(), import_zod58.z.unknown()).nullable().optional().describe("Optional metadata about the client.")
+  }).describe("Actor (user) generating the weekly content \u2014 extracted by the server.tool from ctx.user (\xA79.2). Used when auto-creating marketing_calendario doc.")
 });
-var OutputSchema20 = import_zod55.z.discriminatedUnion("ok", [
-  import_zod55.z.object({
-    ok: import_zod55.z.literal(true),
-    payload: import_zod55.z.record(import_zod55.z.string(), import_zod55.z.unknown()).describe(
+var OutputSchema23 = import_zod58.z.discriminatedUnion("ok", [
+  import_zod58.z.object({
+    ok: import_zod58.z.literal(true),
+    payload: import_zod58.z.record(import_zod58.z.string(), import_zod58.z.unknown()).describe(
       "Aggregated context for the LLM. Shape varies by modo: 'planificar' returns brand skeleton + slotsYaExistentes + historial; 'generar' returns slotsParaGenerar + fotosDisponibles + brand.blogStrategy + blogJIT (if blog slots present)."
     )
   }),
-  import_zod55.z.object({
-    ok: import_zod55.z.literal(false),
-    error: import_zod55.z.string(),
-    code: import_zod55.z.enum(["BRAND_NOT_FOUND", "WEEK_HAS_NO_SLOTS"]).optional()
+  import_zod58.z.object({
+    ok: import_zod58.z.literal(false),
+    error: import_zod58.z.string(),
+    code: import_zod58.z.enum(["BRAND_NOT_FOUND", "WEEK_HAS_NO_SLOTS"]).optional()
   })
 ]);
-var rawContract20 = {
+var rawContract23 = {
   name: "generate_weekly_content",
   description: "Build the week's content. Two modes: 'planificar' aggregates context for the LLM to propose distribution (LLM then uses add_calendar_slot/update_calendar_slot per day); 'generar' returns pre-approved slots + photos + blog JIT context for the LLM to generate actual content (LLM then calls save_generated_content per slot). AUTO-CREATES the monthly marketing_calendario if it does not exist. NEVER generates content directly \u2014 always returns a payload for the LLM consumer.",
-  paramsSchema: ParamsSchema20,
-  outputSchema: OutputSchema20,
+  paramsSchema: ParamsSchema23,
+  outputSchema: OutputSchema23,
   // Auto-create de calendario es bootstrap reversible (volver a llamar usa el
   // calendario existente). NO publica nada externo. modo='generar' tampoco
   // publica — solo prepara contexto.
@@ -14439,7 +14776,7 @@ var rawContract20 = {
   sideEffects: ["reads_firestore", "writes_firestore"]
 };
 var weeklyContentBuilderContract = MartinContractSchema.parse(
-  rawContract20
+  rawContract23
 );
 var DEFAULT_TEXT_THRESHOLD = 0.35;
 var DEFAULT_IMAGE_THRESHOLD = 0.08;
@@ -14628,69 +14965,69 @@ async function contentFinder(input) {
   }
   return result;
 }
-var IncludeSchema = import_zod56.z.object({
-  products: import_zod56.z.boolean(),
-  collections: import_zod56.z.boolean(),
-  articles: import_zod56.z.boolean(),
-  pages: import_zod56.z.boolean()
+var IncludeSchema = import_zod59.z.object({
+  products: import_zod59.z.boolean(),
+  collections: import_zod59.z.boolean(),
+  articles: import_zod59.z.boolean(),
+  pages: import_zod59.z.boolean()
 }).describe(
   "Toggles for which Shopify content types to search. Default truthy for products/collections/articles, false for pages. Set false to skip a category for performance."
 );
-var LimitSchema = import_zod56.z.object({
-  products: import_zod56.z.number().int().min(0).max(20),
-  collections: import_zod56.z.number().int().min(0).max(10),
-  articles: import_zod56.z.number().int().min(0).max(20),
-  pages: import_zod56.z.number().int().min(0).max(10)
+var LimitSchema = import_zod59.z.object({
+  products: import_zod59.z.number().int().min(0).max(20),
+  collections: import_zod59.z.number().int().min(0).max(10),
+  articles: import_zod59.z.number().int().min(0).max(20),
+  pages: import_zod59.z.number().int().min(0).max(10)
 }).describe(
   "Per-category result count caps. Defaults: products 5, collections 3, articles 5, pages 2."
 );
-var ParamsSchema21 = import_zod56.z.object({
-  tenantId: import_zod56.z.string().min(1).describe("Tenant identifier (the business account)."),
-  brandId: import_zod56.z.string().min(1).describe("Brand identifier within the tenant."),
-  contexto: import_zod56.z.string().min(1).describe(
+var ParamsSchema24 = import_zod59.z.object({
+  tenantId: import_zod59.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod59.z.string().min(1).describe("Brand identifier within the tenant."),
+  contexto: import_zod59.z.string().min(1).describe(
     "Search context: a paragraph, keyword, or intent string. Embedded for vector search."
   ),
-  fecha: import_zod56.z.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe(
+  fecha: import_zod59.z.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe(
     "Content date in YYYY-MM-DD. Used to detect active season and prioritize matching collections."
   ),
   include: IncludeSchema,
   limit: LimitSchema,
-  diversidad: import_zod56.z.boolean().describe(
+  diversidad: import_zod59.z.boolean().describe(
     "Whether to apply Jaccard title diversification + handle dedupe to results. Default true."
   ),
-  mode: import_zod56.z.enum(["text", "hybrid"]).optional().describe(
+  mode: import_zod59.z.enum(["text", "hybrid"]).optional().describe(
     "Search mode. 'text' (default): single query per collection against embeddingText, fast. 'hybrid': parallel text + image queries with Reciprocal Rank Fusion, 2x queries \u2014 useful when text mode returns few results or to surface visually-similar items with weak SEO."
   )
 });
-var VectorResultSchema = import_zod56.z.object({
-  id: import_zod56.z.string(),
-  similarity: import_zod56.z.number().optional()
+var VectorResultSchema = import_zod59.z.object({
+  id: import_zod59.z.string(),
+  similarity: import_zod59.z.number().optional()
 }).passthrough();
-var TemporadaSchema2 = import_zod56.z.object({
-  coleccion: import_zod56.z.string().nullable(),
-  titulo: import_zod56.z.string().nullable(),
-  razon: import_zod56.z.string().nullable(),
-  fechaInicio: import_zod56.z.string().nullable(),
-  fechaFin: import_zod56.z.string().nullable()
+var TemporadaSchema2 = import_zod59.z.object({
+  coleccion: import_zod59.z.string().nullable(),
+  titulo: import_zod59.z.string().nullable(),
+  razon: import_zod59.z.string().nullable(),
+  fechaInicio: import_zod59.z.string().nullable(),
+  fechaFin: import_zod59.z.string().nullable()
 });
-var SuggestedActionSchema22 = import_zod56.z.record(import_zod56.z.string(), import_zod56.z.unknown());
-var DetectedConflictSchema22 = import_zod56.z.record(import_zod56.z.string(), import_zod56.z.unknown());
-var OutputSchema21 = import_zod56.z.object({
-  productos: import_zod56.z.array(VectorResultSchema),
-  colecciones: import_zod56.z.array(VectorResultSchema),
-  articles: import_zod56.z.array(VectorResultSchema),
-  pages: import_zod56.z.array(VectorResultSchema),
-  _instrucciones: import_zod56.z.string(),
-  _negativePrompt: import_zod56.z.string(),
+var SuggestedActionSchema22 = import_zod59.z.record(import_zod59.z.string(), import_zod59.z.unknown());
+var DetectedConflictSchema22 = import_zod59.z.record(import_zod59.z.string(), import_zod59.z.unknown());
+var OutputSchema24 = import_zod59.z.object({
+  productos: import_zod59.z.array(VectorResultSchema),
+  colecciones: import_zod59.z.array(VectorResultSchema),
+  articles: import_zod59.z.array(VectorResultSchema),
+  pages: import_zod59.z.array(VectorResultSchema),
+  _instrucciones: import_zod59.z.string(),
+  _negativePrompt: import_zod59.z.string(),
   _temporadaActiva: TemporadaSchema2.nullable(),
   _detectedConflict: DetectedConflictSchema22.optional(),
-  _suggestedActions: import_zod56.z.array(SuggestedActionSchema22)
+  _suggestedActions: import_zod59.z.array(SuggestedActionSchema22)
 });
-var rawContract21 = {
+var rawContract24 = {
   name: "find_content_for_topic",
   description: "Find Shopify content (products, collections, articles, pages) semantically related to a context/keyword + date. Uses multimodal vector search (1408d Vertex). Mode 'text' (default) queries embeddingText (fast); 'hybrid' merges text + image results via Reciprocal Rank Fusion (rescues items with weak text SEO). Auto-injects JIT context: linking instructions, brand visual negatives, active season collection, and conflict detection (>85% similar article).",
-  paramsSchema: ParamsSchema21,
-  outputSchema: OutputSchema21,
+  paramsSchema: ParamsSchema24,
+  outputSchema: OutputSchema24,
   // Lectura pura (vector search). Failures internas en search degradan a
   // arrays vacíos — el helper NO falla.
   requiresConfirmation: false,
@@ -14713,7 +15050,7 @@ var rawContract21 = {
   sideEffects: ["reads_firestore"]
 };
 var contentFinderContract = MartinContractSchema.parse(
-  rawContract21
+  rawContract24
 );
 var DEFAULT_PHOTO_THRESHOLD = 0.7;
 var DEFAULT_SHOPIFY_THRESHOLD = 0.65;
@@ -14860,51 +15197,51 @@ async function slotAssetFinder(input) {
     _fuente: fuente
   };
 }
-var ParamsSchema22 = import_zod57.z.object({
-  tenantId: import_zod57.z.string().min(1).describe("Tenant identifier (the business account)."),
-  brandId: import_zod57.z.string().min(1).describe("Brand identifier within the tenant."),
-  keyword: import_zod57.z.string().min(1).describe(
+var ParamsSchema25 = import_zod60.z.object({
+  tenantId: import_zod60.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod60.z.string().min(1).describe("Brand identifier within the tenant."),
+  keyword: import_zod60.z.string().min(1).describe(
     "Slot keyword to search photos for. Used as embedding query for multimodal vector search."
   ),
-  plataforma: import_zod57.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe(
+  plataforma: import_zod60.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe(
     "Target platform \u2014 determines the variant format to resolve (gbp_4_3, blog_3_2, ig_4_5, ig_1_1)."
   ),
-  fecha: import_zod57.z.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe(
+  fecha: import_zod60.z.string().regex(/^\d{4}-\d{2}-\d{2}$/).describe(
     "Slot date in YYYY-MM-DD. Used to detect active season and apply seasonal catalog overrides."
   ),
-  limit: import_zod57.z.number().int().min(1).max(10).optional().describe("Max number of photos to return. Default 5. Max 10.")
+  limit: import_zod60.z.number().int().min(1).max(10).optional().describe("Max number of photos to return. Default 5. Max 10.")
 });
-var TemporadaSchema22 = import_zod57.z.object({
-  coleccion: import_zod57.z.string().nullable(),
-  titulo: import_zod57.z.string().nullable(),
-  razon: import_zod57.z.string().nullable(),
-  fechaInicio: import_zod57.z.string().nullable(),
-  fechaFin: import_zod57.z.string().nullable()
+var TemporadaSchema22 = import_zod60.z.object({
+  coleccion: import_zod60.z.string().nullable(),
+  titulo: import_zod60.z.string().nullable(),
+  razon: import_zod60.z.string().nullable(),
+  fechaInicio: import_zod60.z.string().nullable(),
+  fechaFin: import_zod60.z.string().nullable()
 });
-var OutputSchema22 = import_zod57.z.discriminatedUnion("ok", [
+var OutputSchema25 = import_zod60.z.discriminatedUnion("ok", [
   // Note: success case does not include `ok: true` literal in helper return —
   // helper returns the success shape directly. Adapter to discriminated union
   // happens at wrapper level if needed; here we accept both shapes.
-  import_zod57.z.object({
-    ok: import_zod57.z.literal(true),
-    fotos: import_zod57.z.array(import_zod57.z.record(import_zod57.z.string(), import_zod57.z.unknown())),
-    _instrucciones: import_zod57.z.string(),
-    _negativePrompt: import_zod57.z.string(),
+  import_zod60.z.object({
+    ok: import_zod60.z.literal(true),
+    fotos: import_zod60.z.array(import_zod60.z.record(import_zod60.z.string(), import_zod60.z.unknown())),
+    _instrucciones: import_zod60.z.string(),
+    _negativePrompt: import_zod60.z.string(),
     _temporadaActiva: TemporadaSchema22.nullable(),
-    _bloqueoProducto: import_zod57.z.boolean(),
-    _fuente: import_zod57.z.enum(["tenant", "shopify_product"])
+    _bloqueoProducto: import_zod60.z.boolean(),
+    _fuente: import_zod60.z.enum(["tenant", "shopify_product"])
   }),
-  import_zod57.z.object({
-    ok: import_zod57.z.literal(false),
-    error: import_zod57.z.string(),
-    code: import_zod57.z.enum(["BRAND_NOT_FOUND"]).optional()
+  import_zod60.z.object({
+    ok: import_zod60.z.literal(false),
+    error: import_zod60.z.string(),
+    code: import_zod60.z.enum(["BRAND_NOT_FOUND"]).optional()
   })
 ]);
-var rawContract22 = {
+var rawContract25 = {
   name: "get_photos_for_slot",
   description: "Find tenant photos for a calendar slot (keyword + platform + date) via multimodal vector search (1408d Vertex). Resolves the platform-specific variant (gbp_4_3/blog_3_2/ig_4_5/ig_1_1). Auto-injects JIT context: how to choose, brand visual negatives, active season overrides, and source layer (tenant photos vs Shopify product fallback). If <3 photos returned, consider calling request_photo_shoot to alert the tenant.",
-  paramsSchema: ParamsSchema22,
-  outputSchema: OutputSchema22,
+  paramsSchema: ParamsSchema25,
+  outputSchema: OutputSchema25,
   requiresConfirmation: false,
   destructive: false,
   affectsPublication: false,
@@ -14931,7 +15268,7 @@ var rawContract22 = {
   sideEffects: ["reads_firestore"]
 };
 var slotAssetFinderContract = MartinContractSchema.parse(
-  rawContract22
+  rawContract25
 );
 var DEFAULT_SIMILARITY_THRESHOLD = 0.6;
 function cosineSimilarity(a, b) {
@@ -15008,44 +15345,44 @@ async function canvaTemplateSelector(input) {
     _instrucciones: "Plantilla Canva seleccionada. Llama a marketingDesignWithCanva({contenidoId, plantillaId, fotoVariantePath, textos}) para renderizar la pieza final."
   };
 }
-var ParamsSchema23 = import_zod58.z.object({
-  tenantId: import_zod58.z.string().min(1).describe("Tenant identifier (the business account)."),
-  brandId: import_zod58.z.string().min(1).describe("Brand identifier within the tenant."),
-  plataforma: import_zod58.z.string().min(1).describe(
+var ParamsSchema26 = import_zod61.z.object({
+  tenantId: import_zod61.z.string().min(1).describe("Tenant identifier (the business account)."),
+  brandId: import_zod61.z.string().min(1).describe("Brand identifier within the tenant."),
+  plataforma: import_zod61.z.string().min(1).describe(
     "Target platform (e.g. 'gbp', 'shopify_blog', 'instagram'). Filters templates that declare this plataforma."
   ),
-  tipoContenido: import_zod58.z.string().min(1).describe(
+  tipoContenido: import_zod61.z.string().min(1).describe(
     "Content type (e.g. 'post', 'carousel', 'story', 'blog'). Filters templates that declare this tipoContenido."
   ),
-  keyword: import_zod58.z.string().min(1).describe("Slot keyword. Used as embedding query for cosine similarity match.")
+  keyword: import_zod61.z.string().min(1).describe("Slot keyword. Used as embedding query for cosine similarity match.")
 });
-var OutputSchema23 = import_zod58.z.union([
-  import_zod58.z.object({
-    plantillaId: import_zod58.z.string(),
-    titulo: import_zod58.z.string().nullable(),
-    thumbnailUrl: import_zod58.z.string().nullable(),
-    similarity: import_zod58.z.number(),
-    _instrucciones: import_zod58.z.string()
+var OutputSchema26 = import_zod61.z.union([
+  import_zod61.z.object({
+    plantillaId: import_zod61.z.string(),
+    titulo: import_zod61.z.string().nullable(),
+    thumbnailUrl: import_zod61.z.string().nullable(),
+    similarity: import_zod61.z.number(),
+    _instrucciones: import_zod61.z.string()
   }),
-  import_zod58.z.object({
-    plantillaId: import_zod58.z.null(),
-    motivo: import_zod58.z.enum([
+  import_zod61.z.object({
+    plantillaId: import_zod61.z.null(),
+    motivo: import_zod61.z.enum([
       "brand_no_encontrada",
       "no_canva",
       "no_match_plataforma",
       "modo_cliente_no_soportado",
       "similarity_baja"
     ]),
-    similarity: import_zod58.z.number().optional(),
-    _instrucciones: import_zod58.z.string().optional(),
-    _todo: import_zod58.z.string().optional()
+    similarity: import_zod61.z.number().optional(),
+    _instrucciones: import_zod61.z.string().optional(),
+    _todo: import_zod61.z.string().optional()
   })
 ]);
-var rawContract23 = {
+var rawContract26 = {
   name: "select_canva_template",
   description: "Select the best Canva template from the tenant for a slot. Filters templates by plataforma+tipoContenido, then cosine-similarity matches embeddings vs the keyword query. Returns plantillaId on match (similarity >= 0.60). On miss returns plantillaId=null with motivo enum (no_canva, no_match_plataforma, modo_cliente_no_soportado, similarity_baja, brand_no_encontrada). The LLM should degrade gracefully (generate without Canva template) on any miss.",
-  paramsSchema: ParamsSchema23,
-  outputSchema: OutputSchema23,
+  paramsSchema: ParamsSchema26,
+  outputSchema: OutputSchema26,
   // Lectura pura. NO falla — todo "no encontré" es resultado válido del helper.
   requiresConfirmation: false,
   destructive: false,
@@ -15072,7 +15409,7 @@ var rawContract23 = {
   sideEffects: ["reads_firestore"]
 };
 var canvaTemplateSelectorContract = MartinContractSchema.parse(
-  rawContract23
+  rawContract26
 );
 function buildDirectorPlanInstrucciones(catalogoVisual) {
   const etiquetas = catalogoVisual.etiquetas || {};
@@ -15296,38 +15633,38 @@ async function photoDirectorExecute(input) {
     _instrucciones: buildDirectorExecuteSuccessInstrucciones(result.balanceAfter)
   };
 }
-var PlanParamsSchema = import_zod59.z.object({
-  tenantId: import_zod59.z.string().min(1).describe("Tenant identifier (the business account)."),
-  fotoId: import_zod59.z.string().min(1).describe("Photo ID in marketing_fotos. The photo must have an archivoOriginal uploaded.")
+var PlanParamsSchema = import_zod62.z.object({
+  tenantId: import_zod62.z.string().min(1).describe("Tenant identifier (the business account)."),
+  fotoId: import_zod62.z.string().min(1).describe("Photo ID in marketing_fotos. The photo must have an archivoOriginal uploaded.")
 });
-var PlanContextSchema = import_zod59.z.object({
-  fotoId: import_zod59.z.string(),
-  archivoOriginal: import_zod59.z.string(),
-  estrategia: import_zod59.z.string(),
-  brandBrief: import_zod59.z.object({
-    segmento: import_zod59.z.string().nullable(),
-    personalidad: import_zod59.z.unknown().nullable()
+var PlanContextSchema = import_zod62.z.object({
+  fotoId: import_zod62.z.string(),
+  archivoOriginal: import_zod62.z.string(),
+  estrategia: import_zod62.z.string(),
+  brandBrief: import_zod62.z.object({
+    segmento: import_zod62.z.string().nullable(),
+    personalidad: import_zod62.z.unknown().nullable()
   }),
-  visualRules: import_zod59.z.record(import_zod59.z.string(), import_zod59.z.unknown()),
-  catalogoVisual: import_zod59.z.record(import_zod59.z.string(), import_zod59.z.unknown()),
-  estiloVisual: import_zod59.z.unknown().nullable(),
-  notaTenant: import_zod59.z.unknown().nullable(),
-  productoLinkeadoManual: import_zod59.z.unknown().nullable(),
-  _instrucciones: import_zod59.z.string()
+  visualRules: import_zod62.z.record(import_zod62.z.string(), import_zod62.z.unknown()),
+  catalogoVisual: import_zod62.z.record(import_zod62.z.string(), import_zod62.z.unknown()),
+  estiloVisual: import_zod62.z.unknown().nullable(),
+  notaTenant: import_zod62.z.unknown().nullable(),
+  productoLinkeadoManual: import_zod62.z.unknown().nullable(),
+  _instrucciones: import_zod62.z.string()
 });
-var PlanOutputSchema = import_zod59.z.discriminatedUnion("ok", [
-  import_zod59.z.object({
-    ok: import_zod59.z.literal(true),
-    imageBase64: import_zod59.z.string().describe("Compressed photo as base64 for transport to the LLM."),
+var PlanOutputSchema = import_zod62.z.discriminatedUnion("ok", [
+  import_zod62.z.object({
+    ok: import_zod62.z.literal(true),
+    imageBase64: import_zod62.z.string().describe("Compressed photo as base64 for transport to the LLM."),
     context: PlanContextSchema
   }),
-  import_zod59.z.object({
-    ok: import_zod59.z.literal(false),
-    code: import_zod59.z.string(),
-    error: import_zod59.z.string(),
-    _instrucciones: import_zod59.z.string().optional(),
-    fix: import_zod59.z.string().optional(),
-    fotoId: import_zod59.z.string().optional()
+  import_zod62.z.object({
+    ok: import_zod62.z.literal(false),
+    code: import_zod62.z.string(),
+    error: import_zod62.z.string(),
+    _instrucciones: import_zod62.z.string().optional(),
+    fix: import_zod62.z.string().optional(),
+    fotoId: import_zod62.z.string().optional()
   })
 ]);
 var planRawContract = {
@@ -15357,43 +15694,43 @@ var planRawContract = {
 var photoDirectorPlanContract = MartinContractSchema.parse(
   planRawContract
 );
-var ExecuteParamsSchema = import_zod59.z.object({
+var ExecuteParamsSchema = import_zod62.z.object({
   // tenantId is injected by the wrapper from ctx (A7 module-scope pattern,
   // even though the helper function itself derives tenantId via the foto's
   // brandId). Needed here for extractTargetPath canonical path.
-  tenantId: import_zod59.z.string().min(1).describe("Tenant identifier (the business account)."),
-  fotoId: import_zod59.z.string().min(1).describe("Photo ID to edit (must have been planned via plan_photo_edit)."),
-  prompt: import_zod59.z.string().nullable().describe(
+  tenantId: import_zod62.z.string().min(1).describe("Tenant identifier (the business account)."),
+  fotoId: import_zod62.z.string().min(1).describe("Photo ID to edit (must have been planned via plan_photo_edit)."),
+  prompt: import_zod62.z.string().nullable().describe(
     "English prompt for Gemini Image Edit when acciones includes edit_background. Pass null when strategy is 'tal_cual' (no editing \u2014 just regenerate thumbnail + embedding with new tags)."
   ),
-  acciones: import_zod59.z.array(import_zod59.z.enum(["edit_background", "none"])).describe(
+  acciones: import_zod62.z.array(import_zod62.z.enum(["edit_background", "none"])).describe(
     "Edit operations to perform. Use ['edit_background'] for AI background edit, ['none'] when strategy is 'tal_cual'."
   ),
-  descripcion: import_zod59.z.string().describe("Semantic description in Spanish (saved as descripcionVision on the photo)."),
-  tipo: import_zod59.z.string().nullable().describe("Photo type from the brand catalogoVisual. null only if catalog has no matching type."),
-  tagsPrimarios: import_zod59.z.array(import_zod59.z.string()).describe("Primary tags from the catalogoVisual."),
-  tagsSecundarios: import_zod59.z.array(import_zod59.z.string()).describe("Secondary tags from the catalogoVisual."),
-  tagsContexto: import_zod59.z.array(import_zod59.z.string()).describe("Contextual tags (occasion, mood, style).")
+  descripcion: import_zod62.z.string().describe("Semantic description in Spanish (saved as descripcionVision on the photo)."),
+  tipo: import_zod62.z.string().nullable().describe("Photo type from the brand catalogoVisual. null only if catalog has no matching type."),
+  tagsPrimarios: import_zod62.z.array(import_zod62.z.string()).describe("Primary tags from the catalogoVisual."),
+  tagsSecundarios: import_zod62.z.array(import_zod62.z.string()).describe("Secondary tags from the catalogoVisual."),
+  tagsContexto: import_zod62.z.array(import_zod62.z.string()).describe("Contextual tags (occasion, mood, style).")
 });
-var ExecuteOutputSchema = import_zod59.z.discriminatedUnion("ok", [
-  import_zod59.z.object({
-    ok: import_zod59.z.literal(true),
-    fotoId: import_zod59.z.string(),
-    archivoEditado: import_zod59.z.string().optional(),
-    thumbnailUrl: import_zod59.z.string().optional(),
-    iteracion: import_zod59.z.number().optional(),
-    editCosto: import_zod59.z.number().optional(),
-    creditsConsumed: import_zod59.z.number().optional(),
-    balanceAfter: import_zod59.z.number().optional(),
-    imageBase64: import_zod59.z.string().nullable(),
-    _instrucciones: import_zod59.z.string()
+var ExecuteOutputSchema = import_zod62.z.discriminatedUnion("ok", [
+  import_zod62.z.object({
+    ok: import_zod62.z.literal(true),
+    fotoId: import_zod62.z.string(),
+    archivoEditado: import_zod62.z.string().optional(),
+    thumbnailUrl: import_zod62.z.string().optional(),
+    iteracion: import_zod62.z.number().optional(),
+    editCosto: import_zod62.z.number().optional(),
+    creditsConsumed: import_zod62.z.number().optional(),
+    balanceAfter: import_zod62.z.number().optional(),
+    imageBase64: import_zod62.z.string().nullable(),
+    _instrucciones: import_zod62.z.string()
   }),
-  import_zod59.z.object({
-    ok: import_zod59.z.literal(false),
-    error: import_zod59.z.string(),
-    code: import_zod59.z.string(),
-    details: import_zod59.z.record(import_zod59.z.string(), import_zod59.z.unknown()).optional(),
-    _instrucciones: import_zod59.z.string()
+  import_zod62.z.object({
+    ok: import_zod62.z.literal(false),
+    error: import_zod62.z.string(),
+    code: import_zod62.z.string(),
+    details: import_zod62.z.record(import_zod62.z.string(), import_zod62.z.unknown()).optional(),
+    _instrucciones: import_zod62.z.string()
   })
 ]);
 var executeRawContract = {
@@ -16050,6 +16387,15 @@ function callPhotoBriefingWriter(input) {
 function callTenantContextSetter(input) {
   return callCF("marketingTenantContextSetterCallable", input);
 }
+function callPhotoDescarter(input) {
+  return callCF("marketingPhotoDescarterCallable", input);
+}
+function callPhotoEditadaMarker(input) {
+  return callCF("marketingPhotoEditadaMarkerCallable", input);
+}
+function callBrandContextSetter(input) {
+  return callCF("marketingBrandContextSetterCallable", input);
+}
 function callBrandBriefWriter(input) {
   return callCF("marketingBrandBriefWriterCallable", input);
 }
@@ -16199,8 +16545,8 @@ function registerContextTools(server, session) {
       "set_context",
       "Set the active tenant + brand for the current super_admin MCP session. Validates that the target brand exists. Available only to super_admin users.",
       {
-        tenantId: import_zod60.z.string().describe("Target tenant identifier"),
-        brandId: import_zod60.z.string().describe("Target brand identifier within the tenant")
+        tenantId: import_zod63.z.string().describe("Target tenant identifier"),
+        brandId: import_zod63.z.string().describe("Target brand identifier within the tenant")
       },
       async ({ tenantId, brandId }) => {
         const ctx = await buildContext(session, brandId);
@@ -16237,12 +16583,62 @@ function registerContextTools(server, session) {
       }
     );
   }
+  const isMultiBrand = session.brands && session.brands.length > 1;
+  const isSuperAdmin = session.canSwitchTenant;
+  if (isMultiBrand || isSuperAdmin) {
+    server.tool(
+      "select_brand",
+      "Switch the active brand within your tenant. Use when you have multi-brand access (agency mode) and want to work with a different brand without passing brandId on every tool call. Does NOT change tenant.",
+      {
+        brandId: import_zod63.z.string().describe("Target brand identifier (must be in your accessible brands list)")
+      },
+      async ({ brandId }) => {
+        const tenantId = session.requireTenant();
+        const ctx = await buildContext(session, brandId);
+        const result = await dispatchWithContract({
+          contract: brandContextSetterContract,
+          helper: brandContextSetter,
+          callable: callBrandContextSetter,
+          input: { tenantId, brandId },
+          ctx
+        });
+        let payload;
+        if (result.state === "success" && result.structuredOutput) {
+          const out = result.structuredOutput;
+          if (out.ok) {
+            try {
+              session.setBrand(out.brandId);
+              payload = {
+                ok: true,
+                tenant: out.tenantId,
+                brand: out.brandNombre ?? out.brandId,
+                dominio: out.brandDominio
+              };
+            } catch (err) {
+              const msg = err instanceof Error ? err.message : String(err);
+              payload = { ok: false, code: "BRAND_NOT_ACCESSIBLE_BY_USER", mensaje: msg };
+            }
+          } else {
+            payload = out;
+          }
+        } else {
+          payload = {
+            ok: false,
+            state: result.state,
+            mensaje: result.text,
+            ...result.validationErrors && result.validationErrors.length > 0 ? { validationErrors: result.validationErrors } : {}
+          };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+      }
+    );
+  }
   if (!session.serviceAccountPath) {
     server.tool(
       "connect_account",
       "Conecta tu cuenta de Ponch para acceder a tus datos. Primero visita https://atpops.vercel.app/auth/mcp-connect para obtener el codigo.",
       {
-        code: import_zod60.z.string().describe("Codigo de conexion de 8 caracteres (ej: ABCD-EFGH) obtenido de la pagina web")
+        code: import_zod63.z.string().describe("Codigo de conexion de 8 caracteres (ej: ABCD-EFGH) obtenido de la pagina web")
       },
       async ({ code }) => {
         try {
@@ -16316,13 +16712,13 @@ function registerContextTools(server, session) {
 }
 
 // src/tools/core.ts
-var import_zod61 = require("zod");
+var import_zod64 = require("zod");
 function registerCoreTools(server, session) {
   server.tool(
     "get_business_summary",
     "Resumen general del negocio: metricas clave, contenido pendiente, estado de conexiones, alertas.",
     {
-      brandId: import_zod61.z.string().optional().describe("ID de la brand. Si no se pasa, usa la brand del contexto.")
+      brandId: import_zod64.z.string().optional().describe("ID de la brand. Si no se pasa, usa la brand del contexto.")
     },
     async ({ brandId: inputBrandId }) => {
       const tenantId = session.requireTenant();
@@ -16398,7 +16794,7 @@ function registerCoreTools(server, session) {
     "get_pending_actions",
     "Lista todo lo que necesita atencion: contenido por aprobar, fotos sin procesar.",
     {
-      brandId: import_zod61.z.string().optional().describe("ID de la brand")
+      brandId: import_zod64.z.string().optional().describe("ID de la brand")
     },
     async ({ brandId: inputBrandId }) => {
       const tenantId = session.requireTenant();
@@ -16436,77 +16832,13 @@ function registerCoreTools(server, session) {
       return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
     }
   );
-  server.tool(
-    "execute_action",
-    "Ejecuta una accion sobre contenido o foto: aprobar, rechazar, descartar foto, usar foto tal cual.",
-    {
-      accion: import_zod61.z.enum(["aprobar", "rechazar", "descartar_foto", "usar_foto_tal_cual"]).describe("Accion a ejecutar"),
-      targetId: import_zod61.z.string().describe("ID del contenido o foto"),
-      motivo: import_zod61.z.string().optional().describe("Motivo del rechazo (requerido para rechazar)")
-    },
-    async ({ accion, targetId, motivo }) => {
-      session.requireTenant();
-      if (accion === "aprobar") {
-        const doc = await readDoc("marketing_contenido", targetId);
-        if (!doc) return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: "Contenido no encontrado" }) }] };
-        if (!esTransicionValida(doc.estado, ESTADO_CONTENIDO.APROBADO)) {
-          return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: `No se puede aprobar desde estado "${doc.estado}"` }) }] };
-        }
-        await updateDoc("marketing_contenido", targetId, {
-          estado: ESTADO_CONTENIDO.APROBADO,
-          aprobadoAt: serverTimestamp(),
-          aprobadoPorId: "mcp-cowork",
-          aprobadoPorNombre: "Cowork AI"
-        });
-        return { content: [{ type: "text", text: JSON.stringify({ ok: true, nuevoEstado: ESTADO_CONTENIDO.APROBADO }) }] };
-      }
-      if (accion === "rechazar") {
-        if (!motivo) return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: "Motivo es requerido para rechazar" }) }] };
-        const doc = await readDoc("marketing_contenido", targetId);
-        if (!doc) return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: "Contenido no encontrado" }) }] };
-        if (!esTransicionValida(doc.estado, ESTADO_CONTENIDO.RECHAZADO)) {
-          return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: `No se puede rechazar desde estado "${doc.estado}"` }) }] };
-        }
-        await updateDoc("marketing_contenido", targetId, {
-          estado: ESTADO_CONTENIDO.RECHAZADO,
-          rechazadoAt: serverTimestamp(),
-          rechazadoMotivo: motivo
-        });
-        return { content: [{ type: "text", text: JSON.stringify({ ok: true, nuevoEstado: ESTADO_CONTENIDO.RECHAZADO }) }] };
-      }
-      if (accion === "descartar_foto") {
-        const doc = await readDoc("marketing_fotos", targetId);
-        if (!doc) return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: "Foto no encontrada" }) }] };
-        if (!validarTransicionFoto(doc.estado, ESTADO_FOTO.DESCARTADA)) {
-          return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: `No se puede descartar desde estado "${doc.estado}"` }) }] };
-        }
-        await updateDoc("marketing_fotos", targetId, { estado: ESTADO_FOTO.DESCARTADA });
-        return { content: [{ type: "text", text: JSON.stringify({ ok: true, nuevoEstado: ESTADO_FOTO.DESCARTADA }) }] };
-      }
-      if (accion === "usar_foto_tal_cual") {
-        const doc = await readDoc("marketing_fotos", targetId);
-        if (!doc) return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: "Foto no encontrada" }) }] };
-        if (!validarTransicionFoto(doc.estado, ESTADO_FOTO.EDITADA)) {
-          return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: `No se puede marcar como editada desde estado "${doc.estado}"` }) }] };
-        }
-        await updateDoc("marketing_fotos", targetId, {
-          estado: ESTADO_FOTO.EDITADA,
-          archivoEditado: doc.archivoOriginal,
-          // usa la original como editada
-          fechaEdicion: serverTimestamp()
-        });
-        return { content: [{ type: "text", text: JSON.stringify({ ok: true, nuevoEstado: ESTADO_FOTO.EDITADA }) }] };
-      }
-      return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: `Accion "${accion}" no reconocida` }) }] };
-    }
-  );
 }
 
 // src/tools/marketing.ts
-var import_zod64 = require("zod");
+var import_zod67 = require("zod");
 
 // src/tools/marketing/photos.ts
-var import_zod62 = require("zod");
+var import_zod65 = require("zod");
 
 // src/services/marketingEmbeddings.ts
 var import_google_auth_library = require("google-auth-library");
@@ -16802,11 +17134,11 @@ REGLAS:
 
 USAR: antes de generar contenido de cualquier slot del calendario.`,
     {
-      brandId: import_zod62.z.string().optional().describe("ID de la brand"),
-      keyword: import_zod62.z.string().describe("Keyword del slot"),
-      plataforma: import_zod62.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Plataforma destino del slot"),
-      fecha: import_zod62.z.string().describe("Fecha del slot en ISO YYYY-MM-DD"),
-      limit: import_zod62.z.number().int().min(1).max(10).default(5)
+      brandId: import_zod65.z.string().optional().describe("ID de la brand"),
+      keyword: import_zod65.z.string().describe("Keyword del slot"),
+      plataforma: import_zod65.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Plataforma destino del slot"),
+      fecha: import_zod65.z.string().describe("Fecha del slot en ISO YYYY-MM-DD"),
+      limit: import_zod65.z.number().int().min(1).max(10).default(5)
     },
     async ({ brandId: inputBrandId, keyword, plataforma, fecha, limit }) => {
       const tenantId = session.requireTenant();
@@ -16854,7 +17186,7 @@ DESPUES de ver la foto, decide:
 
 Luego llama execute_photo_edit con tu analisis y prompt.`,
     {
-      fotoId: import_zod62.z.string().describe("ID de la foto")
+      fotoId: import_zod65.z.string().describe("ID de la foto")
     },
     async ({ fotoId }) => {
       const tenantId = session.requireTenant();
@@ -16902,14 +17234,14 @@ Retorna la foto editada para que la revises. Si no te gusta:
 
 Si estrategia era 'tal_cual', pasa acciones=['none'] \u2014 no se edita pero si se genera thumbnail y embedding con tus tags.`,
     {
-      fotoId: import_zod62.z.string(),
-      prompt: import_zod62.z.string().nullable().describe("Prompt en ingles para Gemini Image Edit. null si tal_cual"),
-      acciones: import_zod62.z.array(import_zod62.z.enum(["edit_background", "none"])),
-      descripcion: import_zod62.z.string().describe("Descripcion semantica en espanol"),
-      tipo: import_zod62.z.string().nullable().describe("Tipo del catalogoVisual del tenant"),
-      tagsPrimarios: import_zod62.z.array(import_zod62.z.string()),
-      tagsSecundarios: import_zod62.z.array(import_zod62.z.string()),
-      tagsContexto: import_zod62.z.array(import_zod62.z.string())
+      fotoId: import_zod65.z.string(),
+      prompt: import_zod65.z.string().nullable().describe("Prompt en ingles para Gemini Image Edit. null si tal_cual"),
+      acciones: import_zod65.z.array(import_zod65.z.enum(["edit_background", "none"])),
+      descripcion: import_zod65.z.string().describe("Descripcion semantica en espanol"),
+      tipo: import_zod65.z.string().nullable().describe("Tipo del catalogoVisual del tenant"),
+      tagsPrimarios: import_zod65.z.array(import_zod65.z.string()),
+      tagsSecundarios: import_zod65.z.array(import_zod65.z.string()),
+      tagsContexto: import_zod65.z.array(import_zod65.z.string())
     },
     async ({ fotoId, prompt, acciones, descripcion, tipo, tagsPrimarios, tagsSecundarios, tagsContexto }) => {
       const tenantId = session.requireTenant();
@@ -16977,7 +17309,7 @@ Si estrategia era 'tal_cual', pasa acciones=['none'] \u2014 no se edita pero si
     "get_photo_edit_status",
     "Return full photo edit status: photo state + iteration counter + active lock info + brand credits balance + actionable decision (puedeEditar) with reason if not. Use BEFORE retrying execute_photo_edit when you got a PHOTO_LOCKED error, or to show the tenant remaining iterations and credits.",
     {
-      fotoId: import_zod62.z.string().describe("Photo identifier")
+      fotoId: import_zod65.z.string().describe("Photo identifier")
     },
     async ({ fotoId }) => {
       const tenantId = session.requireTenant();
@@ -17022,11 +17354,11 @@ Si estrategia era 'tal_cual', pasa acciones=['none'] \u2014 no se edita pero si
     "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_zod62.z.string().optional().describe("ID de la brand"),
-      contexto: import_zod62.z.string().describe("Parrafo, keyword o intencion del contenido"),
-      fecha: import_zod62.z.string().describe("Fecha del contenido en ISO YYYY-MM-DD"),
-      limit: import_zod62.z.number().int().min(1).max(10).default(5),
-      diversidad: import_zod62.z.boolean().default(true)
+      brandId: import_zod65.z.string().optional().describe("ID de la brand"),
+      contexto: import_zod65.z.string().describe("Parrafo, keyword o intencion del contenido"),
+      fecha: import_zod65.z.string().describe("Fecha del contenido en ISO YYYY-MM-DD"),
+      limit: import_zod65.z.number().int().min(1).max(10).default(5),
+      diversidad: import_zod65.z.boolean().default(true)
     },
     async ({ brandId: inputBrandId, contexto, fecha, limit, diversidad }) => {
       console.warn(
@@ -17103,10 +17435,10 @@ RETORNA { plantillaId, titulo, thumbnailUrl } o { plantillaId: null, motivo: 'no
 
 USAR: solo si tenant tiene Canva conectado (tenants/{tenantId}/marketing_config/{brandId}.canva.connected=true).`,
     {
-      brandId: import_zod62.z.string().optional().describe("ID de la brand"),
-      plataforma: import_zod62.z.string().describe("gbp | instagram | shopify_blog"),
-      tipoContenido: import_zod62.z.string().describe("post | carousel | story | blog"),
-      keyword: import_zod62.z.string().describe("Keyword del slot")
+      brandId: import_zod65.z.string().optional().describe("ID de la brand"),
+      plataforma: import_zod65.z.string().describe("gbp | instagram | shopify_blog"),
+      tipoContenido: import_zod65.z.string().describe("post | carousel | story | blog"),
+      keyword: import_zod65.z.string().describe("Keyword del slot")
     },
     async ({ brandId: inputBrandId, plataforma, tipoContenido, keyword }) => {
       const tenantId = session.requireTenant();
@@ -17151,15 +17483,15 @@ USE WHEN: get_photos_for_slot returns few photos and the slot is not yet covered
 
 IMPORTANT \u2014 'razon' field: the tenant sees this in the app. Write in friendly, clear language, NOT technical. BAD example: "get_photos_for_slot returned 0 photos for shopify_blog". GOOD example: "No hay fotos de alcatraz para el blog del 8 de abril". Use the tenant's preferred language.`,
     {
-      brandId: import_zod62.z.string().optional().describe("Brand identifier (defaults to session brand)"),
-      semana: import_zod62.z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "semana debe ser ISO YYYY-MM-DD del lunes").describe("Week identifier (ISO date of Monday)"),
-      necesidades: import_zod62.z.array(
-        import_zod62.z.object({
-          tema: import_zod62.z.string(),
-          keyword: import_zod62.z.string(),
-          cantidadSugerida: import_zod62.z.number().int().positive(),
-          razon: import_zod62.z.string(),
-          slotsAfectados: import_zod62.z.array(import_zod62.z.string()).optional().describe('Affected calendar slot refs (format "semana:N:slot:M")')
+      brandId: import_zod65.z.string().optional().describe("Brand identifier (defaults to session brand)"),
+      semana: import_zod65.z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "semana debe ser ISO YYYY-MM-DD del lunes").describe("Week identifier (ISO date of Monday)"),
+      necesidades: import_zod65.z.array(
+        import_zod65.z.object({
+          tema: import_zod65.z.string(),
+          keyword: import_zod65.z.string(),
+          cantidadSugerida: import_zod65.z.number().int().positive(),
+          razon: import_zod65.z.string(),
+          slotsAfectados: import_zod65.z.array(import_zod65.z.string()).optional().describe('Affected calendar slot refs (format "semana:N:slot:M")')
         })
       ).min(1)
     },
@@ -17198,10 +17530,87 @@ IMPORTANT \u2014 'razon' field: the tenant sees this in the app. Write in friend
       return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
     }
   );
+  server.tool(
+    "discard_photo",
+    "Discard a marketing photo (mark as descartada). Validates state transition. Use when the photo is no longer needed. Requires confirmation: first call returns state=pending_confirmation; pass confirm=true on the second call to execute.",
+    {
+      fotoId: import_zod65.z.string().describe("Photo identifier to discard"),
+      brandId: import_zod65.z.string().optional().describe("Brand identifier (defaults to session brand)"),
+      confirm: import_zod65.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
+    },
+    async ({ fotoId, brandId: inputBrandId, confirm }) => {
+      const tenantId = session.requireTenant();
+      const brandId = inputBrandId ?? session.requireBrand();
+      const ctx = await buildContext(session, brandId, { confirmationGranted: confirm === true });
+      const actor = {
+        uid: ctx.user.uid,
+        nombre: ctx.user.nombre ?? ctx.user.uid,
+        clientType: ctx.user.clientType ?? "mcp_client",
+        clientMetadata: ctx.user.clientMetadata ?? null
+      };
+      const result = await dispatchWithContract({
+        contract: photoDescarterContract,
+        helper: photoDescarter,
+        callable: callPhotoDescarter,
+        input: { tenantId, fotoId, actor },
+        ctx
+      });
+      let payload;
+      if (result.state === "success" && result.structuredOutput) {
+        payload = result.structuredOutput;
+      } else {
+        payload = {
+          ok: false,
+          state: result.state,
+          mensaje: result.text,
+          ...result.validationErrors && result.validationErrors.length > 0 ? { validationErrors: result.validationErrors } : {}
+        };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+    }
+  );
+  server.tool(
+    "use_photo_as_is",
+    "Mark a photo as editada using the original file (no Gemini edit). Validates state transition (procesando \u2192 editada). Use when the original photo is already good enough for publication.",
+    {
+      fotoId: import_zod65.z.string().describe("Photo identifier to mark as edited"),
+      brandId: import_zod65.z.string().optional().describe("Brand identifier (defaults to session brand)")
+    },
+    async ({ fotoId, brandId: inputBrandId }) => {
+      const tenantId = session.requireTenant();
+      const brandId = inputBrandId ?? session.requireBrand();
+      const ctx = await buildContext(session, brandId);
+      const actor = {
+        uid: ctx.user.uid,
+        nombre: ctx.user.nombre ?? ctx.user.uid,
+        clientType: ctx.user.clientType ?? "mcp_client",
+        clientMetadata: ctx.user.clientMetadata ?? null
+      };
+      const result = await dispatchWithContract({
+        contract: photoEditadaMarkerContract,
+        helper: photoEditadaMarker,
+        callable: callPhotoEditadaMarker,
+        input: { tenantId, fotoId, actor },
+        ctx
+      });
+      let payload;
+      if (result.state === "success" && result.structuredOutput) {
+        payload = result.structuredOutput;
+      } else {
+        payload = {
+          ok: false,
+          state: result.state,
+          mensaje: result.text,
+          ...result.validationErrors && result.validationErrors.length > 0 ? { validationErrors: result.validationErrors } : {}
+        };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
+    }
+  );
 }
 
 // src/tools/marketing/content.ts
-var import_zod63 = require("zod");
+var import_zod66 = require("zod");
 var _logOverride = null;
 async function logToMcpLogs(entry) {
   if (_logOverride) return _logOverride(entry);
@@ -17214,22 +17623,22 @@ async function logToMcpLogs(entry) {
   } catch {
   }
 }
-var IncludeSchema2 = import_zod63.z.object({
-  products: import_zod63.z.boolean().default(true),
-  collections: import_zod63.z.boolean().default(true),
-  articles: import_zod63.z.boolean().default(true),
-  pages: import_zod63.z.boolean().default(false)
+var IncludeSchema2 = import_zod66.z.object({
+  products: import_zod66.z.boolean().default(true),
+  collections: import_zod66.z.boolean().default(true),
+  articles: import_zod66.z.boolean().default(true),
+  pages: import_zod66.z.boolean().default(false)
 }).default({
   products: true,
   collections: true,
   articles: true,
   pages: false
 });
-var LimitSchema2 = import_zod63.z.object({
-  products: import_zod63.z.number().int().min(0).max(20).default(5),
-  collections: import_zod63.z.number().int().min(0).max(10).default(3),
-  articles: import_zod63.z.number().int().min(0).max(20).default(5),
-  pages: import_zod63.z.number().int().min(0).max(10).default(2)
+var LimitSchema2 = import_zod66.z.object({
+  products: import_zod66.z.number().int().min(0).max(20).default(5),
+  collections: import_zod66.z.number().int().min(0).max(10).default(3),
+  articles: import_zod66.z.number().int().min(0).max(20).default(5),
+  pages: import_zod66.z.number().int().min(0).max(10).default(2)
 }).default({ products: 5, collections: 3, articles: 5, pages: 2 });
 function registerContentTools(server, session) {
   server.tool(
@@ -17257,13 +17666,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_zod63.z.string().optional().describe("ID de la brand"),
-      contexto: import_zod63.z.string().min(1).describe("Parrafo, keyword o intencion"),
-      fecha: import_zod63.z.string().describe("Fecha del contenido en ISO YYYY-MM-DD"),
+      brandId: import_zod66.z.string().optional().describe("ID de la brand"),
+      contexto: import_zod66.z.string().min(1).describe("Parrafo, keyword o intencion"),
+      fecha: import_zod66.z.string().describe("Fecha del contenido en ISO YYYY-MM-DD"),
       include: IncludeSchema2.optional(),
       limit: LimitSchema2.optional(),
-      diversidad: import_zod63.z.boolean().default(true),
-      mode: import_zod63.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_zod66.z.boolean().default(true),
+      mode: import_zod66.z.enum(["text", "hybrid"]).default("text").describe("Modo de busqueda: 'text' (rapido, 1 query) o 'hybrid' (text+image via RRF, 2x queries, rescata SEO debil)")
     },
     async ({ brandId: inputBrandId, contexto, fecha, include, limit, diversidad, mode }) => {
       const tenantId = session.requireTenant();
@@ -17474,8 +17883,8 @@ function registerMarketingTools(server, session) {
     "get_calendar",
     "Lee el calendario editorial del mes. Muestra semanas con items planificados por plataforma.",
     {
-      brandId: import_zod64.z.string().optional().describe("ID de la brand"),
-      mes: import_zod64.z.string().optional().describe("Mes en formato YYYY-MM (default: mes actual)")
+      brandId: import_zod67.z.string().optional().describe("ID de la brand"),
+      mes: import_zod67.z.string().optional().describe("Mes en formato YYYY-MM (default: mes actual)")
     },
     async ({ brandId: inputBrandId, mes }) => {
       const tenantId = session.requireTenant();
@@ -17513,7 +17922,7 @@ function registerMarketingTools(server, session) {
     "get_seo_snapshot",
     "Read the latest Semrush SEO snapshot for a brand: rank, top keywords, opportunities, competitors.",
     {
-      brandId: import_zod64.z.string().optional().describe("Brand identifier within the tenant")
+      brandId: import_zod67.z.string().optional().describe("Brand identifier within the tenant")
     },
     async ({ brandId: inputBrandId }) => {
       const tenantId = session.requireTenant();
@@ -17549,8 +17958,8 @@ function registerMarketingTools(server, session) {
     "get_photo_gallery",
     "List marketing photos for a brand with per-state counts. Optionally filter by state.",
     {
-      brandId: import_zod64.z.string().optional().describe("Brand identifier within the tenant"),
-      estado: import_zod64.z.string().optional().describe("Optional photo state filter (nueva, procesando, editada, usada, descartada, error)")
+      brandId: import_zod67.z.string().optional().describe("Brand identifier within the tenant"),
+      estado: import_zod67.z.string().optional().describe("Optional photo state filter (nueva, procesando, editada, usada, descartada, error)")
     },
     async ({ brandId: inputBrandId, estado }) => {
       const tenantId = session.requireTenant();
@@ -17586,7 +17995,7 @@ function registerMarketingTools(server, session) {
     "generate_marketing_plan",
     "Aggregate the data needed to generate a strategic marketing plan: SEO snapshot + products. The LLM uses the system prompt to generate the plan from this payload.",
     {
-      brandId: import_zod64.z.string().optional().describe("ID de la brand")
+      brandId: import_zod67.z.string().optional().describe("ID de la brand")
     },
     async ({ brandId: inputBrandId }) => {
       const tenantId = session.requireTenant();
@@ -17600,18 +18009,24 @@ function registerMarketingTools(server, session) {
     "save_marketing_plan",
     "Save a marketing plan to the brand configuration. Writes to tenants/{tenantId}/marketing_config/{brandId}.plan. If the plan object includes a blogStrategy field, it is extracted and stored at brand level (not nested inside plan).",
     {
-      brandId: import_zod64.z.string().optional().describe("Brand ID. If omitted, uses the active brand from session context."),
-      plan: import_zod64.z.record(import_zod64.z.string(), import_zod64.z.unknown()).describe("Full marketing plan object. Common fields: keywordsPrioritarios, gapsCompetencia, temporadas, tonoMarca, quickWins, coleccionesPriorizadas, blogStrategy.")
+      brandId: import_zod67.z.string().optional().describe("Brand ID. If omitted, uses the active brand from session context."),
+      plan: import_zod67.z.record(import_zod67.z.string(), import_zod67.z.unknown()).describe("Full marketing plan object. Common fields: keywordsPrioritarios, gapsCompetencia, temporadas, tonoMarca, quickWins, coleccionesPriorizadas, blogStrategy.")
     },
     async ({ brandId: inputBrandId, plan }) => {
       const tenantId = session.requireTenant();
       const brandId = inputBrandId ?? session.requireBrand();
       const ctx = await buildContext(session, brandId);
+      const actor = {
+        uid: ctx.user.uid,
+        nombre: ctx.user.nombre ?? ctx.user.uid,
+        clientType: ctx.user.clientType ?? "mcp_client",
+        clientMetadata: ctx.user.clientMetadata ?? null
+      };
       const result = await dispatchWithContract({
         contract: planWriterSaveContract,
         helper: ({ db, ...rest }) => planWriter.save({ db, ...rest }),
         callable: callPlanWriterSave,
-        input: { tenantId, brandId, plan },
+        input: { tenantId, brandId, plan, actor },
         ctx
       });
       const payload = result.state === "success" ? result.structuredOutput : {
@@ -17629,9 +18044,9 @@ function registerMarketingTools(server, session) {
     "update_marketing_plan_field",
     "Actualiza UN campo del plan de marketing sin sobreescribir el resto. Merge parcial. Ideal para agregar coleccionesPriorizadas, actualizar quickWins, etc.",
     {
-      brandId: import_zod64.z.string().optional().describe("ID de la brand"),
-      field: import_zod64.z.string().describe('Nombre del campo a actualizar (ej: "coleccionesPriorizadas", "quickWins", "temporadas")'),
-      value: import_zod64.z.unknown().describe("Valor del campo")
+      brandId: import_zod67.z.string().optional().describe("ID de la brand"),
+      field: import_zod67.z.string().describe('Nombre del campo a actualizar (ej: "coleccionesPriorizadas", "quickWins", "temporadas")'),
+      value: import_zod67.z.unknown().describe("Valor del campo")
     },
     async ({ brandId: inputBrandId, field, value }) => {
       const tenantId = session.requireTenant();
@@ -17644,7 +18059,7 @@ function registerMarketingTools(server, session) {
     "generate_brand_brief",
     "Aggregate all business data needed to generate a Brand Brief: Shopify (products, collections, orders, shop info), SEO snapshot, GBP profiles, scraped site_content, brand config, tenant locations. Read-only \u2014 does NOT write the brief. After receiving the payload, generate the brief content and save it via save_brand_brief.",
     {
-      brandId: import_zod64.z.string().optional().describe("Brand ID. If omitted, uses the active brand from session context.")
+      brandId: import_zod67.z.string().optional().describe("Brand ID. If omitted, uses the active brand from session context.")
     },
     async ({ brandId: inputBrandId }) => {
       const tenantId = session.requireTenant();
@@ -17677,8 +18092,8 @@ function registerMarketingTools(server, session) {
     "save_brand_brief",
     "Save the Brand Brief at tenants/{tenantId}/marketing_config/{brandId}.brandBrief. Partial merge \u2014 only the brandBrief field is overwritten.",
     {
-      brandId: import_zod64.z.string().optional().describe("ID de la brand"),
-      brandBrief: import_zod64.z.record(import_zod64.z.string(), import_zod64.z.unknown()).describe("Full Brand Brief object.")
+      brandId: import_zod67.z.string().optional().describe("ID de la brand"),
+      brandBrief: import_zod67.z.record(import_zod67.z.string(), import_zod67.z.unknown()).describe("Full Brand Brief object.")
     },
     async ({ brandId: inputBrandId, brandBrief }) => {
       const tenantId = session.requireTenant();
@@ -17704,19 +18119,25 @@ function registerMarketingTools(server, session) {
     "generate_weekly_content",
     "Aggregate calendar + photos + plan data to generate the week's content. The LLM generates with the system prompt, then uses save_generated_content to persist.",
     {
-      brandId: import_zod64.z.string().optional().describe("ID de la brand"),
-      semana: import_zod64.z.number().optional().describe("Numero de semana (1-5). Default: semana actual del mes."),
-      modo: import_zod64.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_zod67.z.string().optional().describe("ID de la brand"),
+      semana: import_zod67.z.number().optional().describe("Numero de semana (1-5). Default: semana actual del mes."),
+      modo: import_zod67.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();
       const brandId = inputBrandId ?? session.requireBrand();
       const ctx = await buildContext(session, brandId);
+      const actor = {
+        uid: ctx.user.uid,
+        nombre: ctx.user.nombre ?? ctx.user.uid,
+        clientType: ctx.user.clientType ?? "mcp_client",
+        clientMetadata: ctx.user.clientMetadata ?? null
+      };
       const result = await dispatchWithContract({
         contract: weeklyContentBuilderContract,
         helper: weeklyContentBuilder,
         callable: callWeeklyContentBuilder,
-        input: { tenantId, brandId, semana, modo },
+        input: { tenantId, brandId, semana, modo, actor },
         ctx
       });
       const payload = result.state === "success" ? result.structuredOutput?.payload ?? result.structuredOutput : {
@@ -17734,25 +18155,31 @@ function registerMarketingTools(server, session) {
 
 IMPORTANT: If you selected a photo with get_photos_for_slot, ALWAYS pass fotoId here. Without fotoId the post will be published without an image.`,
     {
-      brandId: import_zod64.z.string().optional().describe("ID de la brand"),
-      plataforma: import_zod64.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Plataforma destino"),
-      tipo: import_zod64.z.string().optional().describe("Tipo de contenido (post, blog, carousel, etc.)"),
-      keyword: import_zod64.z.string().optional().describe("Keyword target"),
-      languageCode: import_zod64.z.string().optional().describe("Idioma (es/en)"),
-      fotoId: import_zod64.z.string().optional().describe("ID de la foto a asociar"),
-      datos: import_zod64.z.record(import_zod64.z.string(), import_zod64.z.unknown()).describe("Datos especificos de la plataforma (output de buildDatos*)"),
-      calendarioItemRef: import_zod64.z.string().optional().describe("Referencia al item del calendario")
+      brandId: import_zod67.z.string().optional().describe("ID de la brand"),
+      plataforma: import_zod67.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Plataforma destino"),
+      tipo: import_zod67.z.string().optional().describe("Tipo de contenido (post, blog, carousel, etc.)"),
+      keyword: import_zod67.z.string().optional().describe("Keyword target"),
+      languageCode: import_zod67.z.string().optional().describe("Idioma (es/en)"),
+      fotoId: import_zod67.z.string().optional().describe("ID de la foto a asociar"),
+      datos: import_zod67.z.record(import_zod67.z.string(), import_zod67.z.unknown()).describe("Datos especificos de la plataforma (output de buildDatos*)"),
+      calendarioItemRef: import_zod67.z.string().optional().describe("Referencia al item del calendario")
     },
     async ({ brandId: inputBrandId, plataforma, tipo, keyword, languageCode, fotoId, datos, calendarioItemRef }) => {
       const tenantId = session.requireTenant();
       const brandId = inputBrandId ?? session.requireBrand();
       try {
         const ctx = await buildContext(session, brandId);
+        const actor = {
+          uid: ctx.user.uid,
+          nombre: ctx.user.nombre ?? ctx.user.uid,
+          clientType: ctx.user.clientType ?? "mcp_client",
+          clientMetadata: ctx.user.clientMetadata ?? null
+        };
         const result = await dispatchWithContract({
           contract: contenidoWriterContract,
           helper: (input) => contenidoWriter({ ...input, linkPipeline: linkContenidoAPasoPipeline }),
           callable: callContenidoWriter,
-          input: { tenantId, brandId, plataforma, tipo, keyword, languageCode, fotoId, datos, calendarioItemRef },
+          input: { tenantId, brandId, plataforma, tipo, keyword, languageCode, fotoId, datos, calendarioItemRef, actor },
           ctx
         });
         const payload = result.state === "success" ? result.structuredOutput : {
@@ -17777,13 +18204,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_zod64.z.string().describe("ID del doc en marketing_contenido"),
-      datos: import_zod64.z.record(import_zod64.z.string(), import_zod64.z.unknown()).optional().describe('Campos de datos a actualizar (merge parcial sobre datos existentes). Ej: { body: "...", metaTitle: "..." }'),
-      fotoId: import_zod64.z.string().nullable().optional().describe("Actualizar foto asociada"),
-      keyword: import_zod64.z.string().nullable().optional().describe("Actualizar keyword"),
-      languageCode: import_zod64.z.string().optional().describe("Actualizar idioma"),
-      estado: import_zod64.z.enum(["borrador", "generado", "pendiente_aprobacion", "aprobado", "rechazado"]).optional().describe("Cambiar estado manualmente"),
-      calendarioItemRef: import_zod64.z.string().nullable().optional().describe("Vincular a un slot del calendario")
+      contenidoId: import_zod67.z.string().describe("ID del doc en marketing_contenido"),
+      datos: import_zod67.z.record(import_zod67.z.string(), import_zod67.z.unknown()).optional().describe('Campos de datos a actualizar (merge parcial sobre datos existentes). Ej: { body: "...", metaTitle: "..." }'),
+      fotoId: import_zod67.z.string().nullable().optional().describe("Actualizar foto asociada"),
+      keyword: import_zod67.z.string().nullable().optional().describe("Actualizar keyword"),
+      languageCode: import_zod67.z.string().optional().describe("Actualizar idioma"),
+      estado: import_zod67.z.enum(["borrador", "generado", "pendiente_aprobacion", "aprobado", "rechazado"]).optional().describe("Cambiar estado manualmente"),
+      calendarioItemRef: import_zod67.z.string().nullable().optional().describe("Vincular a un slot del calendario")
     },
     async ({ contenidoId, datos: newDatos, fotoId, keyword, languageCode, estado, calendarioItemRef }) => {
       const tenantId = session.requireTenant();
@@ -17817,19 +18244,19 @@ Si pasas campos dentro de "datos", se hace merge con los datos existentes (no lo
     "add_calendar_slot",
     "Add a NEW slot to the editorial calendar. To modify an existing slot use update_calendar_slot instead.",
     {
-      brandId: import_zod64.z.string().describe('Brand ID (e.g. "ponch", "teleglobos").'),
-      mes: import_zod64.z.string().describe('Calendar month in YYYY-MM format (e.g. "2026-05").'),
-      semana: import_zod64.z.number().describe("Week number within the month (1-5)."),
-      slot: import_zod64.z.object({
-        dia: import_zod64.z.string().describe("Slot date in YYYY-MM-DD format. Must fall within the week's fechaInicio/fechaFin range."),
-        plataforma: import_zod64.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Target publishing platform."),
-        tipo: import_zod64.z.enum(["post", "blog", "carousel", "reel", "story", "review_response"]).describe("Content type."),
-        keyword: import_zod64.z.string().describe("Primary keyword for the content."),
-        tema: import_zod64.z.string().optional().describe("Content topic/theme. OMIT this field if it does not apply. Do NOT send empty string or null."),
-        productoId: import_zod64.z.string().optional().describe("Linked product ID. OMIT this field if no product is linked."),
-        estado: import_zod64.z.enum(["planificado", "pre_aprobado", "generado", "revisar", "aprobado", "publicado", "rechazado"]).optional().describe('Initial status. OMIT to use default "planificado".'),
-        locationId: import_zod64.z.string().optional().describe("GBP location ID \u2014 only when plataforma=gbp AND tenant is multi-location. OMIT otherwise."),
-        locationNombre: import_zod64.z.string().optional().describe("Human-readable GBP location name. OMIT if locationId is not provided.")
+      brandId: import_zod67.z.string().describe('Brand ID (e.g. "ponch", "teleglobos").'),
+      mes: import_zod67.z.string().describe('Calendar month in YYYY-MM format (e.g. "2026-05").'),
+      semana: import_zod67.z.number().describe("Week number within the month (1-5)."),
+      slot: import_zod67.z.object({
+        dia: import_zod67.z.string().describe("Slot date in YYYY-MM-DD format. Must fall within the week's fechaInicio/fechaFin range."),
+        plataforma: import_zod67.z.enum(["gbp", "shopify_blog", "instagram", "review"]).describe("Target publishing platform."),
+        tipo: import_zod67.z.enum(["post", "blog", "carousel", "reel", "story", "review_response"]).describe("Content type."),
+        keyword: import_zod67.z.string().describe("Primary keyword for the content."),
+        tema: import_zod67.z.string().optional().describe("Content topic/theme. OMIT this field if it does not apply. Do NOT send empty string or null."),
+        productoId: import_zod67.z.string().optional().describe("Linked product ID. OMIT this field if no product is linked."),
+        estado: import_zod67.z.enum(["planificado", "pre_aprobado", "generado", "revisar", "aprobado", "publicado", "rechazado"]).optional().describe('Initial status. OMIT to use default "planificado".'),
+        locationId: import_zod67.z.string().optional().describe("GBP location ID \u2014 only when plataforma=gbp AND tenant is multi-location. OMIT otherwise."),
+        locationNombre: import_zod67.z.string().optional().describe("Human-readable GBP location name. OMIT if locationId is not provided.")
       }).describe("New slot data.")
     },
     async ({ brandId, mes, semana, slot }) => {
@@ -17855,27 +18282,27 @@ Si pasas campos dentro de "datos", se hace merge con los datos existentes (no lo
     "update_calendar_slot",
     "MODIFY an EXISTING slot in the editorial calendar. To create a new slot use add_calendar_slot. If slotIndex does not exist, returns error SLOT_NOT_FOUND.",
     {
-      brandId: import_zod64.z.string().optional().describe("Brand ID. If omitted, uses the active brand from session context."),
-      mes: import_zod64.z.string().describe("Calendar month in YYYY-MM format."),
-      semana: import_zod64.z.number().describe("Week number within the month (1-5)."),
-      slotIndex: import_zod64.z.number().describe("Slot index (0-based). Must point to an existing slot \u2014 to add new slots use add_calendar_slot."),
-      cambios: import_zod64.z.object({
-        dia: import_zod64.z.string().nullable().optional().describe("Slot date in YYYY-MM-DD. OMIT if not changing date. Use null to explicitly clear."),
-        plataforma: import_zod64.z.enum(["gbp", "shopify_blog", "instagram", "review"]).nullable().optional().describe("OMIT if not changing platform."),
-        tipo: import_zod64.z.enum(["post", "blog", "carousel", "reel", "story", "review_response"]).nullable().optional().describe("OMIT if not changing content type."),
-        keyword: import_zod64.z.string().nullable().optional().describe("OMIT if not changing keyword."),
-        tema: import_zod64.z.string().nullable().optional().describe("OMIT if not changing topic."),
-        productoId: import_zod64.z.string().nullable().optional().describe("OMIT if not changing linked product. Use null to unlink."),
-        estado: import_zod64.z.enum(["planificado", "pre_aprobado", "generado", "revisar", "aprobado", "publicado", "rechazado"]).optional().describe("OMIT if not changing status manually."),
-        contenidoRef: import_zod64.z.string().nullable().optional().describe("OMIT \u2014 managed by the system, not by callers."),
-        fotoIdAsignada: import_zod64.z.string().nullable().optional().describe("Use assign_photo_to_content for photos. OMIT here."),
-        notas: import_zod64.z.array(NotaCalendarioSchema).optional().describe("Append-only notes for the slot."),
-        locationId: import_zod64.z.string().nullable().optional().describe("GBP location ID \u2014 only when plataforma=gbp."),
-        locationNombre: import_zod64.z.string().nullable().optional().describe("Human-readable GBP location name (for UI).")
+      brandId: import_zod67.z.string().optional().describe("Brand ID. If omitted, uses the active brand from session context."),
+      mes: import_zod67.z.string().describe("Calendar month in YYYY-MM format."),
+      semana: import_zod67.z.number().describe("Week number within the month (1-5)."),
+      slotIndex: import_zod67.z.number().describe("Slot index (0-based). Must point to an existing slot \u2014 to add new slots use add_calendar_slot."),
+      cambios: import_zod67.z.object({
+        dia: import_zod67.z.string().nullable().optional().describe("Slot date in YYYY-MM-DD. OMIT if not changing date. Use null to explicitly clear."),
+        plataforma: import_zod67.z.enum(["gbp", "shopify_blog", "instagram", "review"]).nullable().optional().describe("OMIT if not changing platform."),
+        tipo: import_zod67.z.enum(["post", "blog", "carousel", "reel", "story", "review_response"]).nullable().optional().describe("OMIT if not changing content type."),
+        keyword: import_zod67.z.string().nullable().optional().describe("OMIT if not changing keyword."),
+        tema: import_zod67.z.string().nullable().optional().describe("OMIT if not changing topic."),
+        productoId: import_zod67.z.string().nullable().optional().describe("OMIT if not changing linked product. Use null to unlink."),
+        estado: import_zod67.z.enum(["planificado", "pre_aprobado", "generado", "revisar", "aprobado", "publicado", "rechazado"]).optional().describe("OMIT if not changing status manually."),
+        contenidoRef: import_zod67.z.string().nullable().optional().describe("OMIT \u2014 managed by the system, not by callers."),
+        fotoIdAsignada: import_zod67.z.string().nullable().optional().describe("Use assign_photo_to_content for photos. OMIT here."),
+        notas: import_zod67.z.array(NotaCalendarioSchema).optional().describe("Append-only notes for the slot."),
+        locationId: import_zod67.z.string().nullable().optional().describe("GBP location ID \u2014 only when plataforma=gbp."),
+        locationNombre: import_zod67.z.string().nullable().optional().describe("Human-readable GBP location name (for UI).")
       }).strict().describe("Fields to update on the slot. Only declared fields accepted; unknown fields are rejected. OMIT any field you are not changing."),
-      accionContenidoExistente: import_zod64.z.union([
-        import_zod64.z.enum(["descartar", "nuevo_slot", "mantener"]),
-        import_zod64.z.string().regex(/^mover:semana:\d+:slot:\d+$/, "Format: mover:semana:N:slot:M")
+      accionContenidoExistente: import_zod67.z.union([
+        import_zod67.z.enum(["descartar", "nuevo_slot", "mantener"]),
+        import_zod67.z.string().regex(/^mover:semana:\d+:slot:\d+$/, "Format: mover:semana:N:slot:M")
       ]).optional().describe(
         'Required ONLY when the slot already has a contenidoRef AND the cambios touch semantic fields (keyword/tema/plataforma/tipo). In that case, the helper returns ACCION_CONTENIDO_EXISTENTE_REQUIRED with the 4 options listed below \u2014 ask the tenant which one to apply. OMIT this field in any other case. Do NOT send null. Valid values: "descartar" (mark existing content as discarded and apply changes to this slot) | "mover:semana:N:slot:M" (move existing content to target empty slot N/M and apply changes to origin slot) | "nuevo_slot" (do NOT touch this slot or its content; create a new slot same day with the changes \u2014 useful for multiple posts per day) | "mantener" (keep existing content here and apply changes anyway \u2014 typo-fix case where old content stays valid).'
       )
@@ -17920,9 +18347,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_zod64.z.string().describe("ID del doc en marketing_contenido"),
-      fotoId: import_zod64.z.string().describe("ID de la foto en marketing_fotos (estado editada)"),
-      calendarioItemRef: import_zod64.z.string().optional().describe('Ref del slot (formato "semana:N:slot:M") para actualizar fotoIdAsignada')
+      contenidoRef: import_zod67.z.string().describe("ID del doc en marketing_contenido"),
+      fotoId: import_zod67.z.string().describe("ID de la foto en marketing_fotos (estado editada)"),
+      calendarioItemRef: import_zod67.z.string().optional().describe('Ref del slot (formato "semana:N:slot:M") para actualizar fotoIdAsignada')
     },
     async ({ contenidoRef, fotoId, calendarioItemRef }) => {
       const tenantId = session.requireTenant();
@@ -17948,9 +18375,9 @@ NUNCA uses update_calendar_slot para asignar fotos \u2014 eso escribe en la agen
     "approve_content",
     "Approve marketing content for publication. Validates state transition (pendiente_aprobacion \u2192 aprobado). Requires confirmation: first call returns state=pending_confirmation; pass confirm=true on the second call to execute.",
     {
-      contenidoId: import_zod64.z.string().describe("Marketing content document id"),
-      brandId: import_zod64.z.string().optional().describe("Brand identifier (defaults to session brand)"),
-      confirm: import_zod64.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
+      contenidoId: import_zod67.z.string().describe("Marketing content document id"),
+      brandId: import_zod67.z.string().optional().describe("Brand identifier (defaults to session brand)"),
+      confirm: import_zod67.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
     },
     async ({ contenidoId, brandId: inputBrandId, confirm }) => {
       const tenantId = session.requireTenant();
@@ -17988,10 +18415,10 @@ NUNCA uses update_calendar_slot para asignar fotos \u2014 eso escribe en la agen
     "reject_content",
     "Reject marketing content with a reason. Validates state transition (pendiente_aprobacion \u2192 rechazado). Reversible via rechazado \u2192 editado \u2192 pendiente_aprobacion \u2192 aprobado. Requires confirmation: first call returns state=pending_confirmation; pass confirm=true on the second call to execute.",
     {
-      contenidoId: import_zod64.z.string().describe("Marketing content document id"),
-      motivo: import_zod64.z.string().describe("Reason for rejection (required, surfaced to tenant)"),
-      brandId: import_zod64.z.string().optional().describe("Brand identifier (defaults to session brand)"),
-      confirm: import_zod64.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
+      contenidoId: import_zod67.z.string().describe("Marketing content document id"),
+      motivo: import_zod67.z.string().describe("Reason for rejection (required, surfaced to tenant)"),
+      brandId: import_zod67.z.string().optional().describe("Brand identifier (defaults to session brand)"),
+      confirm: import_zod67.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
     },
     async ({ contenidoId, motivo, brandId: inputBrandId, confirm }) => {
       const tenantId = session.requireTenant();
@@ -18029,7 +18456,7 @@ NUNCA uses update_calendar_slot para asignar fotos \u2014 eso escribe en la agen
     "get_collections",
     "Read all canonical collections (Shopify/WordPress/web-only) for a brand with their 6 SEO fields, plus best practices and the strict schema for generating SEO suggestions.",
     {
-      brandId: import_zod64.z.string().optional().describe("Brand identifier within the tenant")
+      brandId: import_zod67.z.string().optional().describe("Brand identifier within the tenant")
     },
     async ({ brandId: inputBrandId }) => {
       const tenantId = session.requireTenant();
@@ -18060,7 +18487,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_zod64.z.string().optional().describe("ID de la brand"),
+      brandId: import_zod67.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 }) => {
@@ -18086,7 +18513,7 @@ NUNCA uses update_calendar_slot para asignar fotos \u2014 eso escribe en la agen
 }
 
 // src/tools/martin.ts
-var import_zod65 = require("zod");
+var import_zod68 = require("zod");
 function renderResult(result) {
   const payload = {
     state: result.state,
@@ -18102,16 +18529,16 @@ function registerMartinTools(server, session) {
     "recordar_memoria",
     "Save a user preference, rule, pattern or aversion that the system will respect in future interactions. Personal to the calling user (scope: self). Applied automatically in Martin's prompt for subsequent conversations.",
     {
-      tipo: import_zod65.z.enum(["preferencia", "regla", "patron", "aversion"]).describe(
+      tipo: import_zod68.z.enum(["preferencia", "regla", "patron", "aversion"]).describe(
         "Memory type: 'preferencia' (personal preference), 'regla' (operational rule), 'patron' (observed behavioral pattern), 'aversion' (explicit do-not-do rule)."
       ),
-      categoria: import_zod65.z.enum(["compras", "produccion", "dispatch", "ventas", "marketing", "operacion", "personal", "delegacion"]).describe("Business area this memory applies to."),
-      contenido: import_zod65.z.string().min(3).max(500).describe("Memory content in the user's own words (3-500 chars)."),
-      origen: import_zod65.z.object({
-        tipo: import_zod65.z.enum(["conversacion", "feedback_card", "inferido_automatico"]),
-        conversacionId: import_zod65.z.string().nullable(),
-        cardId: import_zod65.z.string().nullable(),
-        rationale: import_zod65.z.array(import_zod65.z.string()).optional()
+      categoria: import_zod68.z.enum(["compras", "produccion", "dispatch", "ventas", "marketing", "operacion", "personal", "delegacion"]).describe("Business area this memory applies to."),
+      contenido: import_zod68.z.string().min(3).max(500).describe("Memory content in the user's own words (3-500 chars)."),
+      origen: import_zod68.z.object({
+        tipo: import_zod68.z.enum(["conversacion", "feedback_card", "inferido_automatico"]),
+        conversacionId: import_zod68.z.string().nullable(),
+        cardId: import_zod68.z.string().nullable(),
+        rationale: import_zod68.z.array(import_zod68.z.string()).optional()
       }).describe("Where this memory was inferred from (conversation, card feedback, or auto-inferred).")
     },
     async ({ tipo, categoria, contenido, origen }) => {
@@ -18130,9 +18557,9 @@ function registerMartinTools(server, session) {
     "olvidar_memoria",
     "Archive a memory that no longer applies. The memory remains visible in settings but is no longer enforced in future interactions. Requires confirmation: the first call returns a confirmation prompt; pass confirm=true on the second call to execute.",
     {
-      memoriaId: import_zod65.z.string().min(1).describe("Memory document ID to archive."),
-      motivo: import_zod65.z.string().optional().describe("Optional reason for archiving (logged for audit)."),
-      confirm: import_zod65.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
+      memoriaId: import_zod68.z.string().min(1).describe("Memory document ID to archive."),
+      motivo: import_zod68.z.string().optional().describe("Optional reason for archiving (logged for audit)."),
+      confirm: import_zod68.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
     },
     async ({ memoriaId, motivo, confirm }) => {
       const ctx = await buildContext(session, null, { confirmationGranted: confirm === true });
@@ -18150,25 +18577,25 @@ function registerMartinTools(server, session) {
     "programar_rutina",
     "Schedule a recurring or one-time task. Useful for monthly reports, reminders, scheduled posts, suggested purchases. Personal to the calling user (scope: self). Requires confirmation.",
     {
-      uidDestinatario: import_zod65.z.string().optional().describe("User ID who should receive the routine output. OMIT to default to the calling user (most common case)."),
-      tipo: import_zod65.z.enum(["reporte", "recordatorio", "accion_delegada", "publicacion", "compra_sugerida"]).describe("Routine type from canonical TipoRutinaEnum."),
-      frecuencia: import_zod65.z.enum(["diaria", "semanal", "quincenal", "mensual", "trimestral", "puntual"]).describe("Execution cadence."),
-      config: import_zod65.z.object({
-        diaSemana: import_zod65.z.number().int().min(0).max(6).nullable(),
-        diaMes: import_zod65.z.number().int().min(1).max(31).nullable(),
-        hora: import_zod65.z.string().regex(/^\d{2}:\d{2}$/),
-        fechaPuntual: import_zod65.z.string().datetime({ offset: true }).nullable()
+      uidDestinatario: import_zod68.z.string().optional().describe("User ID who should receive the routine output. OMIT to default to the calling user (most common case)."),
+      tipo: import_zod68.z.enum(["reporte", "recordatorio", "accion_delegada", "publicacion", "compra_sugerida"]).describe("Routine type from canonical TipoRutinaEnum."),
+      frecuencia: import_zod68.z.enum(["diaria", "semanal", "quincenal", "mensual", "trimestral", "puntual"]).describe("Execution cadence."),
+      config: import_zod68.z.object({
+        diaSemana: import_zod68.z.number().int().min(0).max(6).nullable(),
+        diaMes: import_zod68.z.number().int().min(1).max(31).nullable(),
+        hora: import_zod68.z.string().regex(/^\d{2}:\d{2}$/),
+        fechaPuntual: import_zod68.z.string().datetime({ offset: true }).nullable()
       }).describe("Schedule configuration. Match fields to the frecuencia (semanal needs diaSemana; mensual needs diaMes; puntual needs fechaPuntual)."),
-      accion: import_zod65.z.object({
-        tool: import_zod65.z.string().min(1),
-        params: import_zod65.z.record(import_zod65.z.string(), import_zod65.z.unknown())
+      accion: import_zod68.z.object({
+        tool: import_zod68.z.string().min(1),
+        params: import_zod68.z.record(import_zod68.z.string(), import_zod68.z.unknown())
       }).describe("Action to execute on each fire (MCP tool name + params)."),
-      origen: import_zod65.z.object({
-        tipo: import_zod65.z.enum(["conversacion", "feedback_card", "configurada_explicito"]),
-        conversacionId: import_zod65.z.string().nullable(),
-        cardId: import_zod65.z.string().nullable()
+      origen: import_zod68.z.object({
+        tipo: import_zod68.z.enum(["conversacion", "feedback_card", "configurada_explicito"]),
+        conversacionId: import_zod68.z.string().nullable(),
+        cardId: import_zod68.z.string().nullable()
       }).describe("Where this routine was scheduled from."),
-      confirm: import_zod65.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
+      confirm: import_zod68.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
     },
     async ({ uidDestinatario, tipo, frecuencia, config, accion, origen, confirm }) => {
       const ctx = await buildContext(session, null, { confirmationGranted: confirm === true });
@@ -18197,8 +18624,8 @@ function registerMartinTools(server, session) {
     "pausar_rutina",
     "Pause an active routine temporarily. Can be resumed later by re-enabling it.",
     {
-      rutinaId: import_zod65.z.string().min(1).describe("Routine document ID to pause."),
-      motivo: import_zod65.z.string().optional().describe("Optional reason for pausing (logged for audit).")
+      rutinaId: import_zod68.z.string().min(1).describe("Routine document ID to pause."),
+      motivo: import_zod68.z.string().optional().describe("Optional reason for pausing (logged for audit).")
     },
     async ({ rutinaId, motivo }) => {
       const ctx = await buildContext(session, null);
@@ -18224,9 +18651,9 @@ function registerMartinTools(server, session) {
     "archivar_rutina",
     "Archive a routine that no longer applies. The routine is preserved for audit purposes but will NOT be executed. Requires confirmation.",
     {
-      rutinaId: import_zod65.z.string().min(1).describe("Routine document ID to archive (will not execute again)."),
-      motivo: import_zod65.z.string().optional().describe("Optional reason for archiving (logged for audit)."),
-      confirm: import_zod65.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
+      rutinaId: import_zod68.z.string().min(1).describe("Routine document ID to archive (will not execute again)."),
+      motivo: import_zod68.z.string().optional().describe("Optional reason for archiving (logged for audit)."),
+      confirm: import_zod68.z.boolean().optional().describe("Set to true on the re-invocation after the user confirms. Default false.")
     },
     async ({ rutinaId, motivo, confirm }) => {
       const ctx = await buildContext(session, null, { confirmationGranted: confirm === true });