sdd-es 2.0.0 → 2.6.0

package/commands/sdd.dise/303/261ar.md

@@ -0,0 +1,188 @@
+---
+description: Fase de diseño de FORGE. Orquesta direction picker → product-designer → architecture-designer → wireframe-mvp → critica-diseno. Requiere IR previo en .sdd/ir.json.
+allowed-tools: Read, Write, Bash, Agent
+---
+
+# /sdd.diseñar — Diseño de Producto
+
+**Uso:**
+```
+/sdd.diseñar
+/sdd.diseñar confirmar
+/sdd.diseñar cambiar-direccion
+/sdd.diseñar --sin-critica
+```
+
+---
+
+## PASO 1 — Verificar IR
+
+```bash
+if [ ! -f ".sdd/ir.json" ]; then
+  echo "No hay IR todavía. Primero interpreta tu idea:"
+  echo "  /sdd.interpretar [tu idea]"
+  exit 0
+fi
+
+cat .sdd/ir.json | node -e "
+  const ir = JSON.parse(require('fs').readFileSync('/dev/stdin', 'utf8'));
+  console.log('Producto:', ir.product.name);
+  console.log('Tipo:', ir.product.type);
+"
+```
+
+Si ya hay un `product-design.json`, pregunta:
+
+```
+Ya tienes un diseño para [product.name].
+¿Qué quieres hacer?
+  1) Ver el diseño actual → /sdd.diseñar ver
+  2) Rediseñar (conservar el IR) → /sdd.diseñar rediseñar
+  3) Continuar al código → /sdd.construir
+```
+
+---
+
+## PASO 2 — Direction Picker
+
+Si no hay `design_direction` en `.sdd/estado.json`, invocar la skill `elegir-direccion`:
+
+La skill muestra 3 opciones visuales y espera la elección del usuario.
+
+Después de elegida, guarda en `.sdd/estado.json`:
+```json
+{ "design_direction": "[direction]", "design_system_path": "{PLUGIN_DIR}/design-systems/[direction]/DESIGN.md" }
+```
+
+Si ya hay dirección elegida, saltarla (a menos que sea `cambiar-direccion`).
+
+---
+
+## PASO 3 — Invocar Product Designer
+
+Activa el agente `product-designer`.
+
+El agente:
+1. Lee `.sdd/ir.json`
+2. Lee `.sdd/estado.json` (dirección y DESIGN.md)
+3. Lee `{PLUGIN_DIR}/craft/anti-ai-slop.md`
+4. Genera el `ProductDesign` JSON
+5. Muestra resumen al usuario
+6. Guarda en `.sdd/product-design.json`
+
+---
+
+## PASO 4 — Invocar Architecture Designer
+
+Activa el agente `architecture-designer`.
+
+El agente:
+1. Lee `.sdd/ir.json` + `.sdd/product-design.json`
+2. Propone el stack más simple viable
+3. Muestra resumen en lenguaje natural
+4. Agrega el campo `architecture` a `.sdd/product-design.json`
+
+---
+
+## PASO 5 — Generar Wireframe (pantalla P0)
+
+Invocar la skill `wireframe-mvp`.
+
+La skill:
+1. Lee `.sdd/product-design.json` (pantalla P0)
+2. Lee el DESIGN.md activo
+3. Lee `{PLUGIN_DIR}/craft/anti-ai-slop.md`
+4. Genera el HTML de la pantalla P0
+5. Guarda en `.sdd/diseño/wireframe-pantalla-principal.html` con la tool `Write`
+6. Abre el archivo en el navegador del sistema (`start`/`open`/`xdg-open`)
+
+Si se pasa `--sin-critica`, saltar el PASO 6.
+
+---
+
+## PASO 6 — Crítica y Refinamiento
+
+Invocar la skill `critica-diseno`.
+
+La skill:
+1. Lee el wireframe generado
+2. Evalúa en 5 dimensiones (score 1–5 cada una)
+3. Si score < 4 y iteraciones < 3: refina el wireframe y re-evalúa
+4. Si score ≥ 4: aprueba y termina
+5. Muestra el resultado de la crítica al usuario
+
+---
+
+## PASO 7 — Confirmar y guardar
+
+Muestra resumen final del diseño:
+
+```
+═══════════════════════════════════════════
+✅ DISEÑO COMPLETADO
+═══════════════════════════════════════════
+
+Producto: [product.name]
+Dirección visual: [design_direction]
+Pantallas: [N] pantallas ([nombres P0, P1, P2])
+Stack: [frontend] + [backend] + [database]
+Wireframe: .sdd/diseño/wireframe-pantalla-principal.html
+Score del diseño: [X]/5
+
+¿Listo para generar el código?
+  /sdd.construir     → Pipeline completo automático
+  /sdd.diseñar ver   → Ver el diseño en detalle
+```
+
+Actualizar `.sdd/estado.json`:
+
+```bash
+node -e "
+  const fs = require('fs');
+  const estado = JSON.parse(fs.readFileSync('.sdd/estado.json', 'utf8') || '{}');
+  estado.product_design_aprobado = true;
+  estado.ultima_actualizacion = new Date().toISOString();
+  fs.writeFileSync('.sdd/estado.json', JSON.stringify(estado, null, 2));
+"
+```
+
+---
+
+## Sub-comandos
+
+### `/sdd.diseñar ver`
+Muestra el ProductDesign actual en formato legible (pantallas, stack, wireframe path).
+
+### `/sdd.diseñar confirmar`
+Si el diseño ya fue generado pero esperaba confirmación explícita, lo confirma y continúa.
+
+### `/sdd.diseñar cambiar-direccion`
+Vuelve al PASO 2 (direction picker) sin borrar el IR. Regenera todo lo demás.
+
+### `/sdd.diseñar rediseñar`
+Borra el ProductDesign actual y vuelve a empezar desde el PASO 2, conservando el IR.
+
+---
+
+## Archivos generados
+
+```
+.sdd/
+  product-design.json              ← ProductDesign + ArchitectureDesign
+  estado.json                      ← product_design_aprobado: true
+  diseño/
+    wireframe-pantalla-principal.html  ← Wireframe de P0
+    critica-wireframe.md               ← Resultado de la crítica
+```
+
+---
+
+## Integración con el pipeline
+
+Después de `/sdd.diseñar`:
+
+```
+/sdd.construir   → Pipeline completo: spec + plan + tareas + código
+/sdd.exportar    → Exportar bundle del proyecto
+/sdd.estado      → Ver estado del proyecto
+```

package/commands/sdd.estado.md

@@ -28,7 +28,57 @@ fi
    Ejecuta:  /sdd.constitucion
 ```
 
-## PASO 3 — Generar dashboard completo
+## PASO 2.5 — Detectar perfil y elegir formato de dashboard
+
+```bash
+PERFIL=$(grep -o '"perfil": *"[^"]*"' .sdd/estado.json 2>/dev/null | cut -d'"' -f4)
+[ -z "$PERFIL" ] && PERFIL=$(grep '^perfil:' .sdd/sdd.config.yaml 2>/dev/null | cut -d':' -f2 | tr -d ' ')
+echo "PERFIL=${PERFIL:-guiado}"
+```
+
+- Si `PERFIL=guiado` (o no hay perfil): mostrar **dashboard de producto** (PASO 3A).
+- Si `PERFIL=experto` y no hay modo explícito `pm`/`arq`/`dev`: mostrar **dashboard técnico** (PASO 3B).
+
+## PASO 3A — Dashboard de producto (modo guiado, por defecto)
+
+Muestra el estado en lenguaje natural, sin jerga técnica:
+
+```
+Tu proyecto: [Nombre del proyecto]
+
+[Si hay feature activa:]
+Estás trabajando en: [título de la spec en lenguaje natural]
+Progreso: [N]% listo ([N] de [M] pasos completados)
+[████████████░░░░░░░░]
+
+¿Qué queda por hacer?
+  ✅ [descripción natural del paso completado más reciente]
+  → Próximo paso: [descripción natural de lo que sigue]
+
+[Si hay bloqueos:]
+  ⚠️  Hay un problema que necesita tu atención: [descripción natural del bloqueo]
+
+[Si no hay feature activa:]
+¡Listo para empezar! ¿Qué quieres construir ahora?
+```
+
+Reglas para el dashboard de producto:
+- Nunca mostrar IDs internos (`2026-06-14-auth`, `pipeline_step`, `T003`).
+- Nunca mencionar nombres de comandos a menos que el usuario los pida.
+- Usar "feature", "funcionalidad" o "lo que estás construyendo" en vez de "spec" o "especificación".
+- Traducir las fases del pipeline a lenguaje natural:
+  | Fase interna | Texto para usuario |
+  |---|---|
+  | `especificacion` | "Definiendo los detalles" |
+  | `plan` | "Planificando cómo construirlo" |
+  | `plan_aprobado` | "Plan listo, preparando tareas" |
+  | `tareas_generadas` | "Tareas listas, empezando a construir" |
+  | `implementacion` | "Construyendo..." |
+  | `implementacion_completa` | "Construcción lista, verificando" |
+  | `verificada` | "Verificado y funcionando" |
+  | `completado` | "¡Listo! Feature entregada" |
+
+## PASO 3B — Dashboard técnico (modo experto o modo `dev`)
 
 ```
 ╔════════════════════════════════════════════════════════════════╗
@@ -100,7 +150,7 @@ fi
 ╚════════════════════════════════════════════════════════════════╝
 ```
 
-## PASO 4 — Determinar próximo paso según fase
+## PASO 4 — Determinar próximo paso según fase (para ambos modos)
 
 | Fase actual | Próximo paso |
 |-------------|--------------|
@@ -116,9 +166,76 @@ fi
 | `verificada` (sin snapshot) | `/sdd.snapshot` |
 | `completado` | `/sdd.especificar [nueva feature]` |
 
-## PASO 5 — Modos adicionales
+## PASO 5 — Consumo de agentes (observabilidad)
+
+Si existe `.sdd/observabilidad/consumo.jsonl`, invocar la skill `observabilidad-consumo` y añadir una sección al dashboard:
+
+```bash
+[ -f .sdd/observabilidad/consumo.jsonl ] && wc -l .sdd/observabilidad/consumo.jsonl
+```
+
+Si hay datos, mostrar al final del dashboard:
+
+```
+╠════════════════════════════════════════════════════════════════╣
+║  📊 CONSUMO DE AGENTES (sesión actual)                         ║
+║                                                                ║
+║     [resumen de invocaciones por agente]                       ║
+║     [alertas de fan-out si las hay]                            ║
+║                                                                ║
+║     Ver detalle completo: /sdd.estado consumo                  ║
+╚════════════════════════════════════════════════════════════════╝
+```
+
+`/sdd.estado consumo` — invoca `observabilidad-consumo` y muestra el reporte completo.
+
+## PASO 6 — Modos adicionales
 
 `/sdd.estado historial` — muestra solo el historial completo de specs
 `/sdd.estado tareas` — muestra solo el detalle de tareas de la spec activa
 `/sdd.estado agentes` — muestra solo la config de agentes
+`/sdd.estado consumo` — muestra el reporte de observabilidad de agentes
 `/sdd.estado todo` — muestra TODO lo de arriba más detalles extendidos
+
+## PASO 7 — Output styles (modos de presentación)
+
+Si el argumento contiene `pm`, `arq` o `dev`, adapta el output del dashboard:
+
+**Modo `pm` (Product Manager):**
+```
+📊 ESTADO DEL PROYECTO — [Nombre]
+
+✅ Feature en curso: [título de la spec activa en lenguaje natural]
+📈 Progreso: [N]% completado ([N] de [M] tareas listas)
+🎯 Próximo hito: [descripción en lenguaje natural del siguiente paso]
+🚦 Estado general: [Verde / Amarillo / Rojo]
+
+¿Qué necesitas saber?
+- Avance → responde "avance"
+- Bloqueos → responde "problemas"
+- Cuándo termina → responde "estimado"
+```
+
+**Modo `arq` (Arquitecto):**
+```
+📐 ESTADO TÉCNICO — [Nombre]
+
+Stack: [lenguaje/framework]
+Spec activa: [ID] — [título]
+Fase: [fase actual]
+
+Artefactos:
+  spec.md        → [✅/⏸/❌]
+  plan.md        → [✅/⏸/❌] — [versión/fecha]
+  tareas.md      → [N] tareas ([distribución por agente])
+  analisis.md    → [veredicto]
+
+Decisiones de arquitectura pendientes: [N ADRs sin cerrar]
+Riesgos abiertos: [N del último análisis]
+Deuda técnica registrada: [N items]
+
+Próxima decisión técnica requerida: [descripción]
+```
+
+**Modo `dev` (Desarrollador) — default:**
+El dashboard completo con la barra de progreso de tareas (formato actual del PASO 3).

package/commands/sdd.exportar.md

@@ -0,0 +1,344 @@
+---
+description: Exporta el proyecto como bundle portable. Detecta qué agentes/skills/comandos se usaron desde estado.json y genera {nombre}-forge-bundle/ con solo esas piezas + el proyecto + INSTALL.md.
+allowed-tools: Read, Write, Bash
+---
+
+# /sdd.exportar — Exportar Bundle
+
+**Uso:**
+```
+/sdd.exportar
+/sdd.exportar --completo     ← incluye todos los componentes de FORGE, no solo los usados
+/sdd.exportar --solo-codigo  ← solo el código del proyecto (sin los archivos .sdd/)
+/sdd.exportar --zip          ← genera un archivo ZIP del bundle
+```
+
+---
+
+## PASO 1 — Detectar qué se usó
+
+```bash
+node -e "
+  const fs = require('fs');
+
+  // Leer estado
+  const estado = JSON.parse(fs.existsSync('.sdd/estado.json')
+    ? fs.readFileSync('.sdd/estado.json', 'utf8') : '{}');
+
+  const usados = {
+    ir: !!estado.ir_generado,
+    product_design: !!estado.product_design_generado,
+    design_direction: estado.design_direction || null,
+    tiene_wireframe: fs.existsSync('.sdd/diseño/wireframe-pantalla-principal.html'),
+    tiene_spec: !!estado.spec_activa,
+    tiene_plan: !!estado.plan_activo,
+    pipeline_completado: estado.pipeline_step === 'done',
+  };
+
+  console.log(JSON.stringify(usados, null, 2));
+"
+```
+
+---
+
+## PASO 2 — Determinar componentes del bundle
+
+Según lo que se usó, incluir solo los archivos relevantes:
+
+```
+SIEMPRE incluir:
+  sdd-lite/commands/sdd.md              ← hub principal
+  sdd-lite/commands/sdd.interpretar.md
+  sdd-lite/skills/descubrir-idea/SKILL.md
+  sdd-lite/skills/interpretar-idea/SKILL.md
+  sdd-lite/core/ir.types.ts
+  .sdd/ir.json                          ← el IR del proyecto
+  INSTALL.md                            ← generado por este comando
+
+SI se usó el diseño:
+  sdd-lite/commands/sdd.diseñar.md
+  sdd-lite/skills/elegir-direccion/SKILL.md
+  sdd-lite/agents/product-designer.md
+  sdd-lite/agents/architecture-designer.md
+  sdd-lite/skills/wireframe-mvp/SKILL.md
+  sdd-lite/skills/critica-diseno/SKILL.md
+  design-systems/{direction}/DESIGN.md  ← solo la dirección usada
+  craft/anti-ai-slop.md
+  .sdd/product-design.json
+  .sdd/diseño/                          ← wireframe + crítica
+
+SI se completó el pipeline:
+  sdd-lite/commands/sdd.construir.md
+  sdd-lite/core/ir-to-spec-mapper.ts
+  sdd-lite/core/project-memory.ts
+  sdd-lite/commands/sdd.exportar.md
+  .sdd/spec-draft.json
+  [código generado del proyecto]
+
+SIEMPRE excluir:
+  node_modules/
+  .git/
+  *.log
+  forge.config.json     ← contiene API keys
+```
+
+---
+
+## PASO 3 — Crear el bundle
+
+```bash
+node -e "
+const fs = require('fs');
+const path = require('path');
+
+// ── Leer estado ────────────────────────────────────────────────────────────
+const estado = JSON.parse(fs.existsSync('.sdd/estado.json')
+  ? fs.readFileSync('.sdd/estado.json', 'utf8') : '{}');
+const ir = fs.existsSync('.sdd/ir.json')
+  ? JSON.parse(fs.readFileSync('.sdd/ir.json', 'utf8')) : null;
+
+if (!ir) {
+  console.error('Error: no hay IR todavía. Ejecuta /sdd.interpretar primero.');
+  process.exit(1);
+}
+
+const productName = ir.product.name.toLowerCase().replace(/\s+/g, '-');
+const timestamp = new Date().toISOString().slice(0, 10);
+const BUNDLE = \`\${productName}-forge-bundle\`;
+const FORGE_ROOT = path.resolve(__dirname, '..');  // raíz del repo FORGE
+
+// ── Helper: copiar archivo con creación de directorios ─────────────────────
+function cp(src, dest) {
+  const absS = path.join(FORGE_ROOT, src);
+  const absD = path.join(BUNDLE, dest || src);
+  if (!fs.existsSync(absS)) return;
+  fs.mkdirSync(path.dirname(absD), { recursive: true });
+  fs.copyFileSync(absS, absD);
+}
+
+function cpDir(src, dest) {
+  const absS = path.join(FORGE_ROOT, src);
+  const absD = path.join(BUNDLE, dest || src);
+  if (!fs.existsSync(absS)) return;
+  copyDirSync(absS, absD);
+}
+
+function copyDirSync(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    const s = path.join(src, entry.name);
+    const d = path.join(dest, entry.name);
+    if (entry.isDirectory()) copyDirSync(s, d);
+    else fs.copyFileSync(s, d);
+  }
+}
+
+// ── Crear directorio del bundle ────────────────────────────────────────────
+if (fs.existsSync(BUNDLE)) fs.rmSync(BUNDLE, { recursive: true });
+fs.mkdirSync(BUNDLE, { recursive: true });
+
+const incluidos = [];
+
+// ── SIEMPRE: componentes base del Interpreter ──────────────────────────────
+const base = [
+  ['sdd-lite/commands/sdd.md', 'sdd-lite/commands/sdd.md'],
+  ['sdd-lite/commands/sdd.interpretar.md', 'sdd-lite/commands/sdd.interpretar.md'],
+  ['sdd-lite/skills/descubrir-idea/SKILL.md', 'sdd-lite/skills/descubrir-idea/SKILL.md'],
+  ['sdd-lite/skills/interpretar-idea/SKILL.md', 'sdd-lite/skills/interpretar-idea/SKILL.md'],
+  ['sdd-lite/core/ir.types.ts', 'sdd-lite/core/ir.types.ts'],
+];
+for (const [s, d] of base) { cp(s, d); incluidos.push(d); }
+
+// .sdd/ir.json
+fs.mkdirSync(path.join(BUNDLE, '.sdd'), { recursive: true });
+fs.copyFileSync('.sdd/ir.json', path.join(BUNDLE, '.sdd', 'ir.json'));
+incluidos.push('.sdd/ir.json');
+
+// ── SI se usó diseño ───────────────────────────────────────────────────────
+const hasDesign = estado.product_design_generado && fs.existsSync('.sdd/product-design.json');
+if (hasDesign) {
+  const designFiles = [
+    ['sdd-lite/commands/sdd.diseñar.md', null],
+    ['sdd-lite/skills/elegir-direccion/SKILL.md', null],
+    ['sdd-lite/agents/product-designer.md', null],
+    ['sdd-lite/agents/architecture-designer.md', null],
+    ['sdd-lite/skills/wireframe-mvp/SKILL.md', null],
+    ['sdd-lite/skills/critica-diseno/SKILL.md', null],
+    ['{PLUGIN_DIR}/craft/anti-ai-slop.md', 'craft/anti-ai-slop.md'],
+  ];
+  for (const [s] of designFiles) { cp(s, s); incluidos.push(s); }
+
+  // Design system activo
+  const dir = estado.design_direction || 'neutral-modern';
+  // fuente en {PLUGIN_DIR}, destino relativo en el bundle (portable)
+  cpDir(\`{PLUGIN_DIR}/design-systems/\${dir}\`, \`design-systems/\${dir}\`);
+  incluidos.push(\`design-systems/\${dir}/DESIGN.md\`);
+
+  // Archivos .sdd de diseño
+  fs.copyFileSync('.sdd/product-design.json', path.join(BUNDLE, '.sdd', 'product-design.json'));
+  incluidos.push('.sdd/product-design.json');
+
+  if (fs.existsSync('.sdd/diseño')) {
+    copyDirSync('.sdd/diseño', path.join(BUNDLE, '.sdd', 'diseño'));
+    incluidos.push('.sdd/diseño/');
+  }
+}
+
+// ── SI se completó el pipeline ─────────────────────────────────────────────
+const pipelineDone = estado.pipeline_step === 'done' || !!estado.spec_activa;
+if (pipelineDone) {
+  const pipeFiles = [
+    ['sdd-lite/commands/sdd.construir.md', null],
+    ['sdd-lite/core/ir-to-spec-mapper.ts', null],
+    ['sdd-lite/core/project-memory.ts', null],
+  ];
+  for (const [s] of pipeFiles) { cp(s, s); incluidos.push(s); }
+
+  if (fs.existsSync('.sdd/spec-draft.json')) {
+    fs.copyFileSync('.sdd/spec-draft.json', path.join(BUNDLE, '.sdd', 'spec-draft.json'));
+    incluidos.push('.sdd/spec-draft.json');
+  }
+}
+
+// ── estado.json (sin API keys) ─────────────────────────────────────────────
+const estadoClean = { ...estado };
+delete estadoClean.api_key;
+delete estadoClean.api_key_encrypted;
+fs.writeFileSync(path.join(BUNDLE, '.sdd', 'estado.json'), JSON.stringify(estadoClean, null, 2));
+incluidos.push('.sdd/estado.json');
+
+// ── Generar INSTALL.md ─────────────────────────────────────────────────────
+const install = [
+  '# ' + ir.product.name + ' — Forge Bundle',
+  '',
+  'Generado el ' + timestamp + ' con FORGE.',
+  '',
+  '## Qué contiene este bundle',
+  '',
+  incluidos.map(f => '- \`' + f + '\`').join('\n'),
+  '',
+  '## Cómo usarlo',
+  '',
+  '### Con Claude Code',
+  '',
+  '1. Copia este bundle a tu proyecto',
+  '2. Abre el proyecto en Claude Code',
+  '3. Usa los comandos:',
+  '   - \`/sdd.diseñar\` → continuar con el diseño',
+  '   - \`/sdd.construir\` → generar el código',
+  '',
+  '### Ver el wireframe',
+  '',
+  hasDesign && fs.existsSync('.sdd/diseño/wireframe-pantalla-principal.html')
+    ? 'Abre \`.sdd/diseño/wireframe-pantalla-principal.html\` en cualquier navegador.'
+    : '(Sin wireframe en este bundle)',
+  '',
+  '---',
+  'Generado por FORGE — From idea to product, forged locally.',
+].join('\n');
+
+fs.writeFileSync(path.join(BUNDLE, 'INSTALL.md'), install);
+
+console.log('');
+console.log('✅ Bundle generado: ' + BUNDLE + '/');
+console.log('   Archivos incluidos: ' + incluidos.length);
+console.log('   (forge.config.json y .git excluidos por seguridad)');
+console.log('');
+"
+```
+
+---
+
+## PASO 4 — Generar INSTALL.md
+
+Crear `{bundle}/INSTALL.md` con instrucciones para el destinatario:
+
+```markdown
+# {product.name} — Forge Bundle
+
+Generado el {fecha} con FORGE v{version}.
+
+## Qué contiene este bundle
+
+- `sdd-lite/` — Comandos y agentes de FORGE para Claude Code
+- `.sdd/` — Contexto del proyecto (IR, diseño, wireframes)
+- `craft/` — Reglas de diseño
+- `design-systems/` — Sistema visual {direction}
+{si hay código: - `src/` — Código base generado}
+
+## Cómo usarlo
+
+### Opción A: En un proyecto nuevo con Claude Code
+
+1. Copia este bundle a la raíz de tu proyecto
+2. Abre el proyecto con Claude Code
+3. Usa los comandos disponibles:
+   - `/sdd.diseñar` — continuar el diseño
+   - `/sdd.construir` — generar el código
+   - `/sdd.estado` — ver el estado del proyecto
+
+### Opción B: Revisar el diseño
+
+El wireframe de la pantalla principal está en:
+`.sdd/diseño/wireframe-pantalla-principal.html`
+
+Ábrelo en cualquier navegador para ver el diseño visual.
+
+## Componentes incluidos
+
+{lista generada automáticamente de lo que está en el bundle}
+
+---
+Generado por FORGE — From idea to product, forged locally.
+```
+
+---
+
+## PASO 5 — Comprimir (si `--zip`)
+
+```bash
+if [ "$ZIP_MODE" = "true" ]; then
+  ZIP_NAME="${PRODUCT_NAME}-forge-bundle-${TIMESTAMP}.zip"
+  zip -r "$ZIP_NAME" "$BUNDLE_DIR"
+  rm -rf "$BUNDLE_DIR"
+  echo "✅ Bundle comprimido: $ZIP_NAME"
+else
+  echo "✅ Bundle en: $BUNDLE_DIR/"
+fi
+```
+
+---
+
+## Resumen final
+
+```
+═══════════════════════════════════════════
+📦 BUNDLE EXPORTADO
+═══════════════════════════════════════════
+
+Producto: [product.name]
+Bundle: [nombre]-forge-bundle/
+Tamaño estimado: [N] archivos, [X] KB
+
+Contenido:
+  ✅ IR y análisis (.sdd/ir.json)
+  ✅ Diseño de producto (.sdd/product-design.json)
+  ✅ Wireframe (.sdd/diseño/)
+  [✅ Spec y código si está completo]
+  ✅ Instrucciones (INSTALL.md)
+
+Componentes FORGE incluidos:
+  [lista de comandos/skills/agentes copiados]
+
+¿Qué sigue?
+  Comparte la carpeta [nombre]-forge-bundle/ con tu equipo
+  o abre el proyecto con Claude Code en otro equipo.
+```
+
+---
+
+## Notas de seguridad
+
+- El archivo `.sdd/forge.config.json` (con API keys) **nunca** se incluye en el bundle
+- Los archivos `.env` y credenciales se excluyen automáticamente
+- El bundle no contiene datos de la conversación, solo el output del pipeline