@cristiancorreau/forge 2.1.0

package/assets/adapters/codex/hooks/forge-codex-start.sh

@@ -0,0 +1,186 @@
+#!/usr/bin/env bash
+# Forge v2 — Codex onStart hook: forge-codex-start.sh
+#
+# Se ejecuta al inicio de cada sesión de Codex CLI.
+# Equivalente al hook session-start.sh de Claude Code (UserPromptSubmit).
+#
+# DIFERENCIAS vs Claude Code:
+#   - Claude Code: session-start.sh corre en UserPromptSubmit (automático en cada sesión).
+#   - Codex CLI: este script corre en onStart (automático también, pero el timing
+#     exacto depende de la versión de Codex).
+#   - Claude Code: puede bloquear (exit 2) para detener la sesión.
+#   - Codex CLI: onStart no puede bloquear la sesión — solo puede imprimir advertencias.
+#     Exit 2 aquí no impide que Codex continúe; es informacional.
+#
+# LIMITACIONES de Codex vs Claude Code:
+#   - No hay PreToolUse: no se puede interceptar comandos individuales antes de ejecutarlos.
+#   - No hay PostToolUse: no se puede inspeccionar el resultado de cada tool call.
+#   - Las reglas de seguridad (pre-bash-check, branch guard) son instruccionales en
+#     AGENTS.md, no mecánicas. El agente debe respetar las reglas voluntariamente.
+#
+# Instalación: este script debe copiarse o enlazarse en .codex/forge-codex-start.sh
+# El setup-codex.sh lo hace automáticamente.
+
+set -uo pipefail
+
+CHECKS_PASSED=0
+CHECKS_TOTAL=0
+OUTPUT=""
+
+check() {
+    local name="$1"
+    local result="$2"   # "ok" | "warn: <msg>" | "error: <msg>"
+    CHECKS_TOTAL=$((CHECKS_TOTAL + 1))
+    if [[ "$result" == "ok" ]]; then
+        CHECKS_PASSED=$((CHECKS_PASSED + 1))
+    elif [[ "$result" == error:* ]]; then
+        local msg="${result#error: }"
+        OUTPUT+="  error: ${msg}\n"
+    else
+        local msg="${result#warn: }"
+        OUTPUT+="  warn: ${msg}\n"
+    fi
+}
+
+# ---------------------------------------------------------------------------
+# Check 1 — Herramientas básicas disponibles
+# ---------------------------------------------------------------------------
+if ! command -v git &>/dev/null; then
+    check "git" "error: git no está instalado o no está en PATH"
+else
+    check "git" "ok"
+fi
+
+if ! command -v python3 &>/dev/null; then
+    check "python3" "error: python3 no está instalado o no está en PATH"
+else
+    check "python3" "ok"
+fi
+
+# ---------------------------------------------------------------------------
+# Check 2 — Branch actual no es main/master
+# ---------------------------------------------------------------------------
+CURRENT_BRANCH="$(git branch --show-current 2>/dev/null || true)"
+if [[ "$CURRENT_BRANCH" == "main" || "$CURRENT_BRANCH" == "master" ]]; then
+    check "branch" "warn: branch '${CURRENT_BRANCH}' — crea una feature branch antes de implementar: git checkout -b feature/<tema>-$(date +%Y-%m-%d)"
+else
+    check "branch" "ok"
+fi
+
+# ---------------------------------------------------------------------------
+# Check 3 — Cambios sin commitear
+# ---------------------------------------------------------------------------
+GIT_STATUS="$(git status --short 2>/dev/null || true)"
+if [[ -n "$GIT_STATUS" ]]; then
+    check "uncommitted" "warn: cambios sin commitear en el worktree"
+else
+    check "uncommitted" "ok"
+fi
+
+# ---------------------------------------------------------------------------
+# Check 4 — project.yaml existe
+# ---------------------------------------------------------------------------
+PROJECT_YAML=""
+SEARCH_PATH="$(pwd)"
+for _i in 1 2 3 4 5 6; do
+    if [[ -f "${SEARCH_PATH}/project.yaml" ]]; then
+        PROJECT_YAML="${SEARCH_PATH}/project.yaml"
+        break
+    fi
+    PARENT="$(dirname "$SEARCH_PATH")"
+    [[ "$PARENT" == "$SEARCH_PATH" ]] && break
+    SEARCH_PATH="$PARENT"
+done
+
+if [[ -z "$PROJECT_YAML" ]]; then
+    check "project.yaml" "warn: project.yaml no encontrado — ejecutar forge-wizard.py o scripts/setup-codex.sh"
+else
+    check "project.yaml" "ok"
+
+    # Check 5 — project.yaml tiene campos requeridos
+    YAML_VALID="$(python3 - "$PROJECT_YAML" <<'PYEOF'
+import sys, yaml
+path = sys.argv[1]
+try:
+    with open(path) as f:
+        data = yaml.safe_load(f)
+    if not isinstance(data, dict):
+        print("invalid")
+        sys.exit(0)
+    missing = []
+    project = data.get("project", {})
+    if not project.get("name"):
+        missing.append("project.name")
+    if not project.get("mode"):
+        missing.append("project.mode")
+    if missing:
+        print("missing:" + ",".join(missing))
+    else:
+        print("ok")
+except Exception as e:
+    print(f"error:{e}")
+PYEOF
+)"
+    if [[ "$YAML_VALID" == "ok" ]]; then
+        check "project.yaml.fields" "ok"
+    elif [[ "$YAML_VALID" == missing:* ]]; then
+        MISSING_FIELDS="${YAML_VALID#missing:}"
+        check "project.yaml.fields" "warn: project.yaml faltan campos: ${MISSING_FIELDS}"
+    else
+        check "project.yaml.fields" "warn: project.yaml no se pudo parsear — verificar sintaxis"
+    fi
+
+    # Check 6 — Variables de entorno de producción activas
+    HAS_DEPLOY="$(python3 - "$PROJECT_YAML" <<'PYEOF'
+import sys, yaml
+path = sys.argv[1]
+try:
+    with open(path) as f:
+        data = yaml.safe_load(f)
+    if isinstance(data, dict) and data.get("deploy"):
+        print("yes")
+    else:
+        print("no")
+except Exception:
+    print("no")
+PYEOF
+)"
+    if [[ "$HAS_DEPLOY" == "yes" ]]; then
+        PROD_VARS=""
+        while IFS='=' read -r key _value; do
+            if [[ "$key" =~ ^(PROD_|PRODUCTION_|PROD$|PRODUCTION$) ]]; then
+                PROD_VARS+="${key} "
+            fi
+        done < <(env)
+        if [[ -n "$PROD_VARS" ]]; then
+            check "prod-env" "warn: variables de producción activas en sesión: ${PROD_VARS// /, } — verificar que es intencional"
+        else
+            check "prod-env" "ok"
+        fi
+    else
+        check "prod-env" "ok"
+    fi
+fi
+
+# ---------------------------------------------------------------------------
+# Salida
+# ---------------------------------------------------------------------------
+WARNINGS=$((CHECKS_TOTAL - CHECKS_PASSED))
+
+if [[ $WARNINGS -eq 0 ]]; then
+    # Silencioso — todo OK
+    exit 0
+fi
+
+# Construir etiquetas para el resumen
+LABELS=""
+[[ "$CURRENT_BRANCH" == "main" || "$CURRENT_BRANCH" == "master" ]] && LABELS+="[branch ${CURRENT_BRANCH}] "
+[[ -n "$GIT_STATUS" ]] && LABELS+="[cambios sin commitear] "
+[[ -z "$PROJECT_YAML" ]] && LABELS+="[sin project.yaml] "
+
+printf "forge-codex session: %d advertencia(s) — %s\n" "$WARNINGS" "${LABELS%% }"
+printf "%b" "$OUTPUT"
+
+# Nota: en Codex CLI, onStart no puede bloquear la sesión.
+# Salimos con 0 siempre — las advertencias son informacionales.
+exit 0

package/assets/adapters/kiro/generate-steering.py

@@ -0,0 +1,367 @@
+#!/usr/bin/env python3
+# Copyright 2026 Cristian Correa — Apache License 2.0
+# https://github.com/cristiancorreau/forge
+"""
+generate-steering.py — Genera archivos .kiro/steering/ para Kiro IDE.
+
+Usage:
+  python3 .agentic/adapters/kiro/generate-steering.py
+
+Lee project.yaml en la raíz y genera los steering files de Kiro:
+  .kiro/steering/product.md    ← descripción del producto y stack
+  .kiro/steering/structure.md  ← estructura del proyecto, workflow SDD y flujo de sesión Forge v2
+  .kiro/steering/agents.md     ← roster de agentes y sus responsabilidades
+  .kiro/steering/commands.md   ← 6 comandos Forge para contexto del agente Kiro
+  .kiro/steering/compliance.md ← reglas de compliance (si hay frameworks activos)
+  .kiro/hooks/pre-edit-branch-guard.json ← hook que bloquea ediciones directas en main/master
+
+Kiro usa estos archivos como contexto persistente en todas las conversaciones.
+
+Requiere: pyyaml
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+try:
+    import yaml
+except ImportError:
+    print("ERROR: pyyaml requerido. pip install pyyaml", file=sys.stderr)
+    sys.exit(1)
+
+
+def find_project_root() -> Path:
+    here = Path.cwd()
+    for p in [here] + list(here.parents):
+        if (p / "project.yaml").exists():
+            return p
+    raise FileNotFoundError("No se encontró project.yaml")
+
+
+def find_forge_dir() -> Path:
+    root = find_project_root()
+    for candidate in [root / ".agentic", root / "forge", Path(__file__).parent.parent.parent]:
+        if (candidate / "core").exists():
+            return candidate
+    raise FileNotFoundError("No se encontró el directorio forge con core/")
+
+
+def write_file(path: Path, content: str, force: bool = False) -> str:
+    if path.exists() and not force:
+        return "KEEP"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content)
+    return "OK"
+
+
+def generate_product_md(config: dict) -> str:
+    proj = config.get("project", {})
+    stack = config.get("stack", {})
+    team = config.get("team", {})
+
+    return f"""# {proj.get('name', 'Mi Proyecto')}
+
+{proj.get('description', '')}
+
+## Stack
+
+- **Lenguaje:** {proj.get('language', 'typescript')}
+- **Backend:** {stack.get('backend') or 'N/A'}
+- **Frontend:** {stack.get('frontend') or 'N/A'}
+- **Base de datos:** {stack.get('database') or 'N/A'}
+- **Cache:** {stack.get('cache') or 'N/A'}
+- **Testing:** {', '.join(stack.get('testing', []))}
+
+## Estado del proyecto
+
+- **Status:** {proj.get('status', 'active')}
+- **Equipo:** {team.get('name', 'Equipo Principal')}
+"""
+
+
+def generate_structure_md(config: dict) -> str:
+    proj = config.get("project", {})
+    paths = config.get("paths", {})
+    specs_path = paths.get("specs", "docs/specs")
+    language = proj.get("language", "typescript")
+
+    cmd_map = {
+        "typescript": ("pnpm dev", "pnpm test", "pnpm lint"),
+        "python":     ("uvicorn main:app --reload  # o python manage.py runserver", "pytest", "ruff check ."),
+        "ruby":       ("rails server", "bundle exec rspec", "rubocop"),
+        "go":         ("go run ./cmd/...", "go test ./...", "golangci-lint run"),
+        "php":        ("php artisan serve", "vendor/bin/phpunit", "vendor/bin/phpstan analyse"),
+    }
+    dev_cmd, test_cmd, lint_cmd = cmd_map.get(language, ("# ver docs del proyecto",) * 3)
+
+    return f"""# Estructura del proyecto
+
+## Workflow: Spec-Driven Development (SDD)
+
+Antes de implementar cualquier feature:
+
+1. Verificar que existe una spec en `{specs_path}/`.
+2. Si no existe, crear la spec y obtener aprobación antes de codificar.
+3. Implementar con tests junto al código, no al final.
+4. Actualizar la spec con decisiones tomadas durante la implementación.
+
+## Flujo de sesión — Forge v2
+
+Cada sesión de trabajo sigue este orden:
+
+```
+session-start  → Leer AGENTS.md + specs relevantes. Confirmar rama activa.
+plan           → Descomponer la tarea. Identificar spec. Presentar opciones si hay decisiones abiertas.
+work           → Implementar con tests. Un agente por scope. Actualizar spec si hay desvíos.
+review         → Lint + tests verdes. Compliance review si toca PII o auth.
+ship           → PR abierto, CI verde. No mergear sin revisión si >5 archivos del mismo módulo.
+session-close  → Reportar cambios, decisiones tomadas y próximos pasos.
+```
+
+## Comandos frecuentes
+
+```bash
+{dev_cmd}     # Desarrollo
+{test_cmd}    # Tests
+{lint_cmd}    # Lint
+```
+
+## Reglas no-negociables
+
+- Sin hardcodear tokens, passwords ni secrets.
+- Parámetros preparados en todas las queries SQL — nunca concatenar input del usuario.
+- PII nunca en logs de stdout.
+- Auth + authz verificados en cada endpoint.
+- Sin force push a main/master.
+"""
+
+
+def generate_agents_md(config: dict) -> str:
+    agents_cfg = config.get("agents", {})
+    compliance_cfg = config.get("compliance", {})
+
+    active = agents_cfg.get("active", [])
+    compliance = agents_cfg.get("compliance", [])
+    specialized = agents_cfg.get("specialized", [])
+    frameworks = compliance_cfg.get("frameworks", [])
+
+    if frameworks and "compliance-reviewer" not in active + compliance:
+        compliance = list(set(compliance + ["compliance-reviewer"]))
+
+    role_descriptions = {
+        "orchestrator":        "Coordina al team. Descompone tareas, delega y sintetiza. No implementa código directamente.",
+        "backend-engineer":    "Backend — API, base de datos, lógica de negocio.",
+        "frontend-engineer":   "Frontend — UI, componentes, integración con API.",
+        "api-engineer":        "API — framework HTTP + ORM + lógica de negocio.",
+        "admin-engineer":      "Admin dashboard — UI de gestión interna.",
+        "mobile-engineer":     "Apps móviles.",
+        "fullstack-engineer":  "Features full-stack (backend + frontend).",
+        "test-engineer":       "Testing — unitario, integración, E2E.",
+        "docs-writer":         "Documentación — specs, ADRs, READMEs.",
+        "compliance-reviewer": "Revisa cambios contra marcos regulatorios activos. Tiene poder de veto.",
+        "security-auditor":    "Auditoría de seguridad — auth, authz, OWASP Top 10.",
+        "scanner-engineer":    "Scanner de cookies y trackers.",
+    }
+
+    lines = [
+        "# Roster de agentes",
+        "",
+        "## Reglas operativas",
+        "",
+        "- El orchestrator coordina; los demás agentes no se comunican directamente entre sí.",
+        "- Cada agente respeta su scope — no sale del directorio que le corresponde.",
+        "- Specs en `docs/specs/` antes de implementar. Sin spec, sin código.",
+        "",
+    ]
+
+    if active:
+        lines += ["## Agentes activos", ""]
+        for name in active:
+            desc = role_descriptions.get(name, "Agente de implementación")
+            lines.append(f"- **`{name}`** — {desc}")
+        lines.append("")
+
+    if compliance:
+        lines += ["## Agentes de revisión", ""]
+        for name in compliance:
+            desc = role_descriptions.get(name, "Agente revisor")
+            lines.append(f"- **`{name}`** — {desc}")
+        lines.append("")
+
+    if specialized:
+        lines += ["## Agentes especializados del proyecto", ""]
+        for name in specialized:
+            desc = role_descriptions.get(name, "Agente especializado del proyecto")
+            lines.append(f"- **`{name}`** — {desc}")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def generate_commands_md(config: dict) -> str:
+    paths = config.get("paths", {})
+    specs_path = paths.get("specs", "docs/specs")
+
+    return f"""# Forge commands — referencia para el agente
+
+Este proyecto usa Forge (framework de agentic development). Los siguientes comandos
+son los flujos de trabajo centrales que el agente debe seguir cuando el usuario los invoca.
+
+## new-feature
+
+Inicia la implementación de una nueva feature siguiendo SDD.
+
+1. Si no existe spec para la feature en `{specs_path}/`, crearla primero.
+2. Leer la spec antes de proponer cualquier implementación.
+3. Proponer el plan y esperar aprobación explícita.
+4. Implementar con tests junto a la implementación, no al final.
+5. Al terminar, actualizar la spec con las decisiones tomadas.
+
+## review
+
+Revisa el estado actual de la rama activa.
+
+1. Listar archivos modificados (`git diff --name-only main`).
+2. Ejecutar tests y lint. Reportar resultados.
+3. Verificar que los cambios corresponden a una spec aprobada.
+4. Identificar items pendientes antes de poder hacer merge.
+
+## deploy-check
+
+Verifica que el deploy de producción está sano después de un merge.
+
+1. Confirmar que el build de CI pasó.
+2. Revisar runtime logs (errores 5xx, excepciones no manejadas).
+3. Smoke test de los endpoints principales.
+4. Reportar estado: OK | DEGRADED | DOWN.
+
+## wiki-ingest
+
+Indexa documentación externa para que el agente pueda consultarla.
+
+1. Recibir URL o path a la documentación.
+2. Parsear y fragmentar el contenido.
+3. Almacenar en el directorio de wiki del proyecto.
+4. Confirmar qué secciones quedaron disponibles.
+
+## wiki-query
+
+Consulta la wiki indexada para responder preguntas técnicas.
+
+1. Buscar en los fragmentos indexados con la consulta del usuario.
+2. Sintetizar la respuesta citando las fuentes.
+3. Si no hay resultado en la wiki, indicarlo explícitamente — no inventar.
+
+## wiki-lint
+
+Verifica la calidad y consistencia de la wiki indexada.
+
+1. Detectar fragmentos desactualizados (referencias a versiones antiguas).
+2. Identificar contradicciones entre documentos.
+3. Reportar items que requieren revisión manual.
+"""
+
+
+def generate_branch_guard_hook() -> str:
+    """Genera el hook JSON de Kiro que advierte al editar en main/master."""
+    import json
+    hook = {
+        "name": "branch-guard",
+        "description": "Warns when editing files directly on main or master branch.",
+        "event": "onBeforeEdit",
+        "condition": {
+            "type": "gitBranch",
+            "branches": ["main", "master"]
+        },
+        "action": {
+            "type": "agentPrompt",
+            "prompt": (
+                "STOP: You are about to edit files on the '{{branch}}' branch. "
+                "Direct commits to main/master are not allowed in this project. "
+                "Create a feature branch first: `git checkout -b feat/<name>`. "
+                "Do not proceed with the edit until the user confirms or switches branch."
+            )
+        }
+    }
+    return json.dumps(hook, indent=2, ensure_ascii=False)
+
+
+def generate_compliance_md(config: dict) -> str | None:
+    compliance_cfg = config.get("compliance", {})
+    frameworks = compliance_cfg.get("frameworks", [])
+    if not frameworks:
+        return None
+
+    return f"""# Compliance activo
+
+Este proyecto opera bajo los siguientes marcos regulatorios:
+{chr(10).join(f'- **{f.upper()}**' for f in frameworks)}
+
+## Reglas no-negociables
+
+- Sin datos personales en logs de stdout.
+- Consentimiento explícito antes de cualquier tracker no esencial.
+- Logs de auditoría append-only (sin UPDATE/DELETE sobre tablas de eventos).
+- Derechos del titular implementados: acceso, rectificación, supresión, oposición, portabilidad.
+- TLS 1.2+ para toda comunicación externa.
+
+## Cuándo involucrar al compliance-reviewer
+
+- Cualquier cambio que toque datos de usuarios o consentimientos.
+- Nuevos endpoints que reciban PII.
+- Cambios en la lógica de logs de auditoría.
+- Implementación de derechos del titular (DSAR).
+
+> Nota: el agente compliance-reviewer opera como primer filtro técnico.
+> No sustituye revisión legal profesional para proyectos con obligaciones regulatorias reales.
+"""
+
+
+def main():
+    force = "--force" in sys.argv
+
+    try:
+        root = find_project_root()
+        forge = find_forge_dir()
+    except FileNotFoundError as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    with open(root / "project.yaml") as f:
+        config = yaml.safe_load(f)
+
+    steering_dir = root / ".kiro" / "steering"
+    steering_dir.mkdir(parents=True, exist_ok=True)
+
+    files = {
+        "product.md":    generate_product_md(config),
+        "structure.md":  generate_structure_md(config),
+        "agents.md":     generate_agents_md(config),
+        "commands.md":   generate_commands_md(config),
+    }
+
+    compliance_content = generate_compliance_md(config)
+    if compliance_content:
+        files["compliance.md"] = compliance_content
+
+    for filename, content in files.items():
+        path = steering_dir / filename
+        status = write_file(path, content, force=force)
+        icon = "[OK]  " if status == "OK" else "[KEEP]"
+        print(f"  {icon} .kiro/steering/{filename}" + (" — ya existe (--force para sobreescribir)" if status == "KEEP" else ""))
+
+    # Hooks
+    hooks_dir = root / ".kiro" / "hooks"
+    hook_path = hooks_dir / "pre-edit-branch-guard.json"
+    hook_status = write_file(hook_path, generate_branch_guard_hook(), force=force)
+    hook_icon = "[OK]  " if hook_status == "OK" else "[KEEP]"
+    print(f"  {hook_icon} .kiro/hooks/pre-edit-branch-guard.json" + (" — ya existe (--force para sobreescribir)" if hook_status == "KEEP" else ""))
+
+    print(f"\nKiro steering files en {steering_dir.relative_to(root)}/")
+    if not force:
+        print("  Usar --force para sobreescribir archivos existentes.")
+
+
+if __name__ == "__main__":
+    main()

package/assets/adapters/opencode/HOOKS.md

@@ -0,0 +1,123 @@
+# Forge Hooks — Adaptación para OpenCode
+
+OpenCode no tiene un sistema de hooks equivalente al PreToolUse/Stop de Claude Code. Este documento describe cómo adaptar cada comportamiento de hook de Forge para OpenCode.
+
+---
+
+## 1. Equivalencia de hooks
+
+| Hook Forge (Claude Code) | Equivalente en OpenCode | Mecanismo |
+|--------------------------|------------------------|-----------|
+| `PreToolUse:Edit` — branch guard (bloquear edición en main) | **Ninguno nativo** | Instrucción en AGENTS.md |
+| `PreToolUse:Bash` — detección de console.log/print de debug | **Ninguno nativo** | Instrucción en AGENTS.md |
+| `PreToolUse:Bash` — bloqueo de comandos destructivos en producción | **Ninguno nativo** | Instrucción en AGENTS.md |
+| `Stop` — resumen de sesión y persistencia de memoria | **Ninguno nativo** | Flujo `/session-close` |
+| `pre-commit` git hook — inyección de token stats en progress.html | **Compatible** | El hook git funciona igual en OpenCode |
+
+**Conclusión:** OpenCode no tiene PreToolUse ni Stop hooks. Todos los guardrails deben embeberse como instrucciones en AGENTS.md.
+
+---
+
+## 2. Guardrails que deben embeberse en AGENTS.md
+
+### Branch guard (equivale a PreToolUse:Edit)
+
+```markdown
+## Guardrail: Branch guard
+
+NUNCA editar código cuando la rama actual sea `main`, `master` o `develop`.
+
+Antes de cualquier edición de archivo:
+1. Verificar la rama actual con `git branch --show-current`
+2. Si la rama es `main`, `master` o `develop`: detener y pedir al usuario que cree una rama de feature antes de continuar.
+
+Excepción: archivos de documentación (*.md) pueden editarse en main si el usuario lo indica explícitamente.
+```
+
+### Debug detection (equivale a PreToolUse:Bash con grep de debug patterns)
+
+```markdown
+## Guardrail: Detección de debug
+
+Antes de hacer commit de cualquier archivo, verificar que no contenga:
+- `console.log(` en JavaScript/TypeScript (excepción: archivos de logger o utilidades de logging)
+- `print(` en Python que no sea logging de producción
+- `debugger;` en JavaScript/TypeScript
+- `binding.pry` en Ruby
+- `dd(` o `dump(` en PHP
+
+Si se detectan estos patrones en código que va a commitearse: reportar la línea exacta y pedir confirmación antes de continuar.
+```
+
+### Producción safety (equivale a PreToolUse:Bash con comandos destructivos)
+
+```markdown
+## Guardrail: Producción safety
+
+Nunca ejecutar estos comandos sin confirmación explícita del usuario:
+- `DROP TABLE`, `DROP DATABASE`, `TRUNCATE` en cualquier base de datos de producción
+- `rm -rf` en directorios que no sean temporales o de build
+- `git push --force` a main/master (usar `--force-with-lease` en feature branches si es estrictamente necesario)
+- Deploy directo a producción sin haber ejecutado `/review` primero
+
+Para cualquier comando potencialmente destructivo: describir el efecto exacto y pedir confirmación explícita antes de ejecutar.
+```
+
+### SQL injection prevention
+
+```markdown
+## Guardrail: SQL injection
+
+Nunca concatenar input del usuario directamente en strings SQL.
+Siempre usar parámetros preparados o el ORM del proyecto.
+
+Ejemplo prohibido: `f"SELECT * FROM users WHERE email = '{email}'"`
+Ejemplo correcto: `cursor.execute("SELECT * FROM users WHERE email = %s", (email,))`
+```
+
+---
+
+## 3. Configuración de proyecto OpenCode
+
+OpenCode utiliza un archivo `.opencode/config.json` para configuración a nivel de proyecto. Ejemplo recomendado para proyectos Forge:
+
+```json
+{
+  "model": "claude-sonnet-4-5",
+  "context": {
+    "files": [
+      "AGENTS.md",
+      "project.yaml"
+    ]
+  }
+}
+```
+
+**Notas:**
+- `context.files`: archivos que OpenCode incluye automáticamente como contexto en cada sesión. Incluir siempre `AGENTS.md` y `project.yaml`.
+- `model`: el modelo a usar. Recomendado `claude-sonnet-4-5` o superior para proyectos con `project.mode: standard` o `enterprise`.
+
+---
+
+## 4. Flujo recomendado sin hooks
+
+Dado que OpenCode no tiene hooks automáticos, el cumplimiento de los guardrails depende de:
+
+1. **AGENTS.md bien escrito**: incluir las secciones de guardrails del punto 2 en el AGENTS.md generado por `generate-agents-md.py`.
+2. **Disciplina de sesión**: usar `/session-start` al comenzar y `/session-close` al terminar para mantener el estado documentado.
+3. **Pre-commit git hook**: el hook de git en `hooks/pre-commit` funciona igual en OpenCode — instalarlo en el proyecto cliente con `git config core.hooksPath .githooks`.
+
+---
+
+## 5. Referencia cruzada con comandos Forge v2
+
+Los comandos SDD disponibles en OpenCode (en `.opencode/commands/`) son:
+
+| Comando | Descripción |
+|---------|-------------|
+| `/session-start` | Inicializa sesión, detecta branch y estado del repo |
+| `/plan` | Crea o revisa specs en docs/specs/ |
+| `/work` | Implementa una spec en modo serial |
+| `/review` | Revisión de código con veredicto vinculante |
+| `/ship` | Pipeline de deploy con polling y smoke tests |
+| `/session-close` | Cierra sesión con commit, daily note y PR |