orquestra-mcp 1.18.2 → 1.23.0

package/README.md

@@ -1,6 +1,6 @@
 # orquestra-mcp
 
-Servidor MCP (Model Context Protocol) para Orquestra. Expone **89 tools**
+Servidor MCP (Model Context Protocol) para Orquestra. Expone **99 tools**
 que llaman a la API de `orquestra-infra`: lectura de contexto/dashboard/
 workspace/infra/paridad/listados, escritura de tareas/ideas/changelog/
 notas/docs/módulos/flujo/categorías/infra/proyectos, y corridas de QA —
@@ -192,7 +192,7 @@ create/update sigue siendo criterio del agente y del humano.
 
 ## Estado
 
-89 tools: lectura (contexto, dashboard, workspace, infra, paridad, standup,
+99 tools: lectura (contexto, dashboard, workspace, infra, paridad, standup,
 sync report, setup guide, playbooks de etapa y de plataforma, catálogo de
 skills, search) + `list_*` de cada colección + creación/edición de tareas
 (con checklist, tiempo, adjuntos, merge), ideas (con comentarios), notas,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orquestra-mcp",
-  "version": "1.18.2",
+  "version": "1.23.0",
   "description": "Servidor MCP de Orquestra -- 89 tools para leer y escribir tareas, ideas, changelog, infraestructura, contenido, QA y más desde un agente de IA",
   "type": "module",
   "bin": {

package/src/platformPlaybooks.mjs

@@ -1,6 +1,15 @@
 // Puerto exacto de orquestra-web/src/lib/platformPlaybooks.js (PLATFORM_PLAYBOOKS) --
 // constantes estaticas, sin acceso a red ni a la base de datos. get_platform_playbook
 // lo lee directo desde aca (mismo criterio que stages.mjs/foundations.mjs).
+// Puerto de TRACKING_TOOLS de la web: herramientas de medición conectables a una
+// distribución web. El ID vive en distributions.publishForm[key]. `pattern` valida
+// el formato (se serializa como string en la web, acá es el RegExp directo).
+export const TRACKING_TOOLS = [
+  { key: 'ga4_measurement_id', label: 'Google Analytics 4', idLabel: 'ID de medición', pattern: /^G-[A-Z0-9]{6,12}$/, example: 'G-ABC123DEF4', where: 'Google Analytics → Admin → Flujos de datos' },
+  { key: 'meta_pixel_id',      label: 'Meta Pixel',         idLabel: 'ID del Pixel',    pattern: /^\d{8,20}$/,          example: '1234567890123456', where: 'Meta Business → Events Manager' },
+  { key: 'gtm_container_id',   label: 'Google Tag Manager', idLabel: 'ID del contenedor', pattern: /^GTM-[A-Z0-9]{4,10}$/, example: 'GTM-ABC1234', where: 'Tag Manager → Administrador → ID del contenedor' },
+]
+
 export const PLATFORM_PLAYBOOKS = {
 
   ios: {
@@ -265,4 +274,132 @@ export const PLATFORM_PLAYBOOKS = {
       },
     ],
   },
+  web: {
+    label: 'Web — SEO y analítica',
+    color: '#4A7CFF',
+    // Sin formulario de tienda ni "Completar con IA": una web no declara
+    // nada en una consola, solo tiene el checklist y la guía de referencia
+    // (DistributionGuide.jsx esconde la columna del formulario si es false).
+    hasForm: false,
+    consoleName: 'SEO y analítica',
+    moduleName:        'SEO y analítica web',
+    moduleDescription: 'Checklist para que la web/landing nazca medible e indexable: Search Console, analítica, rendimiento y SEO básico, para que no se olvide nada al lanzar.',
+    moduleTags:        ['playbook', 'seo', 'analitica'],
+
+    referenceGuide: [
+      {
+        key: 'search_console',
+        title: 'Google Search Console',
+        body: 'Sin esto Google no te dice si te indexó ni por qué no apareces. Agrega la propiedad (mejor tipo "Dominio", verificando por registro DNS TXT, así cubre www, http/https y subdominios), envía el sitemap.xml y revisa el informe de Páginas indexadas a la semana. Es gratis y es la fuente real de errores de indexación y consultas de búsqueda.',
+      },
+      {
+        key: 'analytics',
+        title: 'Google Analytics 4 / Firebase Analytics',
+        body: 'Mide visitas, origen y conversiones. Si el sitio ya usa Firebase, activa Google Analytics en el proyecto y usa el SDK web (measurementId); si no, crea una propiedad GA4 y pega la etiqueta. Define al menos un evento de conversión (registro, clic en CTA, descarga). Si el sitio sirve a usuarios de la UE/México, acuerda el aviso de cookies y consentimiento antes de activar.',
+      },
+      {
+        key: 'meta_pixel',
+        title: 'Meta Pixel (si harás anuncios)',
+        body: 'Solo si vas a pautar en Facebook/Instagram: crea el Pixel en Meta Business → Events Manager y pega su ID numérico abajo en "Conexiones de medición". Sirve para medir conversiones de los anuncios y armar audiencias de remarketing. Requiere consentimiento de cookies en la UE/México y debe mencionarse en la política de privacidad.',
+      },
+      {
+        key: 'bing_webmaster',
+        title: 'Bing Webmaster Tools (opcional)',
+        body: 'Importa la propiedad directo desde Search Console en un clic. Cubre Bing, DuckDuckGo y parte de los asistentes con IA que usan su índice.',
+      },
+      {
+        key: 'sitemap_robots',
+        title: 'sitemap.xml y robots.txt',
+        body: 'Ambos en la raíz del dominio y respondiendo 200. robots.txt debe apuntar al sitemap y NO bloquear todo (Disallow: /) por un resto del entorno de staging. En SPAs (React/Vite) verifica que el sitemap lo genere el build, no que sea un archivo olvidado a mano.',
+      },
+      {
+        key: 'meta_tags',
+        title: 'Título, meta description y etiquetas por página',
+        body: 'Cada página indexable necesita <title> único (≤60 caracteres) y meta description (≤155) que venda el clic, un solo <h1>, y <link rel="canonical">. Una SPA que sirve el mismo <title> en todas las rutas pierde casi todo el SEO: usa prerender/SSR o un manejador de head por ruta.',
+      },
+      {
+        key: 'social_preview',
+        title: 'Open Graph / Twitter Cards',
+        body: 'og:title, og:description y og:image (1200x630) para que al compartir el enlace en WhatsApp, LinkedIn o X se vea una tarjeta, no una URL pelona. Pruébalo pegando el enlace en cada red antes de lanzar.',
+      },
+      {
+        key: 'performance',
+        title: 'Rendimiento: Core Web Vitals / PageSpeed',
+        body: 'Mide con PageSpeed Insights (móvil primero). Los puntos que casi siempre pesan: imágenes sin comprimir ni dimensiones (usa WebP/AVIF y lazy-loading), fuentes bloqueantes, JS sin dividir. LCP < 2.5s, CLS < 0.1, INP < 200ms son los umbrales de "bueno" de Google.',
+      },
+      {
+        key: 'structured_data',
+        title: 'Datos estructurados (schema.org)',
+        body: 'JSON-LD de Organization (y SoftwareApplication, FAQPage o Product según el sitio) para optar a resultados enriquecidos. Valida con la prueba de resultados enriquecidos de Google antes de publicar.',
+      },
+      {
+        key: 'https_domain',
+        title: 'HTTPS, dominio canónico y redirecciones',
+        body: 'Elige una sola versión (con o sin www) y redirige 301 las demás, incluido http → https. Evita cadenas de redirecciones y páginas duplicadas bajo dos URLs.',
+      },
+      {
+        key: 'privacy_legal',
+        title: 'Privacidad y consentimiento',
+        body: 'Si usas analítica o cookies, la política de privacidad debe mencionarlas y estar enlazada en el pie. Es requisito de Google Analytics aceptar sus términos de procesamiento de datos.',
+      },
+    ],
+
+    tasks: [
+      {
+        title:       'Agregar el sitio a Google Search Console y enviar el sitemap',
+        description: 'Crear la propiedad (tipo Dominio, verificación por DNS TXT), enviar sitemap.xml y confirmar que no marque errores de indexación. Sin esto no hay forma de saber si Google ve el sitio.',
+        type: 'tech', priority: 'high', tags: ['seo', 'web', 'search-console'], offsetDays: 1,
+      },
+      {
+        title:       'Instalar analítica (Google Analytics 4 / Firebase Analytics) y definir una conversión',
+        description: 'Activar GA4 (o Google Analytics en el proyecto Firebase y usar el SDK web con measurementId), confirmar en Tiempo real que registra visitas propias y marcar al menos un evento como conversión (registro, CTA, descarga).',
+        type: 'tech', priority: 'high', tags: ['seo', 'web', 'analytics'], offsetDays: 2, checkKey: 'analytics',
+      },
+      {
+        title:       'Instalar Meta Pixel y verificar el evento PageView',
+        description: 'Solo si habrá anuncios en Facebook/Instagram: crear el Pixel en Events Manager, instalarlo en el sitio y confirmar PageView con la extensión Meta Pixel Helper o la pestaña Probar eventos.',
+        type: 'tech', priority: 'low', tags: ['seo', 'web', 'analytics', 'meta'], offsetDays: 4, checkKey: 'meta_pixel',
+      },
+      {
+        title:       'Verificar que sitemap.xml y robots.txt respondan 200 y no bloqueen el sitio',
+        description: 'Abrirlos en el navegador en el dominio de producción. Revisar que robots.txt no tenga "Disallow: /" heredado de staging y que apunte al sitemap. En SPAs, comprobar que el hosting no devuelva index.html para estas rutas.',
+        type: 'tech', priority: 'high', tags: ['seo', 'web'], offsetDays: 2,
+      },
+      {
+        title:       'Revisar título, meta description, h1 y canonical de cada página indexable',
+        description: 'Un <title> único (≤60) y meta description (≤155) por página, un solo h1 y canonical. Si es SPA, confirmar que cada ruta los entrega al rastreador (prerender/SSR o manejador de head).',
+        type: 'tech', priority: 'medium', tags: ['seo', 'web'], offsetDays: 3,
+      },
+      {
+        title:       'Configurar Open Graph / Twitter Cards con imagen 1200x630',
+        description: 'og:title, og:description, og:image y twitter:card. Probar el enlace pegándolo en WhatsApp, LinkedIn y X.',
+        type: 'business', priority: 'medium', tags: ['seo', 'web', 'social'], offsetDays: 3,
+      },
+      {
+        title:       'Medir y corregir Core Web Vitals en PageSpeed Insights (móvil)',
+        description: 'Correr PageSpeed Insights sobre la home y las páginas clave. Objetivo: LCP < 2.5s, CLS < 0.1, INP < 200ms. Atacar primero imágenes sin comprimir, fuentes bloqueantes y JS sin dividir.',
+        type: 'tech', priority: 'medium', tags: ['seo', 'web', 'performance'], offsetDays: 5,
+      },
+      {
+        title:       'Fijar dominio canónico y redirecciones 301 (www / http → https)',
+        description: 'Elegir una sola versión del dominio y redirigir las demás con 301, sin cadenas de redirecciones. Confirmar HTTPS válido.',
+        type: 'tech', priority: 'medium', tags: ['seo', 'web'], offsetDays: 3,
+      },
+      {
+        title:       'Agregar datos estructurados (JSON-LD) y validarlos',
+        description: 'Organization como mínimo, más SoftwareApplication/FAQPage/Product según el sitio. Validar con la prueba de resultados enriquecidos de Google.',
+        type: 'tech', priority: 'low', tags: ['seo', 'web'], offsetDays: 7,
+      },
+      {
+        title:       'Importar la propiedad a Bing Webmaster Tools',
+        description: 'Importar desde Search Console en un clic. Opcional, pero cubre Bing/DuckDuckGo y asistentes de IA que usan su índice.',
+        type: 'business', priority: 'low', tags: ['seo', 'web'], offsetDays: 7,
+      },
+      {
+        title:       'Verificar/crear política de privacidad que mencione la analítica y cookies',
+        description: 'Si el sitio usa analítica o cookies, la política de privacidad tiene que mencionarlo y estar enlazada en el pie. Revisar también si hace falta aviso de consentimiento de cookies.',
+        type: 'business', priority: 'medium', tags: ['seo', 'web', 'compliance'], offsetDays: 3, checkKey: 'privacy',
+      },
+    ],
+  },
 }

package/src/server.mjs

@@ -6,7 +6,7 @@ import { z } from 'zod'
 import { loadConfig, apiGet, apiPost, apiPatch, apiDelete, putToPresignedUrl, ApiError } from './api.mjs'
 import { STAGES, PLAYBOOKS } from './stages.mjs'
 import { FOUNDATIONS } from './foundations.mjs'
-import { PLATFORM_PLAYBOOKS } from './platformPlaybooks.mjs'
+import { PLATFORM_PLAYBOOKS, TRACKING_TOOLS } from './platformPlaybooks.mjs'
 import { SKILLS_CATALOG } from './skillsCatalog.mjs'
 import { parseSource, previewSkill, installSkill } from './skillInstall.mjs'
 
@@ -89,6 +89,8 @@ Al aplicar un playbook con apply_stage_playbook -- sobre todo el de etapa "post"
 
 Al aplicar apply_platform_playbook (Platform Playbook de publicación iOS/Android) con publishForm: solo completa las claves para las que tengas base real del proyecto (código, get_project_context, servicios/entornos ya configurados) -- mismo criterio que el botón "Completar con IA" de la web: category/content_rights/data_collection/content_rating suelen inferirse bien para una app B2B sin ads/tracking, pero pricing, availability, package/bundle ID, cuentas demo para el reviewer o el nombre exacto de la app NUNCA se inventan -- dejalas fuera de publishForm para que el usuario las complete a mano. Si la tool devuelve publishFormConflict, la distribución ya tenía datos guardados en esas claves y no se escribió nada -- mostrale al usuario el valor actual vs. el propuesto de cada una, y repetí el llamado con confirmReplace:true solo si confirma explícito el reemplazo (no lo asumas ni lo repitas sin esa confirmación).
 
+Analítica y anuncios en un sitio web: antes de instalar o tocar Google Analytics 4, Meta Pixel o Tag Manager en el código, llama a get_tracking_ids -- si la distribución web ya tiene el ID guardado (ga4_measurement_id, meta_pixel_id, gtm_container_id), úsalo tal cual; nunca inventes un ID ni se lo vuelvas a pedir al usuario. Si falta y el usuario te lo da (o lo lees literal en el código/consola real), guárdalo con set_tracking_ids para que el resto de agentes y la guía web lo vean. Si ya hay uno distinto guardado, no lo reemplaces sin confirmación explícita (confirmReplace).
+
 Durante el trabajo normal de código, sin que el usuario te lo pida explícitamente y SIN ESPERAR a que lo mencione (si tienes esta tool disponible en la sesión, se usa por default en todo trabajo real, no solo cuando alguien dice "usa Orquestra"):
 - Si te pide una funcionalidad o arreglo real (no una pregunta rápida ni exploración de código sin cambios), revisa con list_tasks/search si ya existe una tarea relacionada; si no, créala con create_task ANTES de empezar a trabajar, en el estatus inicial del proyecto (ver list_statuses). Si no hay un proyecto default configurado para esta carpeta, no te rindas ahí -- usa get_workspace_summary para encontrar el proyecto correcto y pásalo explícito como projectId en cada llamada.
 - Mientras trabajas, mueve la tarea por los estatus reales según avanzas (no la dejes en el inicial hasta el final). Al terminar, muévela a su estatus final con update_task y registra una entrada de changelog con create_changelog_entry -- así el usuario nunca tiene que documentar esto a mano. Si sabes en qué repo real estás trabajando (podés correr "git remote get-url origin" o ya lo sabes por la carpeta), pásalo SIEMPRE como "repo" ("owner/name") -- encontrado real (17 ago 2026): ni el hook local ni el GitHub Action ni la reconciliación de orquestra-infra lo estaban mandando pese a que el campo existe hace rato, así que ninguna entrada automática sabía de qué repo/plataforma venía. Si además la distribución de ese repo ya está identificada (ver list_distributions), pásala en "distributions" -- sin esto el changelog no puede filtrar/agrupar por plataforma.
@@ -369,7 +371,7 @@ export function createServer() {
     'get_platform_playbook',
     {
       description: 'Guía de referencia + checklist accionable para publicar en App Store Connect (iOS) o Google Play Console (Android) -- "Platform Playbook", paralelo a get_stage_playbook pero sobre una PLATAFORMA/distribución concreta, no la etapa del proyecto. No llama a la API -- datos estáticos. "referenceGuide" es texto de referencia (no genera tareas); "tasks" es el checklist accionable (misma forma que get_stage_playbook, se puede convertir en módulo + tareas reales).',
-      inputSchema: { platform: z.enum(['ios', 'android']).describe('ios (App Store Connect) | android (Google Play Console)') },
+      inputSchema: { platform: z.enum(['ios', 'android', 'web']).describe('ios (App Store Connect) | android (Google Play Console) | web (SEO y analítica: Search Console, GA4/Firebase Analytics, sitemap, meta tags, Core Web Vitals)') },
     },
     async ({ platform }) => textResult(PLATFORM_PLAYBOOKS[platform])
   )
@@ -508,7 +510,7 @@ export function createServer() {
       categoryId: z.string().optional(),
       moduleId: z.string().describe('OBLIGATORIO -- módulo al que pertenece esta tarea, para poder agruparla/revisarla después. Si no existe uno relacionado, llamá primero a list_modules (para no duplicar) y create_module.'),
       dueDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, 'Formato esperado: YYYY-MM-DD').describe('OBLIGATORIO -- fecha estimada de término (YYYY-MM-DD), calculada con criterio real según prioridad/tamaño del trabajo (mismo criterio que la "revisión de sincronización" de get_sync_report), nunca un valor arbitrario.'),
-      reviewDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, 'Formato esperado: YYYY-MM-DD').optional().describe('Fecha para volver a MIRAR esta tarea -- recordatorio, NO un entregable. Úsalo para tareas de espera sin deadline real (ej. "esperar respuesta de Apple y revisar en 5 días"): en ese caso NO llenes dueDate, llena reviewDate. Distinto de dueDate (fecha de término real de un entregable) -- una tarea puede tener ambos, uno solo, o ninguno. Dispara un aviso (notificación + correo) al assignedTo el día que llega, un solo disparo.'),
+      reviewDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, 'Formato esperado: YYYY-MM-DD').optional().describe('Fecha para volver a MIRAR esta tarea -- recordatorio, NO un entregable. Para un aviso CON HORA (ej. en 5 horas) usa set_task_reminder. Úsalo para tareas de espera sin deadline real (ej. "esperar respuesta de Apple y revisar en 5 días"): en ese caso NO llenes dueDate, llena reviewDate. Distinto de dueDate (fecha de término real de un entregable) -- una tarea puede tener ambos, uno solo, o ninguno. Dispara un aviso (notificación + correo) al assignedTo el día que llega, un solo disparo.'),
       assignedTo: z.string().optional().describe('uid del miembro asignado'),
       tags: z.array(z.string()).optional(),
       scope: z.array(z.object({ distId: z.string(), layer: z.string().optional(), done: z.boolean() })).optional()
@@ -613,6 +615,190 @@ export function createServer() {
     }
   )
 
+  // Revisión de Contenido (ORQ-184, 2 oct 2026). Aprobar NO tiene tool propia:
+  // es update_content con status "approved" (el server estampa quién/cuándo).
+  // GitHub (ORQ-200, 3 oct 2026): las rutas aceptan token de servicio del proyecto.
+  // Crear/borrar integraciones NO se expone a propósito: maneja el PAT y exige
+  // sesión de miembro (web).
+  registerRead(
+    'list_github_integrations',
+    '/v1/github-integrations',
+    'Lista los repos de GitHub conectados a un proyecto (repo, rama, distribución vinculada, último error/chequeo). Úsala para saber qué repos alimentan el changelog antes de pedir actividad o un sync.',
+    {},
+    (args, projectId) => ({ projectId })
+  )
+
+  registerRead(
+    'get_github_activity',
+    '/v1/github-activity',
+    'Actividad reciente de GitHub por repo conectado del proyecto (commits, PRs). Sirve para saber qué se hizo realmente sin leer el repo a mano.',
+    { days: z.number().int().min(1).max(90).optional().describe('Ventana en días hacia atrás (default del servidor)') },
+    (args, projectId) => ({ projectId, days: args.days })
+  )
+
+  server.registerTool(
+    'sync_task_from_github',
+    {
+      description: 'Actualiza UNA tarea desde GitHub: busca commits/PRs que la mencionan (ORQ-###) y refleja su estado real. Si el proyecto tiene varios repos conectados, pasa integrationId (list_github_integrations).',
+      inputSchema: {
+        projectId: z.string().optional().describe(PROJECT_ID_DESC),
+        taskId: z.string().describe('ID de la tarea'),
+        integrationId: z.string().optional().describe('Integración (repo) concreta; opcional si solo hay una'),
+      },
+    },
+    async ({ projectId, taskId, integrationId }) => {
+      try {
+        return textResult(await apiPost(config, `/v1/tasks/${taskId}/sync-github`, { projectId: resolveProjectId(projectId), ...(integrationId ? { integrationId } : {}) }))
+      } catch (err) {
+        return errorResult(err)
+      }
+    }
+  )
+
+  server.registerTool(
+    'run_closure_scan',
+    {
+      description: 'Escanea la actividad reciente de GitHub y PROPONE cerrar tareas cuyo trabajo ya aparece hecho (sugerencias closure_proposal, nunca cierra nada sola). Revisa las propuestas con list_suggestions y acepta con accept_suggestion.',
+      inputSchema: {
+        projectId: z.string().optional().describe(PROJECT_ID_DESC),
+        days: z.number().int().min(1).max(90).optional().describe('Ventana en días hacia atrás (default del servidor)'),
+      },
+    },
+    async ({ projectId, days }) => {
+      try {
+        return textResult(await apiPost(config, '/v1/closure-scan', { projectId: resolveProjectId(projectId), ...(days ? { days } : {}) }))
+      } catch (err) {
+        return errorResult(err)
+      }
+    }
+  )
+
+  server.registerTool(
+    'request_content_changes',
+    {
+      description: 'Pide cambios en una pieza de contenido que está en revisión: guarda tu comentario en el historial (reviewComments), la devuelve a borrador y avisa (push + correo) a quien la creó. No existe un estado "rechazado". En una pieza multi-canal (channels[]) channelId es obligatorio. Para aprobar usa update_content con status "approved".',
+      inputSchema: {
+        projectId: z.string().optional().describe(PROJECT_ID_DESC),
+        contentId: z.string().describe('ID de la pieza (list_content)'),
+        text: z.string().describe('Qué hay que cambiar -- queda guardado como comentario de revisión'),
+        channelId: z.string().optional().describe('Solo si la pieza es multi-canal: el canal (variante) al que se refieren los cambios'),
+      },
+    },
+    async ({ projectId, contentId, text, channelId }) => {
+      try {
+        const data = await apiPost(config, `/v1/content/${contentId}/request-changes`, { projectId: resolveProjectId(projectId), text, ...(channelId ? { channelId } : {}) })
+        return textResult(data)
+      } catch (err) {
+        return errorResult(err)
+      }
+    }
+  )
+
+  server.registerTool(
+    'ai_review_content',
+    {
+      description: 'Pre-revisión visual con IA de la imagen de una pieza contra el Brand Kit (colores, texto legible, voz de marca): deja un semáforo green/yellow/red con observaciones en aiPreReview. Es informativa, nunca aprueba ni rechaza sola. Cuesta 1 crédito de IA. Se corre sola antes del aviso al aprobador.',
+      inputSchema: {
+        projectId: z.string().optional().describe(PROJECT_ID_DESC),
+        contentId: z.string().describe('ID de la pieza (list_content)'),
+        channelId: z.string().optional().describe('Solo si la pieza es multi-canal'),
+      },
+    },
+    async ({ projectId, contentId, channelId }) => {
+      try {
+        return textResult(await apiPost(config, `/v1/content/${contentId}/ai-review`, { projectId: resolveProjectId(projectId), ...(channelId ? { channelId } : {}) }))
+      } catch (err) {
+        return errorResult(err)
+      }
+    }
+  )
+
+  server.registerTool(
+    'regenerate_content_image',
+    {
+      description: 'Regenera la imagen de una pieza con IA usando su imagePrompt original MÁS tus comentarios (y los anteriores). Corre en segundo plano (la respuesta es inmediata, "regenerating"; el resultado aparece en la pieza en ~1 minuto: la imagen nueva queda en mediaFiles, la anterior en imageHistory, y la pieza vuelve a "review" avisando al aprobador). Gasta 5 créditos de IA del workspace (se reembolsan si falla) y hay un tope de 5 regeneraciones por pieza/canal. mode "reference" (default) edita la imagen actual para mantener la composición; "scratch" genera desde cero.',
+      inputSchema: {
+        projectId: z.string().optional().describe(PROJECT_ID_DESC),
+        contentId: z.string().describe('ID de la pieza (list_content)'),
+        text: z.string().describe('Comentarios para la nueva imagen (ej. "más luz, sin texto")'),
+        mode: z.enum(['reference', 'scratch']).optional().describe('reference (default) = editar la imagen actual; scratch = desde cero'),
+        channelId: z.string().optional().describe('Solo si la pieza es multi-canal: el canal (variante) cuya imagen se regenera'),
+      },
+    },
+    async ({ projectId, contentId, text, mode, channelId }) => {
+      try {
+        const data = await apiPost(config, `/v1/content/${contentId}/regenerate-image`, { projectId: resolveProjectId(projectId), text, ...(mode ? { mode } : {}), ...(channelId ? { channelId } : {}) })
+        return textResult(data)
+      } catch (err) {
+        return errorResult(err)
+      }
+    }
+  )
+
+  // Recordatorio con hora de una tarea (2 oct 2026, a pedido de José) --
+  // "recuérdame en 5 horas revisar X con Ana" / "mañana revisa Y para poder
+  // cerrarla". Azúcar sobre PATCH /v1/tasks { remindAt (epoch ms), remindNote }:
+  // el job orquestra-reminders (modo remindAt, cada ~15 min) avisa por
+  // notificación + correo a assignedTo (o createdBy) y deja remindAt en null.
+  // El cálculo de "en 5h"/"mañana" se hace ACÁ (hora local de la máquina del
+  // usuario), no en el server, que no conoce su zona horaria.
+  const REMIND_IN_RE = /^(\d+)\s*(m|min|h|hr|d)$/i
+  function resolveRemindAt({ remindIn, remindAt }) {
+    if (remindIn && remindAt) throw new Error('Manda remindIn O remindAt, no los dos.')
+    if (remindAt) {
+      const ms = Date.parse(remindAt)
+      if (Number.isNaN(ms)) throw new Error('remindAt inválido -- formato ISO 8601, idealmente con zona (ej. 2026-10-03T09:00:00-06:00).')
+      return ms
+    }
+    if (!remindIn) throw new Error('Falta remindIn (ej. "5h", "30m", "2d", "tomorrow") o remindAt (ISO 8601).')
+    const v = remindIn.trim().toLowerCase()
+    if (v === 'tomorrow' || v === 'mañana') {
+      const d = new Date()
+      d.setDate(d.getDate() + 1)
+      d.setHours(9, 0, 0, 0)
+      return d.getTime()
+    }
+    const m = REMIND_IN_RE.exec(v)
+    if (!m) throw new Error('remindIn inválido -- usa "30m", "5h", "2d" o "tomorrow" (mañana 9:00 hora local).')
+    const n = Number(m[1])
+    const unit = m[2][0] // m | h | d
+    const ms = unit === 'm' ? n * 60000 : unit === 'h' ? n * 3600000 : n * 86400000
+    return Date.now() + ms
+  }
+
+  server.registerTool(
+    'set_task_reminder',
+    {
+      description: 'Programa (o quita) un recordatorio CON HORA sobre una tarea: a esa hora Orquestra avisa por notificación in-app + correo a la persona asignada (o a quien creó la tarea si no hay asignado), una sola vez. Úsalo para "recuérdame mañana revisar X para poder cerrarla" o "en 5 horas revisarla con Ana": pasa la nota con QUÉ hay que revisar/con quién. Resolución real ~15 min (no es un reloj al minuto). Para un recordatorio por DÍA sin hora sigue sirviendo reviewDate en update_task. Mandar clear=true quita el recordatorio pendiente.',
+      inputSchema: {
+        projectId: z.string().optional().describe(PROJECT_ID_DESC),
+        taskId: z.string().describe('Tarea sobre la que se programa el recordatorio'),
+        remindIn: z.string().optional().describe('Relativo a ahora: "30m", "5h", "2d" o "tomorrow" (mañana 9:00, hora local). Alternativa a remindAt.'),
+        remindAt: z.string().optional().describe('Momento exacto en ISO 8601, idealmente con zona horaria (ej. 2026-10-03T16:30:00-06:00). Alternativa a remindIn.'),
+        note: z.string().max(500).optional().describe('Qué hay que revisar o con quién (aparece en la notificación y el correo). Muy recomendable.'),
+        clear: z.boolean().optional().describe('true = quita el recordatorio pendiente de la tarea (ignora remindIn/remindAt).'),
+      },
+    },
+    async ({ projectId, taskId, remindIn, remindAt, note, clear }) => {
+      try {
+        const body = { projectId: resolveProjectId(projectId), id: taskId }
+        if (clear) {
+          body.remindAt = null
+        } else {
+          body.remindAt = resolveRemindAt({ remindIn, remindAt })
+          if (note !== undefined) body.remindNote = note
+        }
+        const data = await apiPatch(config, '/v1/tasks', body)
+        return textResult({
+          ...data,
+          reminder: clear ? 'quitado' : { remindAt: new Date(body.remindAt).toISOString(), note: note ?? null },
+        })
+      } catch (err) {
+        return errorResult(err)
+      }
+    }
+  )
+
   // Postproxy (integración de Contenido, 24 ago 2026) -- server.registerTool
   // directo, mismo criterio que merge_task/unmerge_task: son POST a
   // `${path}/${id}/connect-postproxy|publish-postproxy`, no un CRUD
@@ -622,7 +808,7 @@ export function createServer() {
   server.registerTool(
     'connect_postproxy_channel',
     {
-      description: 'Inicia la conexión de un canal (facebook/instagram/tiktok/linkedin) a Postproxy. Devuelve UNA de dos formas: {url} -- OAuth hosteado por Postproxy, el usuario tiene que abrirlo y completarlo a mano (el agente no puede terminar un OAuth por su cuenta), pásale esa URL tal cual; o {needsPageSelection, profileId, profileLabel, pages} -- pasa con facebook y linkedin, cuando ya hay un login de esa red conectado en la cuenta (un solo login da acceso a varias Pages de Facebook, o al perfil personal y las Organization Pages de LinkedIn, no hace falta repetir el OAuth) y hace falta elegir cuál corresponde a este canal. Esa elección hoy es un flujo de la web (Cuentas conectadas) -- si te llega `needsPageSelection`, dile al usuario que complete la selección ahí, esta tool no tiene una contraparte para elegir la página. Modelo real de Postproxy: cada perfil (login) vive en UN solo profile group y Orquestra usa un group por proyecto -- el OAuth de esta tool deja el perfil nuevo en el group de este proyecto; una cuenta de Instagram/TikTok conectada desde otro proyecto NO se puede reusar acá (sería publicar en la cuenta de otro proyecto), hay que conectar la cuenta correcta. Solo para los tipos que soporta Postproxy -- un canal newsletter (Buttondown) se conecta desde la web, no con esta tool.',
+      description: 'Inicia la conexión de un canal (facebook/instagram/tiktok/linkedin) a Postproxy. DISPONIBLE BAJO SOLICITUD (1 oct 2026): si el workspace no tiene Postproxy habilitado, la API responde 403 `postproxy_not_enabled` -- no reintentes ni busques otra vía; dile al usuario que un admin la solicite desde Contenido → Cuentas conectadas → "Solicitar conexión" en la web (se habilita a mano, le avisan por correo). Puede seguir planeando y redactando la pieza mientras tanto. Devuelve UNA de dos formas: {url} -- OAuth hosteado por Postproxy, el usuario tiene que abrirlo y completarlo a mano (el agente no puede terminar un OAuth por su cuenta), pásale esa URL tal cual; o {needsPageSelection, profileId, profileLabel, pages} -- pasa con facebook y linkedin, cuando ya hay un login de esa red conectado en la cuenta (un solo login da acceso a varias Pages de Facebook, o al perfil personal y las Organization Pages de LinkedIn, no hace falta repetir el OAuth) y hace falta elegir cuál corresponde a este canal. Esa elección hoy es un flujo de la web (Cuentas conectadas) -- si te llega `needsPageSelection`, dile al usuario que complete la selección ahí, esta tool no tiene una contraparte para elegir la página. Modelo real de Postproxy: cada perfil (login) vive en UN solo profile group y Orquestra usa un group por proyecto -- el OAuth de esta tool deja el perfil nuevo en el group de este proyecto; una cuenta de Instagram/TikTok conectada desde otro proyecto NO se puede reusar acá (sería publicar en la cuenta de otro proyecto), hay que conectar la cuenta correcta. Solo para los tipos que soporta Postproxy -- un canal newsletter (Buttondown) se conecta desde la web, no con esta tool.',
       inputSchema: {
         projectId: z.string().optional().describe(PROJECT_ID_DESC),
         channelId: z.string().describe('Canal a conectar (ver list_channels) -- su `type` tiene que ser facebook/instagram/tiktok/linkedin'),
@@ -1060,7 +1246,7 @@ export function createServer() {
         projectId: z.string().optional().describe(PROJECT_ID_DESC),
         ideaId: z.string().describe('Idea -- usá search para encontrar su id'),
         text: z.string().describe('Texto del comentario'),
-        authorName: z.string().optional().describe('Default "IA" -- solo cambialo si el comentario es una cita textual de otra persona, no lo tuyo.'),
+        authorName: z.string().optional().describe('Default: el nombre del agente registrado al instalar el MCP ("IA" si no hay) -- solo cambialo si el comentario es una cita textual de otra persona, no lo tuyo.'),
       },
     },
     async ({ projectId, ideaId, text, authorName }) => {
@@ -1836,7 +2022,7 @@ export function createServer() {
       description: 'Aplica el Platform Playbook de publicación (iOS App Store / Google Play) sobre una distribución real: crea el módulo + tareas de la plantilla (igual que apply_stage_playbook) y, si mandás publishForm, también completa el formulario de la Guía de publicación de esa distribución (mismo dato que llena DistributionGuide.jsx en la web). Solo completá campos para los que tengas una base real del proyecto (código, get_project_context, servicios/entornos configurados) -- nunca inventes pricing, availability, package/bundle ID, cuentas demo para el reviewer, o el nombre exacto de la app; dejalos afuera de publishForm para que el usuario los complete a mano. Si la distribución YA tiene valores guardados en alguna de las claves que mandás, la tool NO los sobreescribe en silencio -- devuelve publishFormConflict con el valor actual vs. el propuesto por cada clave en conflicto, sin tocar publishForm. Mostrale ese conflicto al usuario y volvé a llamar con confirmReplace:true SOLO si confirma explícitamente el reemplazo. Si este playbook YA se aplicó antes sobre esta misma distribución (módulo+tareas ya creados), la tool lo detecta sola (mismo mecanismo que el badge "Ya aplicado" de DistributionGuide.jsx) y NO vuelve a crear módulo/tareas duplicados -- devuelve alreadyApplied:true. Volvé a llamar con force:true SOLO si el usuario pide explícitamente un checklist nuevo encima del que ya existe.',
       inputSchema: {
         projectId: z.string().optional().describe(PROJECT_ID_DESC),
-        platform: z.enum(['ios', 'android']).describe('ios (App Store Connect) | android (Google Play Console) -- ver get_platform_playbook para el contenido'),
+        platform: z.enum(['ios', 'android', 'web']).describe('ios (App Store Connect) | android (Google Play Console) | web (SEO y analítica, sin formulario) -- ver get_platform_playbook para el contenido'),
         distributionId: z.string().describe('Distribución real sobre la que aplicar el playbook (ver list_distributions) -- ahí vive el publishForm existente, si lo hay.'),
         moduleName: z.string().optional().describe('Nombre del módulo -- default: el de la plantilla'),
         publishForm: z.record(z.string()).optional().describe('Respuestas a completar, clave = key de referenceGuide (ver get_platform_playbook). Omitido o vacío = solo crea módulo + tareas, sin tocar el formulario.'),
@@ -1890,7 +2076,9 @@ export function createServer() {
           result.markedApplied = true
         }
 
-        if (publishForm && Object.keys(publishForm).length > 0) {
+        if (publishForm && Object.keys(publishForm).length > 0 && playbook.hasForm === false) {
+          result.publishFormIgnored = 'La guía web no tiene formulario de publicación (no hay consola que declarar) -- publishForm se ignoró.'
+        } else if (publishForm && Object.keys(publishForm).length > 0) {
           const distributions = await apiGet(config, '/v1/distributions', { projectId: pid })
           const dist = distributions.items.find(d => d.id === distributionId)
           if (!dist) {
@@ -1924,5 +2112,96 @@ export function createServer() {
     }
   )
 
+  // ═══ IDs de medición (GA4 / Meta Pixel / GTM) de una distribución web ═══
+  // Viven en distributions.publishForm (mismo mapa que la Guía de publicación,
+  // ver TRACKING_TOOLS en platformPlaybooks.mjs). PATCH reemplaza el mapa
+  // completo, así que set_tracking_ids lee y mezcla antes de escribir.
+  server.registerTool(
+    'get_tracking_ids',
+    {
+      description: 'Lee los IDs de medición conectados a las distribuciones del proyecto: Google Analytics 4 (ID de medición G-…), Meta Pixel (ID numérico) y Google Tag Manager (GTM-…). Úsalo ANTES de instalar o editar analítica/anuncios en el código de un sitio: si hay un ID guardado, ese es el que debes usar -- nunca inventes ni pidas de nuevo uno que ya está. Devuelve por distribución los IDs presentes y cuáles faltan.',
+      inputSchema: {
+        projectId: z.string().optional().describe(PROJECT_ID_DESC),
+        distributionId: z.string().optional().describe('Solo esta distribución (ver list_distributions). Omitido = todas las de tipo web.'),
+      },
+    },
+    async ({ projectId, distributionId }) => {
+      try {
+        const pid = resolveProjectId(projectId)
+        const { items } = await apiGet(config, '/v1/distributions', { projectId: pid })
+        const dists = items.filter(d => distributionId ? d.id === distributionId : d.type === 'web')
+        if (distributionId && dists.length === 0) {
+          throw new Error(`No se encontró la distribución "${distributionId}" en este proyecto -- revisá list_distributions.`)
+        }
+        return textResult({
+          distributions: dists.map(d => {
+            const form = d.publishForm || {}
+            return {
+              distributionId: d.id,
+              name: d.name || d.label,
+              type: d.type,
+              domain: d.domain || null,
+              ids: Object.fromEntries(TRACKING_TOOLS.map(t => [t.key, form[t.key] || null])),
+              missing: TRACKING_TOOLS.filter(t => !form[t.key]).map(t => t.key),
+            }
+          }),
+          tools: TRACKING_TOOLS.map(t => ({ key: t.key, label: t.label, idLabel: t.idLabel, example: t.example, where: t.where })),
+        })
+      } catch (err) {
+        return errorResult(err)
+      }
+    }
+  )
+
+  server.registerTool(
+    'set_tracking_ids',
+    {
+      description: 'Guarda (o quita) los IDs de medición de una distribución web: ga4_measurement_id (G-…), meta_pixel_id (solo dígitos) y gtm_container_id (GTM-…). Mezcla con lo ya guardado -- solo toca las claves que mandas; "" quita una. Valida el formato. SOLO guarda un ID que el usuario te dio o que leíste literal en el código/consola real del sitio -- nunca lo inventes. Si ya hay un valor distinto guardado y no mandas confirmReplace:true, no escribe y devuelve el conflicto: muéstraselo al usuario y repite con confirmReplace:true solo si confirma.',
+      inputSchema: {
+        projectId: z.string().optional().describe(PROJECT_ID_DESC),
+        distributionId: z.string().describe('Distribución web (ver list_distributions)'),
+        ga4_measurement_id: z.string().optional().describe('ID de medición de GA4, ej. G-ABC123DEF4. "" lo quita.'),
+        meta_pixel_id: z.string().optional().describe('ID numérico del Meta Pixel. "" lo quita.'),
+        gtm_container_id: z.string().optional().describe('ID del contenedor de Tag Manager, ej. GTM-ABC1234. "" lo quita.'),
+        confirmReplace: z.boolean().optional().describe('Default false. true solo si el usuario ya confirmó reemplazar un valor existente que te devolvió el conflicto.'),
+      },
+    },
+    async ({ projectId, distributionId, confirmReplace, ...ids }) => {
+      try {
+        const pid = resolveProjectId(projectId)
+        const { items } = await apiGet(config, '/v1/distributions', { projectId: pid })
+        const dist = items.find(d => d.id === distributionId)
+        if (!dist) throw new Error(`No se encontró la distribución "${distributionId}" en este proyecto -- revisá list_distributions.`)
+
+        const existing = dist.publishForm || {}
+        const patch = {}
+        const invalid = []
+        for (const t of TRACKING_TOOLS) {
+          if (ids[t.key] === undefined) continue
+          const raw = String(ids[t.key]).trim()
+          const v = t.key === 'meta_pixel_id' ? raw : raw.toUpperCase()
+          if (v && !t.pattern.test(v)) invalid.push({ key: t.key, value: raw, expected: t.example })
+          else patch[t.key] = v
+        }
+        if (invalid.length) throw new Error(`Formato inválido: ${invalid.map(i => `${i.key} "${i.value}" (ej. ${i.expected})`).join(', ')}`)
+        if (Object.keys(patch).length === 0) throw new Error('No mandaste ningún ID para guardar.')
+
+        const conflicts = Object.entries(patch)
+          .filter(([k, v]) => existing[k] && existing[k] !== v)
+          .map(([key, proposed]) => ({ key, current: existing[key], proposed: proposed || '(quitar)' }))
+        if (conflicts.length > 0 && !confirmReplace) {
+          return textResult({ updated: false, conflicts, message: 'Ya hay valores guardados distintos. No se escribió nada -- muéstraselos al usuario y repite con confirmReplace:true solo si confirma el reemplazo.' })
+        }
+
+        const merged = { ...existing }
+        for (const [k, v] of Object.entries(patch)) { if (v) merged[k] = v; else delete merged[k] }
+        await apiPatch(config, '/v1/distributions', { projectId: pid, id: distributionId, publishForm: merged })
+        return textResult({ updated: true, distributionId, written: patch })
+      } catch (err) {
+        return errorResult(err)
+      }
+    }
+  )
+
   return server
 }