orquestra-mcp 1.46.0 → 1.47.0

package/README.md

@@ -12,25 +12,34 @@ configurar/sincronizar un proyecto completo sin crear duplicados.
 Ver `CLAUDE.md` para contexto de desarrollo. Ver la memoria del proyecto
 `orquestra-mcp-api-plan` para las 8 fases del plan MCP/API completo.
 
-## Setup rápido (recomendado)
+## Empezar (macOS, Linux y Windows)
+
+Necesitas una cuenta en [app.orquestra.me](https://app.orquestra.me) y Node 18+.
+
+**1. Conecta tu cuenta y tu proyecto** — desde la carpeta de tu proyecto:
 
 ```bash
-npm install
-node bin/orquestra-mcp.mjs setup
+npx orquestra-mcp@latest setup
 ```
 
-Esto abre tu navegador en `https://app.orquestra.me/cli-auth` para
-confirmar tu sesión (Google o email/password, lo que ya uses) y:
+Abre el navegador para confirmar tu sesión (Google o email/password) y luego:
+
+- Si **no tienes workspace**, te pide su nombre y después el de tu primer proyecto.
+- Si **perteneces a varios workspaces**, te deja elegir en cuál trabajar (elegir aquí
+  no cambia el que tienes abierto en la web).
+- Eliges un proyecto de ese workspace o creas uno nuevo.
+
+La conexión se guarda **por carpeta** en `~/.orquestra/mcp-config.json`: puedes tener
+distintos proyectos (o cuentas) en distintas carpetas. Para conectar otra carpeta o
+cambiar de proyecto, vuelve a correr el setup ahí.
 
-- Si **no tienes** workspace/proyecto todavía: te crea uno default
-  ("Mi primer proyecto", con los 6 estatus base) — puedes renombrarlo o
-  cambiarlo cuando quieras desde `orquestra-web`.
-- Si **ya tienes** uno o varios: te deja elegir cuál usar por default
-  desde la misma terminal.
+**2. Regístralo en tu agente** (ver abajo: Claude Code, Claude Desktop, Cursor, Codex,
+Gemini CLI). Usa `orquestra-mcp@latest` para que `npx` no se quede con una versión vieja
+de su caché.
 
-Guarda todo (`apiToken`, `workspaceId`, `defaultProjectId`) en
-`~/.orquestra/mcp-config.json` — después de esto, `node bin/orquestra-mcp.mjs`
-(sin más flags ni env vars) ya funciona.
+**Ver la versión / actualizar:** `npm view orquestra-mcp version` muestra la última
+publicada. Con `@latest` cada arranque la usa; el servidor que ya está corriendo conserva
+la suya hasta que reconectas (en Claude Code: `/mcp` → reconectar).
 
 Variable opcional `ORQUESTRA_WEB_URL` para apuntar el login a otro lugar
 (ej. `http://localhost:5173` mientras desarrollas `orquestra-web` local en
@@ -71,35 +80,57 @@ Variables de entorno (todas opcionales si ya corriste `setup` — se leen de
 
 ### Claude Code
 
-Si ya corriste `setup`, alcanza con:
+macOS / Linux:
 
 ```bash
-claude mcp add orquestra -- node /ruta/absoluta/a/orquestra-mcp/bin/orquestra-mcp.mjs
+claude mcp add orquestra -- npx -y orquestra-mcp@latest
 ```
 
-O manual, sin `setup`:
+Windows (PowerShell) — `npx` necesita `cmd /c` delante:
 
-```bash
-claude mcp add orquestra \
-  -e ORQUESTRA_API_TOKEN=orq_... \
-  -e ORQUESTRA_WORKSPACE_ID=... \
-  -- node /ruta/absoluta/a/orquestra-mcp/bin/orquestra-mcp.mjs
+```powershell
+claude mcp add orquestra -- cmd /c npx -y orquestra-mcp@latest
 ```
 
+Agrega `--scope user` después de `add` para tenerlo en todos tus proyectos. Si PowerShell
+dice que `claude` no se reconoce, falta instalar Claude Code:
+`npm install -g @anthropic-ai/claude-code` (y vuelve a abrir la terminal). Si ya lo habías
+agregado sin `@latest`, primero `claude mcp remove orquestra`.
+
 ### Claude Desktop (`claude_desktop_config.json`)
 
+- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- Windows: `%APPDATA%\Claude\claude_desktop_config.json`
+
 ```json
 {
   "mcpServers": {
     "orquestra": {
-      "command": "node",
-      "args": ["/ruta/absoluta/a/orquestra-mcp/bin/orquestra-mcp.mjs"]
+      "command": "npx",
+      "args": ["-y", "orquestra-mcp@latest"]
     }
   }
 }
 ```
 
-(sin `env` si ya corriste `setup`; si no, agrega `ORQUESTRA_API_TOKEN`/`ORQUESTRA_WORKSPACE_ID` igual que en Claude Code.)
+Cierra la app por completo (en Windows también desde el ícono junto al reloj) y vuelve a
+abrirla.
+
+### Cursor, Codex CLI, Gemini CLI
+
+Mismo comando (`npx -y orquestra-mcp@latest`), cambia el archivo — ver
+[orquestra.me/mcp#instalacion](https://www.orquestra.me/mcp#instalacion). En Windows, si
+el agente no encuentra `npx`, usa `"command": "cmd"` con
+`"args": ["/c", "npx", "-y", "orquestra-mcp@latest"]`.
+
+### Sin `setup` (variables de entorno)
+
+```bash
+claude mcp add orquestra \
+  -e ORQUESTRA_API_TOKEN=orq_... \
+  -e ORQUESTRA_WORKSPACE_ID=... \
+  -- npx -y orquestra-mcp@latest
+```
 
 ## Tools
 

package/bin/orquestra-mcp.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
-import { createServer } from '../src/server.mjs'
+import { createServer, createSetupNeededServer } from '../src/server.mjs'
 import { runSetup } from '../src/setup.mjs'
 import { runVaultSync } from '../src/vaultSync.mjs'
 
@@ -9,7 +9,7 @@ const HELP_TEXT = `orquestra-mcp -- Servidor MCP de Orquestra (132 tools)
 Uso:
   npx orquestra-mcp            Inicia el servidor MCP por stdio -- lo usa tu cliente
                                 MCP (Claude Code, Claude Desktop, etc.), no se corre a mano
-  npx orquestra-mcp setup      Login por navegador + configura tu proyecto default
+  npx orquestra-mcp setup      Login por navegador + conecta esta carpeta a un proyecto
   npx orquestra-mcp vault sync <carpeta> [--apply]
                                 Sincroniza la base de conocimiento del workspace con una
                                 carpeta de tu vault de Obsidian (la 1ra vez solo muestra el plan)
@@ -50,7 +50,7 @@ async function main() {
     server = createServer()
   } catch (err) {
     console.error(`[orquestra-mcp] ${err.message}`)
-    process.exit(1)
+    server = createSetupNeededServer(err.message)
   }
 
   const transport = new StdioServerTransport()

package/package.json

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

package/src/api.mjs

@@ -27,12 +27,15 @@ export function loadConfig() {
   if (!apiToken) missing.push('ORQUESTRA_API_TOKEN')
   if (!workspaceId) missing.push('ORQUESTRA_WORKSPACE_ID')
   if (missing.length) {
+    const folders = Object.keys(fileConfig?.projects || {})
     throw new Error(
-      `Faltan variables de entorno requeridas: ${missing.join(', ')} (y no hay config en ${CONFIG_PATH}). ` +
-      `Corre "npx orquestra-mcp setup" para conectarlo con tu cuenta -- crea un workspace/proyecto ` +
-      `default si no tienes uno, o te deja elegir uno existente. Alternativa manual: 1) cuenta+workspace ` +
-      `ya creados en orquestra-web, 2) generar un token con POST ${apiBase}/v1/tokens con tu ID token ` +
-      `de Firebase, y 3) pasar ese token + el workspaceId acá.`
+      `Esta carpeta (${process.cwd()}) no está conectada a Orquestra. ` +
+      (folders.length
+        ? `Carpetas conectadas en ${CONFIG_PATH}: ${folders.join(' | ')}. `
+        : `No hay ninguna carpeta conectada (${CONFIG_PATH} no existe o está vacío). `) +
+      `Solución: abre una terminal en esta carpeta y corre "npx orquestra-mcp@latest setup" ` +
+      `(o ábrela desde una carpeta que ya esté conectada), y después reconecta el MCP. ` +
+      `Alternativa sin setup: variables de entorno ${missing.join(' y ')}.`
     )
   }
 

package/src/configFile.mjs

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
 import { homedir } from 'os'
-import { join, dirname, sep } from 'path'
+import { join, dirname, win32, posix } from 'path'
 
 export const CONFIG_PATH = join(homedir(), '.orquestra', 'mcp-config.json')
 
@@ -63,13 +63,27 @@ export function upsertProjectMapping({ apiBase, apiToken, workspaceId, folderPat
 // gana, así que un repo individual con su propio mapeo (y su propia cuenta)
 // puede sobreescribir el de la carpeta contenedora que lo engloba. Devuelve
 // el objeto {apiBase, apiToken, workspaceId, projectId} de esa carpeta.
-export function resolveProjectForCwd(projects, cwd) {
+// En Windows las rutas no distinguen mayúsculas, y VS Code arranca el
+// servidor con la unidad en minúscula ("c:\Users\...") aunque setup haya
+// guardado "C:\Users\..." (o con "/" en vez de "\"). Comparar exacto hacía
+// que no encontrara la carpeta y el servidor se cerrara al arrancar
+// ("Connection closed" en Claude Code, 21 oct 2026). `platform` es para tests.
+export function folderKey(folderPath, platform = process.platform) {
+  const isWin = platform === 'win32'
+  const resolved = (isWin ? win32 : posix).resolve(folderPath)
+  const trimmed = resolved.length > 1 && !/^[a-z]:\\$/i.test(resolved) ? resolved.replace(/[\\/]+$/, '') : resolved
+  return isWin ? trimmed.toLowerCase() : trimmed
+}
+
+export function resolveProjectForCwd(projects, cwd, platform = process.platform) {
   if (!projects) return undefined
+  const sep = platform === 'win32' ? '\\' : '/'
+  const target = folderKey(cwd, platform)
   let best = null
   for (const folderPath of Object.keys(projects)) {
-    const normalized = folderPath.endsWith(sep) ? folderPath.slice(0, -1) : folderPath
-    if (cwd !== normalized && !cwd.startsWith(normalized + sep)) continue
-    if (!best || normalized.length > best.length) best = normalized
+    const key = folderKey(folderPath, platform)
+    if (target !== key && !target.startsWith(key.endsWith(sep) ? key : key + sep)) continue
+    if (!best || key.length > best.key.length) best = { key, folderPath }
   }
-  return best ? projects[best] : undefined
+  return best ? projects[best.folderPath] : undefined
 }

package/src/foundations.mjs

@@ -4,9 +4,20 @@
 // analytics/crash reporting ausentes en las 4 apps). Constantes estáticas,
 // sin acceso a red ni a la base de datos -- mismo criterio que stages.mjs.
 // get_foundations_checklist las expone tal cual; el agente conectado hace
-// la detección real (grep del repo local) y usa report_foundation_gap para
-// cada una que confirme ausente -- ver SERVER_INSTRUCTIONS.
+// la detección real (grep del repo local) y reporta con report_foundations
+// (ORQ-400: queda en el checklist de fundamentos del proyecto). Las keys son
+// las mismas que CODE_FOUNDATIONS de orquestra-infra (lib/foundations.mjs);
+// `detectedByServer` = el servidor lo ve solo en el árbol de los repos conectados.
 export const FOUNDATIONS = [
+  {
+    key: 'readme',
+    label: 'README para levantar el proyecto',
+    category: 'calidad',
+    why: 'Sin instrucciones de setup (dependencias, variables de entorno, comandos), cada persona nueva -- o tu yo del futuro -- pierde horas reconstruyéndolo.',
+    detectionHint: 'README en la raíz del repo que de verdad explique cómo levantarlo, no solo el título.',
+    scales: ['landing', 'app', 'platform'],
+    detectedByServer: true,
+  },
   {
     key: 'analytics',
     label: 'Analytics de producto',
@@ -14,6 +25,7 @@ export const FOUNDATIONS = [
     why: 'Sin eventos básicos (pantallas, acciones clave) no hay forma de saber qué usa la gente ni de tomar decisiones con datos.',
     detectionHint: 'Buscar SDKs de analytics en dependencias (Firebase Analytics, Segment, Amplitude, PostHog, Mixpanel) o gtag/GA4 en el HTML -- y confirmar que de verdad se llame (logEvent/track), no solo que esté listada la dependencia.',
     scales: ['app', 'platform'],
+    detectedByServer: false,
   },
   {
     key: 'crash_reporting',
@@ -22,6 +34,7 @@ export const FOUNDATIONS = [
     why: 'Sin esto, los crashes de usuarios reales son invisibles -- solo se enteran si alguien reporta a mano.',
     detectionHint: 'Buscar Crashlytics/Sentry/Bugsnag en dependencias, y confirmar inicialización real en el entrypoint de la app (no solo la dependencia listada y sin usar).',
     scales: ['app', 'platform'],
+    detectedByServer: false,
   },
   {
     key: 'error_alerting',
@@ -30,6 +43,7 @@ export const FOUNDATIONS = [
     why: 'Un log que nadie lee no es monitoreo -- sin una alarma real, un backend caído puede tardar horas o días en notarse.',
     detectionHint: 'Buscar alarmas de CloudWatch con AlarmActions/SNS, integraciones de Sentry/PagerDuty, o un webhook de errores a Slack/email en la infraestructura.',
     scales: ['platform'],
+    detectedByServer: false,
   },
   {
     key: 'dependency_scanning',
@@ -38,6 +52,7 @@ export const FOUNDATIONS = [
     why: 'Dependencias con vulnerabilidades conocidas quedan sin parchear indefinidamente si nada avisa cuando aparecen.',
     detectionHint: 'Buscar .github/dependabot.yml, renovate.json, o un paso de audit (npm audit / pip-audit / similar) en el CI.',
     scales: ['app', 'platform'],
+    detectedByServer: true,
   },
   {
     key: 'ci_pipeline',
@@ -46,5 +61,6 @@ export const FOUNDATIONS = [
     why: 'Sin lint/tests/build automáticos en cada PR, cada regresión depende de que alguien la note a mano antes de mergear.',
     detectionHint: 'Buscar workflows de CI (.github/workflows/*.yml, GitLab CI, CircleCI) con jobs que corran en pull_request, no solo en push a main.',
     scales: ['app', 'platform'],
+    detectedByServer: true,
   },
 ]

package/src/platformPlaybooks.mjs

@@ -16,7 +16,7 @@ export const PLATFORM_PLAYBOOKS = {
     label: 'iOS — App Store',
     color: '#007AFF',
     moduleName:        'Publicación en App Store',
-    moduleDescription: 'Checklist verificable para enviar la app a revisión en App Store Connect, sin sorpresas de último momento.',
+    moduleDescription: 'Lo que hay que decidir y preparar para enviar la app a revisión en App Store Connect, sin sorpresas de último momento. Que la ficha esté publicada y que las URLs de privacidad y soporte respondan lo revisa solo el checklist de Buenas prácticas.',
     moduleTags:        ['playbook', 'publicacion'],
 
     // Revisado contra App Store Connect real el 19 oct 2026 (ORQ-383). `section`
@@ -190,17 +190,9 @@ export const PLATFORM_PLAYBOOKS = {
 
     // `optional: true` = no viene seleccionada por default al aplicar (pasos
     // de crecimiento que solo tienen sentido con la app ya aprobada).
+    // Sin tareas de "verificar URL de privacidad/soporte" (ORQ-398): las
+    // prueba solo el checklist de Buenas prácticas y, si falla, ahí se crea la tarea.
     tasks: [
-      {
-        title:       'Verificar/crear política de privacidad pública (URL)',
-        description: 'App Store Connect pide una URL pública de política de privacidad antes de poder enviar a revisión. Si el proyecto no tiene una, hay que publicarla (puede vivir en la landing).',
-        type: 'business', priority: 'high', tags: ['publicacion', 'ios'], offsetDays: 2, checkKey: 'privacy',
-      },
-      {
-        title:       'Verificar/crear página o contacto de soporte',
-        description: 'Apple pide una URL de soporte visible para el usuario (puede ser un mailto, un formulario o una página de FAQ). Probarla en el navegador: tiene que responder 200.',
-        type: 'business', priority: 'high', tags: ['publicacion', 'ios'], offsetDays: 2, checkKey: 'support',
-      },
       {
         title:       'Confirmar que la app permite eliminar la cuenta desde adentro',
         description: 'Guideline 5.1.1(v), obligatorio -- "escríbenos por correo" NO cumple el requisito. Tiene que haber un botón real de "Eliminar cuenta" (con confirmación) en Perfil/Ajustes que borre la cuenta y los datos sin salir de la app. Si no existe, constrúyelo ANTES de mandar a revisión, no después de un rechazo.',
@@ -288,7 +280,7 @@ export const PLATFORM_PLAYBOOKS = {
     label: 'Android — Google Play',
     color: '#3DDC84',
     moduleName:        'Publicación en Google Play',
-    moduleDescription: 'Checklist verificable para publicar la app en Google Play Console, sin sorpresas de último momento.',
+    moduleDescription: 'Lo que hay que decidir y preparar para publicar la app en Google Play Console, sin sorpresas de último momento. Que la ficha esté publicada y que la URL de privacidad responda lo revisa solo el checklist de Buenas prácticas.',
     moduleTags:        ['playbook', 'publicacion'],
 
     referenceGuide: [
@@ -369,22 +361,9 @@ export const PLATFORM_PLAYBOOKS = {
       },
     ],
 
+    // Sin tareas de "verificar URL de privacidad / email de soporte / que la
+    // URL responda 200" (ORQ-398): lo prueba solo el checklist de Buenas prácticas.
     tasks: [
-      {
-        title:       'Verificar/crear política de privacidad pública (URL)',
-        description: 'Play Console (Contenido de la app) pide una URL pública de política de privacidad antes de poder publicar. Si el proyecto no tiene una, hay que publicarla (puede vivir en la landing).',
-        type: 'business', priority: 'high', tags: ['publicacion', 'android'], offsetDays: 2, checkKey: 'privacy',
-      },
-      {
-        title:       'Verificar/crear página o contacto de soporte',
-        description: 'Play Console pide un email de contacto de soporte visible en la ficha de Play Store.',
-        type: 'business', priority: 'high', tags: ['publicacion', 'android'], offsetDays: 2, checkKey: 'support',
-      },
-      {
-        title:       'Probar en el navegador que la URL de privacidad/soporte responde 200 (no solo que "ya se desplegó")',
-        description: 'Gotcha real: Play Console valida que la URL responda, no solo el formato. Un deploy exitoso no garantiza que rutas como /privacidad carguen -- si el hosting es una SPA (React Router y similares) sin la regla de rewrite configurada (servir index.html para cualquier ruta), da 404 real aunque el build haya salido bien. Probar la URL directo en el navegador, en una pestaña nueva, ANTES de pegarla en el formulario.',
-        type: 'tech', priority: 'high', tags: ['publicacion', 'android'], offsetDays: 2,
-      },
       {
         title:       'Confirmar pricing y disponibilidad por país',
         description: 'Definir si la app es gratis o de pago y en qué países se distribuye -- "Disponible en todos los países" es el default razonable salvo restricción regulatoria específica.',
@@ -431,10 +410,15 @@ export const PLATFORM_PLAYBOOKS = {
     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.',
+    moduleDescription: 'Lo que hay que hacer para que la web/landing nazca medible e indexable: Search Console, analítica y rendimiento. Lo técnico (redirecciones, sitemap, contenido, canonical...) lo revisa solo el checklist de Buenas prácticas.',
     moduleTags:        ['playbook', 'seo', 'analitica'],
 
     referenceGuide: [
+      {
+        key: 'practices_checklist',
+        title: 'Lo técnico lo revisa Orquestra solo',
+        body: 'Redirecciones 301 (http→https y con/sin www), robots.txt, sitemap, noindex, contenido en el HTML, título y descripción, h1, canonical, og:image y JSON-LD se revisan solos cada lunes en "Buenas prácticas" (arriba en esta página), y te avisa si algo que estaba bien se rompe. No hace falta crear tareas para eso: si un punto falla, ahí mismo puedes crear la tarea.',
+      },
       {
         key: 'search_console',
         title: 'Google Search Console',
@@ -485,6 +469,26 @@ export const PLATFORM_PLAYBOOKS = {
         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: 'html_content',
+        title: 'El contenido tiene que venir en el HTML',
+        body: 'Una SPA (React/Vite) que sirve solo <div id="root"></div> deja a los buscadores casi sin texto: Google lo renderiza tarde y otros buscadores no lo ejecutan. Usa prerender o SSR para que cada ruta pública llegue con su contenido real.',
+      },
+      {
+        key: 'noindex_app',
+        title: 'La app y el login no deben competir con la web',
+        body: 'Si la app vive en un subdominio (app.tu-dominio.com), ponle <meta name="robots" content="noindex">. Si no, Google puede mostrar la pantalla de login en vez de tu web pública cuando alguien busca tu marca.',
+      },
+      {
+        key: 'own_links',
+        title: 'Tus enlaces, siempre a la versión canónica',
+        body: 'Bio de redes, fichas de App Store/Google Play, npm, firmas de correo y enlaces dentro de la app: todos con la misma URL (con o sin www, la que elegiste). Son las primeras señales que Google usa para entender que ese dominio eres tú.',
+      },
+      {
+        key: 'generic_name',
+        title: 'Si tu marca es una palabra común',
+        body: 'Con un nombre genérico (una palabra del diccionario) primero vas a aparecer por "marca + producto" o por tu dominio, no por la palabra sola: compites con diccionarios y sitios con años de antigüedad. Lo que acelera: enlaces de sitios reconocidos (tiendas, npm, directorios, artículos) y contenido propio.',
+      },
       {
         key: 'privacy_legal',
         title: 'Privacidad y consentimiento',
@@ -495,7 +499,7 @@ export const PLATFORM_PLAYBOOKS = {
     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.',
+        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. Al terminar, márcalo como hecho en Buenas prácticas.',
         type: 'tech', priority: 'high', tags: ['seo', 'web', 'search-console'], offsetDays: 1,
       },
       {
@@ -508,35 +512,20 @@ export const PLATFORM_PLAYBOOKS = {
         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, checkKey: 'core_web_vitals',
       },
       {
-        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:       'Revisar en Search Console la canónica que eligió Google y las páginas sin indexar',
+        description: '1-2 semanas después de lanzar (o de cambiar el dominio): inspeccionar la home y confirmar que "Google-selected canonical" sea tu URL canónica, y revisar Páginas → "Por qué no se indexan". Al terminar, márcalo como hecho en Buenas prácticas.',
+        type: 'tech', priority: 'high', tags: ['seo', 'web', 'search-console'], offsetDays: 14,
       },
       {
-        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:       'Apuntar tus perfiles y fichas a la URL canónica',
+        description: 'Bio de redes, fichas de las tiendas, npm, firmas de correo y enlaces dentro de la app con la misma URL canónica. Al terminar, márcalo como hecho en Buenas prácticas.',
+        type: 'business', priority: 'medium', tags: ['seo', 'web'], offsetDays: 7,
       },
       {
         title:       'Importar la propiedad a Bing Webmaster Tools',

package/src/server.mjs

@@ -146,7 +146,7 @@ No le preguntes al usuario por workspaceId ni projectId -- ya están configurado
 
 No crees tareas ni entradas de changelog por preguntas triviales o exploración sin cambios reales -- solo por trabajo que de verdad avanza el proyecto.
 
-Si estás iniciando una sesión de trabajo real en un proyecto que YA tiene código (no un "vacío" recién conectado, ver arriba) y hace rato no se corrió este chequeo, o el usuario pide explícito "revisa fundamentos"/"qué le falta a este proyecto" (no lo hagas en cada mensaje ni en exploración sin cambios): primero llamá a get_project_findings -- ya trae, calculado por el servidor y priorizado, lo que falta o está mal dentro de Orquestra (vencidas, bloqueadas, módulos en riesgo, paridad, infraestructura, servicios que faltan, duplicadas) -- y preséntaselo al usuario por severidad antes de seguir; luego, para lo que solo se ve en el código, llamá a get_foundations_checklist y, con acceso real al filesystem del repo (grep de dependencias, archivos de config, workflows de CI -- seguí el detectionHint de cada ítem), confirmá cuáles de verdad faltan -- filtrá por "scales" contra el scale real del proyecto (ver project.scale en get_project_context; un ítem con scales:["platform"] no aplica a una landing). Por cada uno que confirmes ausente con evidencia concreta, llamá a report_foundation_gap con esa evidencia específica -- nunca lo reportes solo porque el checklist lo menciona, sin haber revisado el código de verdad. No repitas un chequeo ya hecho recientemente en la misma sesión.
+Si estás iniciando una sesión de trabajo real en un proyecto que YA tiene código (no un "vacío" recién conectado, ver arriba) y hace rato no se corrió este chequeo, o el usuario pide explícito "revisa fundamentos"/"qué le falta a este proyecto" (no lo hagas en cada mensaje ni en exploración sin cambios): primero llamá a get_project_findings -- ya trae, calculado por el servidor y priorizado, lo que falta o está mal dentro de Orquestra (vencidas, bloqueadas, módulos en riesgo, paridad, infraestructura, servicios que faltan, duplicadas) -- y preséntaselo al usuario por severidad antes de seguir; luego, para lo que solo se ve en el código, llamá a get_foundations_checklist y, con acceso real al filesystem del repo (grep de dependencias, archivos de config, workflows de CI -- seguí el detectionHint de cada ítem), confirmá cuáles de verdad faltan -- filtrá por "scales" contra el scale real del proyecto (ver project.scale en get_project_context; un ítem con scales:["platform"] no aplica a una landing). Antes, mira get_practices sin distributionId: los ítems con detectedByServer ya los revisa el servidor en los repos conectados, así que concéntrate en los que salen "unknown". Reporta en UNA llamada a report_foundations lo que confirmaste (pass si existe y se usa, fail si falta, na con motivo si el usuario decidió no tenerlo), con evidencia específica de archivos reales -- nunca lo reportes solo porque el checklist lo menciona, sin haber revisado el código de verdad. No repitas un chequeo ya hecho recientemente en la misma sesión.
 
 Si el usuario pregunta explícito qué Claude Skills de terceros le faltan (o pide instalar alguna) -- no lo hagas sin que te lo pidan: llamá a get_skills_catalog y revisá con acceso real al filesystem cuáles de esos keys ya existen en .claude/skills/ (del proyecto) o ~/.claude/skills/ (global). Antes de instalar cualquiera con install_skill, llamá primero a preview_skill y mostrale al usuario el skillMdContent completo -- nunca instales sin que haya visto ese contenido y confirmado explícitamente, los SKILL.md de terceros pueden traer instrucciones que un agente ejecuta solo con cargarlas.`
 
@@ -161,6 +161,22 @@ const SCOPE_EVIDENCE = {
   notApplicableReason: z.string().optional().describe('Motivo de "no aplica" (obligatorio si notApplicable es true)'),
 }
 
+// Sin conexión para la carpeta (loadConfig falló): antes el proceso se cerraba
+// y el cliente solo mostraba "Connection closed", sin el motivo. Ahora arranca
+// con una sola tool que explica qué pasa y cómo arreglarlo, para que el agente
+// se lo diga al usuario.
+export function createSetupNeededServer(reason) {
+  const server = new McpServer(
+    { name: 'orquestra-mcp', version: PKG_VERSION },
+    { instructions: `Orquestra no está conectado en esta carpeta, así que sus herramientas no están disponibles. Si el usuario pide algo de Orquestra, llama a diagnostico_conexion y explícale cómo arreglarlo. Motivo: ${reason}` },
+  )
+  server.registerTool('diagnostico_conexion', {
+    description: 'Explica por qué Orquestra no está conectado en esta carpeta y cómo arreglarlo.',
+    inputSchema: {},
+  }, async () => ({ content: [{ type: 'text', text: `orquestra-mcp ${PKG_VERSION}: ${reason}` }] }))
+  return server
+}
+
 export function createServer() {
   const config = loadConfig()
   const server = new McpServer({ name: 'orquestra-mcp', version: PKG_VERSION }, { instructions: SERVER_INSTRUCTIONS })
@@ -357,6 +373,79 @@ export function createServer() {
     { distributionId: z.string().describe('Distribución type="web" con domain configurado') }
   )
 
+  // Buenas prácticas (ORQ-392/394; tiendas iOS/Android ORQ-398): checklist que
+  // evalúa el servidor (lib/practices.mjs y lib/storePractices.mjs en infra) y
+  // guarda en `distributions.practices`. No hay
+  // GET propio: se lee de la distribución. Los puntos manuales los confirma una
+  // persona en la web -- a propósito no hay tool para marcarlos.
+  server.registerTool(
+    'get_practices',
+    {
+      description: 'Checklist de buenas prácticas de una distribución, evaluado por el servidor cada lunes. Web: redirecciones 301 (http→https, con/sin www), robots.txt, sitemap, noindex, contenido en el HTML sin JS, título/descripción, h1, canonical, og:image, JSON-LD y Core Web Vitals; para la app (indexable=false) solo https + noindex. iOS/Android: ficha pública en App Store/Google Play, que la ficha enlace a la web canónica, frescura de la versión, capturas y calificación, y que las URLs de privacidad/soporte respondan 200. Cada punto trae status (pass|warn|fail|unknown|manual|na), severity, detail y evidence ya redactados -- úsalos tal cual, no re-diagnostiques. Los puntos group="manual" (Search Console, Data Collection/Data safety, cuenta demo del revisor...) los confirma el usuario en la web. Úsala después de un deploy o de llenar la guía de publicación (antes, run_practices) o cuando el usuario pregunte por SEO, indexación o la ficha de la tienda. Para corregir un fail, trabaja en el código real del repo o en la guía de publicación y vuelve a revisar. SIN distributionId devuelve los checklists del PROYECTO, revisados a diario: FUNDAMENTOS (proyectos de código en construcción o lanzados: distribuciones, servicios, entornos y repos registrados, canal de beta, agente de QA, bugs de prioridad alta abiertos, y el grupo Código -- README/CI/Dependabot los ve el servidor en los repos conectados, analytics/crash_reporting/error_alerting solo con report_foundations) y CRECIMIENTO (etapa post): canales registrados y con ritmo, ritmo cumplido por canal en 28 días, contenido programado a 7 días, changelog reciente, última versión anunciada en Contenido, IDs de medición y buenas prácticas de la web pública -- para corregir un fail de ritmo crea piezas reales con create_content en canales de list_channels, nunca inventes un canal.',
+      inputSchema: {
+        projectId: z.string().optional().describe(PROJECT_ID_DESC),
+        distributionId: z.string().optional().describe('Distribución type="web", "ios" o "android" (ver list_distributions). Omitido = checklist de crecimiento del proyecto.'),
+      },
+    },
+    async ({ projectId, distributionId }) => {
+      try {
+        if (!distributionId) {
+          const p = await apiGet(config, `/v1/projects/${resolveProjectId(projectId)}`, {})
+          return textResult({
+            projectId: p.id, name: p.name, phase: p.phase,
+            foundations: p.foundations || null,
+            foundationsManual: p.foundationsManual || {},
+            foundationsCode: p.foundationsCode || {},
+            growth: p.growth || null,
+            growthManual: p.growthManual || {},
+            hint: [
+              !p.foundations && 'Fundamentos: se revisa en proyectos de código en construcción (mvp/alpha/beta) o ya lanzados.',
+              !p.growth && 'Crecimiento: solo en la etapa post (fase launch/v1/v2/v3/mantenimiento) o con el playbook post aplicado.',
+            ].filter(Boolean).join(' ') || undefined,
+          })
+        }
+        const { items } = await apiGet(config, '/v1/distributions', { projectId: resolveProjectId(projectId) })
+        const d = (items || []).find(x => x.id === distributionId)
+        if (!d) return errorResult(new Error(`No existe la distribución ${distributionId} en este proyecto`))
+        const store = d.type === 'ios' || d.type === 'android'
+        if (d.type !== 'web' && !store) return errorResult(new Error('Las buenas prácticas solo aplican a distribuciones type="web", "ios" o "android"'))
+        return textResult({
+          id: d.id, name: d.name || d.label, type: d.type,
+          ...(store ? { bundleId: d.bundleId || d.identifier || null } : { domain: d.domain || null, indexable: d.indexable ?? null }),
+          practices: d.practices || null,
+          practicesManual: d.practicesManual || {},
+          ...(!store && !d.domain ? { hint: 'Sin domain configurado no se revisa: agrégalo con update_distribution.' } : {}),
+          ...(store && !d.bundleId && !d.identifier ? { hint: 'Sin bundleId no se encuentra la ficha de la tienda: agrégalo con update_distribution.' } : {}),
+        })
+      } catch (err) {
+        return errorResult(err)
+      }
+    }
+  )
+
+  server.registerTool(
+    'run_practices',
+    {
+      description: 'Pide una revisión nueva de buenas prácticas para una distribución web con dominio o una app iOS/Android (por ejemplo, justo después de desplegar o de publicar en la tienda). Corre en segundo plano (unos segundos): responde "running"; el resultado aparece después en get_practices. 409 si ya hay una en curso. SIN distributionId recalcula al momento los dos checklists del proyecto (fundamentos y crecimiento) y devuelve {foundations, growth}; el que no aplica a la fase del proyecto viene como {skipped}. Si un punto que pasaba ahora falla, el servidor avisa solo al equipo.',
+      inputSchema: {
+        projectId: z.string().optional().describe(PROJECT_ID_DESC),
+        distributionId: z.string().optional().describe('Distribución type="web" con domain configurado, o type="ios"/"android". Omitido = checklist de crecimiento del proyecto.'),
+      },
+    },
+    async ({ projectId, distributionId }) => {
+      try {
+        const pid = resolveProjectId(projectId)
+        if (distributionId) return textResult(await apiPost(config, '/v1/practices', { projectId: pid, distributionId }))
+        // Sin distribución: los dos checklists del proyecto; el que no aplica responde 400.
+        const run = path => apiPost(config, path, { projectId: pid }).catch(err => ({ skipped: err.message }))
+        const [foundations, growth] = await Promise.all([run('/v1/foundations'), run('/v1/growth')])
+        return textResult({ foundations, growth })
+      } catch (err) {
+        return errorResult(err)
+      }
+    }
+  )
+
   registerRead(
     'get_infra_status',
     '/v1/infra',
@@ -625,32 +714,30 @@ export function createServer() {
   server.registerTool(
     'get_foundations_checklist',
     {
-      description: 'Checklist de "fundamentos olvidados" -- prácticas chicas (analytics, crash reporting, alertas de error, escaneo de dependencias, CI) que casi ningún proyecto instrumenta por su cuenta pero suman mucho cuando faltan. No llama a la API -- datos estáticos. Cada ítem trae "scales" (a qué project.scale aplica -- "landing" queda afuera de la mayoría a propósito) y "detectionHint" para que TÚ (con acceso real al filesystem del repo) confirmes si de verdad falta antes de reportarlo con report_foundation_gap -- ver SERVER_INSTRUCTIONS para cuándo correr este chequeo.',
+      description: 'Checklist de "fundamentos olvidados" -- prácticas chicas (README, CI, escaneo de dependencias, analytics, crash reporting, alertas de error) que casi ningún proyecto instrumenta por su cuenta pero suman mucho cuando faltan. No llama a la API -- datos estáticos. Cada ítem trae "scales" (a qué project.scale aplica -- "landing" queda afuera de la mayoría a propósito), "detectionHint" para que TÚ (con acceso real al filesystem del repo) confirmes si se cumple, y "detectedByServer" (true = el servidor ya lo revisa solo en los repos conectados; no hace falta reportarlo salvo para marcar na o si no hay repo conectado). Reporta lo confirmado con report_foundations; el estado actual está en get_practices sin distributionId.',
     },
     async () => textResult(FOUNDATIONS)
   )
 
+  // ORQ-400: reemplaza a report_foundation_gap (creaba una sugerencia suelta). Ahora lo
+  // confirmado queda en el checklist de fundamentos del proyecto (project.foundationsCode),
+  // tanto lo que se cumple como lo que falta, y la web lo pinta en el Dashboard.
   server.registerTool(
-    'report_foundation_gap',
+    'report_foundations',
     {
-      description: 'Reporta un ítem de get_foundations_checklist que confirmaste ausente con evidencia real del repo (no lo llames sin haber revisado el código de verdad). Crea una sugerencia "foundation_gap", visible en el drawer "Sugerencias de IA" de la web -- aceptarla crea una tarea real (mismo mecanismo que accept_suggestion). Si ese foundationKey ya tiene una sugerencia (pending, aceptada o descartada) no crea una duplicada -- descartar una no la hace reaparecer en el siguiente chequeo.',
+      description: 'Reporta al checklist de fundamentos del proyecto lo que confirmaste en el código real de los repos (ítems de get_foundations_checklist): pass si existe Y se usa, fail si falta, na si no aplica (con el motivo). Nunca lo reportes sin haber revisado los archivos de verdad. Queda vigente 90 días y gana sobre lo que el servidor detecta solo en el repo, así que úsalo sobre todo para analytics/crash_reporting/error_alerting (el servidor no lee código) y para marcar na lo que el usuario decidió no tener. Recalcula el checklist y devuelve el resultado completo; un fail aparece en el Dashboard con "Crear tarea".',
       inputSchema: {
         projectId: z.string().optional().describe(PROJECT_ID_DESC),
-        foundationKey: z.string().describe('key del ítem de get_foundations_checklist, ej. "analytics"'),
-        title: z.string().describe('Título corto y específico al proyecto real, ej. "Falta Crashlytics en la app iOS" -- no copies el label genérico del checklist tal cual.'),
-        reason: z.string().describe('Evidencia concreta que encontraste (qué buscaste, qué NO encontraste) y por qué importa acá -- no una explicación genérica del ítem.'),
+        reports: z.array(z.object({
+          key: z.enum(FOUNDATIONS.map(f => f.key)).describe('key del ítem de get_foundations_checklist'),
+          status: z.enum(['pass', 'fail', 'na']),
+          evidence: z.string().min(1).describe('Evidencia concreta y específica del proyecto: archivo y qué encontraste (ej. "Crashlytics.crashlytics() en AppDelegate.swift, sin equivalente en la web"), o el motivo de na. Nada genérico.'),
+        })).min(1),
       },
     },
-    async ({ projectId, foundationKey, title, reason }) => {
+    async ({ projectId, reports }) => {
       try {
-        const resolvedProjectId = resolveProjectId(projectId)
-        const data = await apiPost(config, '/v1/suggestions', {
-          projectId: resolvedProjectId,
-          kind: 'foundation_gap',
-          foundationKey, title, reason,
-          idempotencyKey: `foundation:${resolvedProjectId}:${foundationKey}`,
-        })
-        return textResult(data)
+        return textResult(await apiPost(config, '/v1/foundations', { projectId: resolveProjectId(projectId), reports }))
       } catch (err) {
         return errorResult(err)
       }
@@ -2457,6 +2544,7 @@ export function createServer() {
     repoUrl: z.string().optional().describe('URL del repo de este código -- solo informativo, no requiere credenciales.'),
     knowledgeSource: z.string().optional().describe('Doc libre tipo CLAUDE.md para el agente de QA de esta distribución.'),
     publishForm: z.record(z.string()).optional().describe('Respuestas del formulario de la Guía de publicación -- clave = key de referenceGuide en get_platform_playbook, valor = texto declarado. Reemplaza el mapa completo (nunca merge parcial). Preferí apply_platform_playbook a mandar esto directo -- esa tool avisa y pide confirmación si la distribución ya tiene datos guardados, esta lo sobreescribe sin preguntar.'),
+    indexable: z.boolean().nullable().optional().describe('Solo web: ¿debe aparecer en Google? true = web pública (landing), false = app/login (las buenas prácticas le exigen noindex), null = que el servidor lo infiera. Pregúntale al usuario si no es obvio; no lo adivines.'),
   })
 
   // ═══ Contenido (Fase 1 del rediseño, 11 ago 2026; modelo multi-canal

package/src/setup.mjs

@@ -175,11 +175,17 @@ export async function runSetup() {
 
   upsertProjectMapping({ apiBase, apiToken: token, workspaceId, folderPath, projectId: defaultProjectId })
   console.log(`\nListo. "${folderPath}" (y sus subcarpetas) ya apunta a este proyecto -- guardado en ${CONFIG_PATH}.`)
+  // En Windows Claude Code necesita `cmd /c` para lanzar npx, y el config de
+  // Claude Desktop vive en %APPDATA%. `@latest` evita que npx reuse una
+  // versión vieja de su caché.
+  const isWindows = process.platform === 'win32'
   console.log('\nSiguiente paso -- conéctalo a tu agente de IA:\n')
   console.log('  Claude Code:')
-  console.log('    claude mcp add orquestra -- npx orquestra-mcp\n')
-  console.log('  Claude Desktop -- agrega esto a tu claude_desktop_config.json:')
-  console.log('    { "mcpServers": { "orquestra": { "command": "npx", "args": ["orquestra-mcp"] } } }\n')
+  console.log(`    claude mcp add orquestra -- ${isWindows ? 'cmd /c ' : ''}npx -y orquestra-mcp@latest`)
+  if (isWindows) console.log('    (si "claude" no se reconoce: npm install -g @anthropic-ai/claude-code y abre otra terminal)')
+  console.log('    Después reinicia Claude Code o reconéctalo con /mcp.\n')
+  console.log(`  Claude Desktop -- agrega esto a ${isWindows ? '%APPDATA%\\Claude\\' : '~/Library/Application Support/Claude/'}claude_desktop_config.json:`)
+  console.log('    { "mcpServers": { "orquestra": { "command": "npx", "args": ["-y", "orquestra-mcp@latest"] } } }\n')
   console.log('  ¿Usas Cursor, ChatGPT/Codex o Gemini CLI? La config de cada uno está en:')
   console.log('    https://www.orquestra.me/mcp#instalacion\n')
   console.log('Docs completas y todas las tools disponibles: https://www.orquestra.me/mcp')

package/src/stages.mjs

@@ -47,39 +47,29 @@ export const PLAYBOOKS = {
   },
   build: {
     moduleName: 'Camino a beta',
-    moduleDescription: 'La base técnica y de proceso que necesitas para llegar a una beta estable con usuarios reales dando feedback.',
+    moduleDescription: 'El trabajo humano para llegar a una beta con usuarios reales dando feedback: entrada al producto, flujo de feedback y testers. Lo técnico que se puede revisar (infraestructura registrada, canal de beta, QA, bugs urgentes, README, CI, dependencias, analítica y crashes) lo revisa solo el checklist de Fundamentos del Dashboard.',
     moduleTags: ['playbook', 'proyecto'],
     intro: 'Construye con dirección: infraestructura medible, feedback desde el día uno y una beta que puedas poner en manos de usuarios reales.',
     tasks: [
-      { title: 'Configurar entornos e infraestructura base', description: 'Backend, base de datos, auth y storage funcionando. Regístralos en la sección Infra con su proveedor y estado.', type: 'tech', priority: 'high', tags: ['infra'], offsetDays: 3 },
-      { title: 'Instrumentar analytics y crash reporting', description: 'Desde el primer build: eventos clave (registro, acción principal, retorno) y reporte de crashes. Sin datos no hay decisiones.', type: 'tech', priority: 'high', tags: ['analytics'], offsetDays: 7 },
       { title: 'Implementar autenticación y onboarding', description: 'El flujo de entrada define la primera impresión. Registro simple + un onboarding que lleve al usuario a su primer momento de valor.', type: 'feature', priority: 'high', tags: ['onboarding'], offsetDays: 14 },
       { title: 'Definir flujo de feedback de beta testers', description: '¿Cómo te van a reportar bugs y sugerencias? (formulario, grupo de WhatsApp, botón in-app). Decide dónde aterriza: aquí en Ideas.', type: 'improvement', priority: 'medium', tags: ['beta', 'feedback'], offsetDays: 18 },
-      { title: 'Preparar build de beta (TestFlight / track interno / staging)', description: 'Un canal de distribución de beta por plataforma. Registra la versión en review en el panel de Infra.', type: 'tech', priority: 'high', tags: ['beta'], offsetDays: 21 },
       { title: 'Reclutar 10-20 beta testers', description: 'Idealmente del público objetivo que validaste en pre-proyecto. Amigos que no son el público te dirán que "está padre" y nada más.', type: 'business', priority: 'medium', tags: ['beta'], offsetDays: 25 },
-      { title: 'Documentar setup del proyecto (README)', description: 'Cómo levantar el proyecto desde cero: dependencias, variables de entorno, comandos. Guárdalo en Docs. Tu yo del futuro lo agradece.', type: 'docs', priority: 'low', tags: ['docs'], offsetDays: 28 },
-      { title: 'Checklist de estabilidad pre-lanzamiento', description: 'Crashes < 1%, flujos principales sin bugs conocidos, tiempos de carga aceptables, datos de prueba limpios. Si pasa, estás listo para launch.', type: 'tech', priority: 'high', tags: ['calidad'], offsetDays: 35 },
     ],
   },
   post: {
     moduleName: 'Lanzamiento y crecimiento',
-    moduleDescription: 'El plan de marketing paso a paso después de la beta: posicionamiento, canales de lanzamiento, contenido, y el loop de métricas y feedback que convierte un lanzamiento en crecimiento.',
+    moduleDescription: 'El plan de lanzamiento después de la beta: posicionamiento, landing, canales y contenido de lanzamiento. Lo que se sostiene en el tiempo (ritmo de publicación, changelog anunciado, analítica, feedback y revisión semanal de métricas) lo revisa solo el checklist de Crecimiento del Dashboard.',
     moduleTags: ['playbook', 'post-proyecto', 'marketing'],
     intro: 'Terminaste la beta — ahora el trabajo es que la gente lo use. Este playbook te lleva del "¿y ahora qué?" a un lanzamiento con canales, contenido y métricas.',
     tasks: [
       { title: 'Redactar el pitch: propuesta de valor en una frase', description: 'La frase que usarás en la tienda, la landing y redes. Fórmula: "[Producto] ayuda a [público] a [resultado] sin [dolor]". Itérala hasta que alguien ajeno la entienda a la primera.', type: 'business', priority: 'high', tags: ['marketing', 'posicionamiento'], offsetDays: 2 },
       { title: 'Preparar assets de tienda (ASO): capturas, descripción, keywords', description: '5-8 capturas que cuenten una historia (no pantallas sueltas), descripción con el pitch arriba, y keywords que tu público realmente busca.', type: 'business', priority: 'high', tags: ['marketing', 'aso'], offsetDays: 5 },
       { title: 'Publicar landing con captura de correos', description: 'Una página: pitch, 3 beneficios, capturas y un CTA (descargar o dejar correo). Los correos capturados son tu canal propio para siempre.', type: 'feature', priority: 'high', tags: ['marketing', 'landing'], offsetDays: 7 },
-      { title: 'Configurar analytics de adquisición', description: 'Fuentes de tráfico, conversión de visita→registro→activación. Necesitas saber DE DÓNDE llegan los usuarios que sí se quedan.', type: 'tech', priority: 'medium', tags: ['analytics', 'adquisición'], offsetDays: 8 },
       { title: 'Conectar tus canales reales de contenido', description: 'Antes de programar nada: registra en Contenido → Cuentas conectadas los canales donde de verdad vas a publicar (redes, blog, newsletter). El plan de contenido de abajo solo sirve con canales reales, no uno genérico — si personalizas este playbook con IA y ya tienes canales conectados, te genera piezas reales directo.', type: 'tech', priority: 'high', tags: ['marketing', 'contenido'], offsetDays: 9 },
       { title: 'Plan de contenido de lanzamiento (2 semanas)', description: 'Con tus canales ya conectados (tarea anterior), programa en Contenido: teaser, anuncio, demo del caso de uso principal, historia de por qué lo construiste, testimonios de beta testers — uno por canal real, no una lista genérica.', type: 'business', priority: 'high', tags: ['marketing', 'contenido'], offsetDays: 10 },
       { title: 'Lanzar en canales: Product Hunt, comunidades y redes', description: 'Elige 3 canales donde vive tu público (PH, subreddits, grupos de FB/Discord, foros del nicho). Un post honesto de creador funciona mejor que uno de venta.', type: 'business', priority: 'high', tags: ['marketing', 'lanzamiento'], offsetDays: 14 },
       { title: 'Contactar 10 personas con audiencia en el nicho', description: 'Creators, newsletters, podcasts o prensa pequeña del tema. Mensaje corto y personalizado + acceso gratis. Con que respondan 2, ganaste.', type: 'followup', priority: 'medium', tags: ['marketing', 'outreach'], offsetDays: 16 },
-      { title: 'Activar loop de feedback de usuarios reales', description: 'Un canal permanente: encuesta in-app, correo de bienvenida que pregunta "¿qué te trajo aquí?", o botón de sugerencias. Todo aterriza en Ideas.', type: 'improvement', priority: 'medium', tags: ['feedback'], offsetDays: 18 },
       { title: 'Definir y medir activación y retención (D1 / D7 / D30)', description: 'Activación: % que llega al momento de valor. Retención: % que regresa al día 1, 7 y 30. Estos números te dicen si tienes producto o solo descargas.', type: 'business', priority: 'medium', tags: ['métricas'], offsetDays: 21 },
-      { title: 'Ritmo de contenido post-lanzamiento (3 publicaciones/semana)', description: 'El lanzamiento es un día; el crecimiento es constancia. Deja programadas en Contenido las siguientes 2 semanas: tips de uso, casos, mejoras del changelog — repartidas entre tus canales reales conectados.', type: 'business', priority: 'medium', tags: ['marketing', 'contenido'], offsetDays: 24 },
-      { title: 'Publicar release notes / changelog público v1', description: 'Convierte tu Changelog en comunicación: qué hay de nuevo, en lenguaje de usuario. Cada release es una excusa para volver a aparecer.', type: 'docs', priority: 'low', tags: ['changelog'], offsetDays: 26 },
-      { title: 'Revisión semanal de métricas y próximos pasos', description: 'Reunión recurrente (aunque seas solo tú): adquisición, activación, retención, top feedback. Decide UNA mejora prioritaria por semana.', type: 'meeting', priority: 'medium', tags: ['métricas', 'ritmo'], offsetDays: 28 },
     ],
   },
 }