claude-code-arcane 1.0.0

package/skills/atlassian-templates/scripts/template_scaffolder.py

@@ -0,0 +1,418 @@
+#!/usr/bin/env python3
+"""
+Template Scaffolder
+
+Generates Confluence page template markup in storage-format XHTML. Supports
+built-in template types and custom section definitions with optional macros.
+
+Usage:
+    python template_scaffolder.py meeting-notes
+    python template_scaffolder.py decision-log --format json
+    python template_scaffolder.py custom --sections "Overview,Goals,Action Items" --macros toc,status
+    python template_scaffolder.py --list
+"""
+
+import argparse
+import json
+import sys
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+
+# ---------------------------------------------------------------------------
+# Macro Generators
+# ---------------------------------------------------------------------------
+
+def macro_toc() -> str:
+    """Generate table of contents macro."""
+    return '<ac:structured-macro ac:name="toc"><ac:parameter ac:name="printable">true</ac:parameter><ac:parameter ac:name="style">disc</ac:parameter><ac:parameter ac:name="maxLevel">3</ac:parameter></ac:structured-macro>'
+
+
+def macro_status(text: str = "IN PROGRESS", color: str = "Yellow") -> str:
+    """Generate status macro."""
+    return f'<ac:structured-macro ac:name="status"><ac:parameter ac:name="colour">{color}</ac:parameter><ac:parameter ac:name="title">{text}</ac:parameter></ac:structured-macro>'
+
+
+def macro_info_panel(content: str) -> str:
+    """Generate info panel macro."""
+    return f'<ac:structured-macro ac:name="info"><ac:rich-text-body><p>{content}</p></ac:rich-text-body></ac:structured-macro>'
+
+
+def macro_warning_panel(content: str) -> str:
+    """Generate warning panel macro."""
+    return f'<ac:structured-macro ac:name="warning"><ac:rich-text-body><p>{content}</p></ac:rich-text-body></ac:structured-macro>'
+
+
+def macro_note_panel(content: str) -> str:
+    """Generate note panel macro."""
+    return f'<ac:structured-macro ac:name="note"><ac:rich-text-body><p>{content}</p></ac:rich-text-body></ac:structured-macro>'
+
+
+def macro_expand(title: str, content: str) -> str:
+    """Generate expand/collapse macro."""
+    return f'<ac:structured-macro ac:name="expand"><ac:parameter ac:name="title">{title}</ac:parameter><ac:rich-text-body>{content}</ac:rich-text-body></ac:structured-macro>'
+
+
+def macro_jira_issues(jql: str) -> str:
+    """Generate Jira issues macro."""
+    return f'<ac:structured-macro ac:name="jira"><ac:parameter ac:name="jqlQuery">{jql}</ac:parameter><ac:parameter ac:name="columns">key,summary,type,created,updated,due,assignee,reporter,priority,status,resolution</ac:parameter></ac:structured-macro>'
+
+
+MACRO_MAP = {
+    "toc": macro_toc,
+    "status": macro_status,
+    "info": macro_info_panel,
+    "warning": macro_warning_panel,
+    "note": macro_note_panel,
+    "expand": macro_expand,
+    "jira-issues": macro_jira_issues,
+}
+
+
+# ---------------------------------------------------------------------------
+# Built-in Templates
+# ---------------------------------------------------------------------------
+
+def _section(title: str, content: str) -> str:
+    """Generate a section with heading and content."""
+    return f'<h2>{title}</h2>\n{content}\n'
+
+
+def _table(headers: List[str], rows: List[List[str]]) -> str:
+    """Generate an XHTML table."""
+    parts = ['<table><colgroup>']
+    for _ in headers:
+        parts.append('<col />')
+    parts.append('</colgroup><thead><tr>')
+    for h in headers:
+        parts.append(f'<th><p>{h}</p></th>')
+    parts.append('</tr></thead><tbody>')
+    for row in rows:
+        parts.append('<tr>')
+        for cell in row:
+            parts.append(f'<td><p>{cell}</p></td>')
+        parts.append('</tr>')
+    parts.append('</tbody></table>')
+    return ''.join(parts)
+
+
+def template_meeting_notes() -> Dict[str, Any]:
+    """Generate meeting notes template."""
+    today = datetime.now().strftime("%Y-%m-%d")
+    body = macro_toc() + '\n'
+    body += macro_info_panel("Replace placeholder text with your meeting details.") + '\n'
+    body += _section("Meeting Details", _table(
+        ["Field", "Value"],
+        [["Date", today], ["Time", ""], ["Location", ""], ["Facilitator", ""], ["Note Taker", ""]],
+    ))
+    body += _section("Attendees", '<ul><li><p>Name 1</p></li><li><p>Name 2</p></li></ul>')
+    body += _section("Agenda", '<ol><li><p>Item 1</p></li><li><p>Item 2</p></li><li><p>Item 3</p></li></ol>')
+    body += _section("Discussion Notes", '<p>Summary of discussion points...</p>')
+    body += _section("Decisions Made", _table(
+        ["Decision", "Owner", "Date"],
+        [["", "", today]],
+    ))
+    body += _section("Action Items", _table(
+        ["Action", "Owner", "Due Date", "Status"],
+        [["", "", "", macro_status("TODO", "Grey")]],
+    ))
+    body += _section("Next Meeting", '<p>Date: TBD</p><p>Agenda items for next time:</p><ul><li><p></p></li></ul>')
+
+    return {"name": "Meeting Notes", "body": body, "labels": ["meeting-notes", "template"]}
+
+
+def template_decision_log() -> Dict[str, Any]:
+    """Generate decision log template."""
+    today = datetime.now().strftime("%Y-%m-%d")
+    body = macro_toc() + '\n'
+    body += _section("Decision Log", macro_info_panel("Track key decisions, context, and outcomes."))
+    body += _table(
+        ["ID", "Date", "Decision", "Context", "Alternatives Considered", "Outcome", "Owner", "Status"],
+        [
+            ["D-001", today, "", "", "", "", "", macro_status("DECIDED", "Green")],
+            ["D-002", "", "", "", "", "", "", macro_status("PENDING", "Yellow")],
+        ],
+    )
+    body += '\n'
+    body += _section("Decision Template", macro_expand("Decision Details Template",
+        '<h3>Context</h3><p>What is the issue or situation requiring a decision?</p>'
+        '<h3>Options</h3><ol><li><p>Option A - pros/cons</p></li><li><p>Option B - pros/cons</p></li></ol>'
+        '<h3>Decision</h3><p>What was decided and why?</p>'
+        '<h3>Consequences</h3><p>What are the expected outcomes?</p>'
+    ))
+
+    return {"name": "Decision Log", "body": body, "labels": ["decision-log", "template"]}
+
+
+def template_runbook() -> Dict[str, Any]:
+    """Generate runbook template."""
+    body = macro_toc() + '\n'
+    body += macro_warning_panel("This runbook should be tested and reviewed quarterly.") + '\n'
+    body += _section("Overview", '<p>Brief description of what this runbook covers.</p>'
+        + _table(["Field", "Value"], [
+            ["Service/System", ""], ["Owner", ""], ["Last Tested", ""],
+            ["Severity", ""], ["Estimated Duration", ""],
+        ]))
+    body += _section("Prerequisites", '<ul><li><p>Access to system X</p></li><li><p>VPN connected</p></li><li><p>Required tools installed</p></li></ul>')
+    body += _section("Steps", '<ol><li><p><strong>Step 1:</strong> Description</p><ac:structured-macro ac:name="code"><ac:parameter ac:name="language">bash</ac:parameter><ac:plain-text-body><![CDATA[# command here]]></ac:plain-text-body></ac:structured-macro></li>'
+        '<li><p><strong>Step 2:</strong> Description</p></li>'
+        '<li><p><strong>Step 3:</strong> Description</p></li></ol>')
+    body += _section("Verification", '<p>How to verify the issue is resolved:</p><ul><li><p>Check 1</p></li><li><p>Check 2</p></li></ul>')
+    body += _section("Rollback", macro_note_panel("If the above steps do not resolve the issue, follow these rollback steps.") +
+        '<ol><li><p>Rollback step 1</p></li><li><p>Rollback step 2</p></li></ol>')
+    body += _section("Escalation", _table(
+        ["Level", "Contact", "When to Escalate"],
+        [["L1", "", ""], ["L2", "", ""], ["L3", "", ""]],
+    ))
+
+    return {"name": "Runbook", "body": body, "labels": ["runbook", "operations", "template"]}
+
+
+def template_project_kickoff() -> Dict[str, Any]:
+    """Generate project kickoff template."""
+    today = datetime.now().strftime("%Y-%m-%d")
+    body = macro_toc() + '\n'
+    body += _section("Project Overview", _table(
+        ["Field", "Value"],
+        [["Project Name", ""], ["Start Date", today], ["Target End Date", ""],
+         ["Project Lead", ""], ["Sponsor", ""], ["Status", macro_status("KICKOFF", "Blue")]],
+    ))
+    body += _section("Vision & Goals", '<h3>Vision</h3><p>What does success look like?</p>'
+        '<h3>Goals</h3><ol><li><p>Goal 1</p></li><li><p>Goal 2</p></li><li><p>Goal 3</p></li></ol>')
+    body += _section("Scope", '<h3>In Scope</h3><ul><li><p></p></li></ul><h3>Out of Scope</h3><ul><li><p></p></li></ul>')
+    body += _section("Stakeholders", _table(
+        ["Name", "Role", "Responsibility", "Communication Preference"],
+        [["", "", "", ""]],
+    ))
+    body += _section("Timeline & Milestones", _table(
+        ["Milestone", "Target Date", "Status"],
+        [["Phase 1", "", macro_status("NOT STARTED", "Grey")],
+         ["Phase 2", "", macro_status("NOT STARTED", "Grey")]],
+    ))
+    body += _section("Risks", _table(
+        ["Risk", "Likelihood", "Impact", "Mitigation"],
+        [["", "High/Medium/Low", "High/Medium/Low", ""]],
+    ))
+    body += _section("Next Steps", '<ul><li><p></p></li></ul>')
+
+    return {"name": "Project Kickoff", "body": body, "labels": ["project-kickoff", "template"]}
+
+
+def template_sprint_retro() -> Dict[str, Any]:
+    """Generate sprint retrospective template."""
+    body = macro_toc() + '\n'
+    body += _section("Sprint Info", _table(
+        ["Field", "Value"],
+        [["Sprint", ""], ["Date Range", ""], ["Facilitator", ""],
+         ["Velocity", ""], ["Commitment", ""], ["Completion Rate", ""]],
+    ))
+    body += _section("What Went Well", '<ul><li><p></p></li></ul>')
+    body += _section("What Could Be Improved", '<ul><li><p></p></li></ul>')
+    body += _section("Action Items from Last Retro", _table(
+        ["Action", "Owner", "Status"],
+        [["", "", macro_status("DONE", "Green")], ["", "", macro_status("IN PROGRESS", "Yellow")]],
+    ))
+    body += _section("New Action Items", _table(
+        ["Action", "Owner", "Due Date", "Priority"],
+        [["", "", "", "High/Medium/Low"]],
+    ))
+    body += _section("Team Health Check", macro_info_panel("Rate each area 1-5 (1=needs work, 5=great)") + _table(
+        ["Area", "Rating", "Trend", "Notes"],
+        [["Teamwork", "", "", ""], ["Delivery", "", "", ""],
+         ["Fun", "", "", ""], ["Learning", "", "", ""]],
+    ))
+
+    return {"name": "Sprint Retrospective", "body": body, "labels": ["sprint-retro", "agile", "template"]}
+
+
+def template_how_to_guide() -> Dict[str, Any]:
+    """Generate how-to guide template."""
+    body = macro_toc() + '\n'
+    body += macro_info_panel("This guide explains how to accomplish a specific task.") + '\n'
+    body += _section("Overview", '<p>Brief description of what this guide covers and who it is for.</p>')
+    body += _section("Prerequisites", '<ul><li><p>Prerequisite 1</p></li><li><p>Prerequisite 2</p></li></ul>')
+    body += _section("Step-by-Step Instructions",
+        '<h3>Step 1: Title</h3><p>Description of what to do.</p>'
+        '<h3>Step 2: Title</h3><p>Description of what to do.</p>'
+        '<h3>Step 3: Title</h3><p>Description of what to do.</p>')
+    body += _section("Troubleshooting", macro_expand("Common Issues",
+        '<h3>Issue 1</h3><p>Solution...</p>'
+        '<h3>Issue 2</h3><p>Solution...</p>'))
+    body += _section("Related Resources", '<ul><li><p>Link 1</p></li><li><p>Link 2</p></li></ul>')
+
+    return {"name": "How-To Guide", "body": body, "labels": ["how-to", "guide", "template"]}
+
+
+TEMPLATE_REGISTRY = {
+    "meeting-notes": template_meeting_notes,
+    "decision-log": template_decision_log,
+    "runbook": template_runbook,
+    "project-kickoff": template_project_kickoff,
+    "sprint-retro": template_sprint_retro,
+    "how-to-guide": template_how_to_guide,
+}
+
+
+# ---------------------------------------------------------------------------
+# Custom Template Builder
+# ---------------------------------------------------------------------------
+
+def build_custom_template(
+    sections: List[str],
+    macros: List[str],
+) -> Dict[str, Any]:
+    """Build a custom template from sections and macros."""
+    body = ""
+
+    # Add requested macros at the top
+    if "toc" in macros:
+        body += macro_toc() + '\n'
+    if "status" in macros:
+        body += '<p>Status: ' + macro_status() + '</p>\n'
+
+    for section in sections:
+        section = section.strip()
+        if not section:
+            continue
+        body += _section(section, '<p></p>')
+
+    # Add panels if requested
+    if "info" in macros:
+        body = macro_info_panel("Add instructions or context here.") + '\n' + body
+    if "warning" in macros:
+        body += macro_warning_panel("Add warnings here.") + '\n'
+    if "note" in macros:
+        body += macro_note_panel("Add notes here.") + '\n'
+
+    return {"name": "Custom Template", "body": body, "labels": ["custom", "template"]}
+
+
+# ---------------------------------------------------------------------------
+# Output Formatting
+# ---------------------------------------------------------------------------
+
+def format_text_output(result: Dict[str, Any]) -> str:
+    """Format results as readable text report."""
+    lines = []
+    lines.append("=" * 60)
+    lines.append(f"TEMPLATE: {result['name']}")
+    lines.append("=" * 60)
+    lines.append("")
+    lines.append(f"Labels: {', '.join(result.get('labels', []))}")
+    lines.append("")
+    lines.append("CONFLUENCE STORAGE FORMAT MARKUP")
+    lines.append("-" * 30)
+    lines.append(result["body"])
+
+    return "\n".join(lines)
+
+
+def format_json_output(result: Dict[str, Any]) -> Dict[str, Any]:
+    """Format results as JSON."""
+    return result
+
+
+def format_list_output(output_format: str) -> str:
+    """Format available templates list."""
+    if output_format == "json":
+        templates = {}
+        for name, func in TEMPLATE_REGISTRY.items():
+            result = func()
+            templates[name] = {
+                "name": result["name"],
+                "labels": result["labels"],
+            }
+        return json.dumps(templates, indent=2)
+
+    lines = []
+    lines.append("=" * 60)
+    lines.append("AVAILABLE TEMPLATES")
+    lines.append("=" * 60)
+    lines.append("")
+    for name, func in TEMPLATE_REGISTRY.items():
+        result = func()
+        lines.append(f"  {name}")
+        lines.append(f"    Name: {result['name']}")
+        lines.append(f"    Labels: {', '.join(result['labels'])}")
+        lines.append("")
+    lines.append(f"Total templates: {len(TEMPLATE_REGISTRY)}")
+    lines.append("")
+    lines.append("Usage:")
+    lines.append("  python template_scaffolder.py <template-name>")
+    lines.append('  python template_scaffolder.py custom --sections "Section1,Section2" --macros toc,status')
+    return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# CLI Interface
+# ---------------------------------------------------------------------------
+
+def main() -> int:
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="Generate Confluence page template markup"
+    )
+    parser.add_argument(
+        "template",
+        nargs="?",
+        help="Template name or 'custom' for custom template",
+    )
+    parser.add_argument(
+        "--format",
+        choices=["text", "json"],
+        default="text",
+        help="Output format (default: text)",
+    )
+    parser.add_argument(
+        "--list",
+        action="store_true",
+        help="List all available template types",
+    )
+    parser.add_argument(
+        "--sections",
+        help='Comma-separated section names for custom template (e.g., "Overview,Goals,Action Items")',
+    )
+    parser.add_argument(
+        "--macros",
+        help='Comma-separated macro names to include (e.g., "toc,status,info")',
+    )
+
+    args = parser.parse_args()
+
+    try:
+        if args.list:
+            print(format_list_output(args.format))
+            return 0
+
+        if not args.template:
+            parser.error("template name is required unless --list is used")
+
+        template_name = args.template.lower()
+
+        if template_name == "custom":
+            if not args.sections:
+                parser.error("--sections is required for custom templates")
+            sections = [s.strip() for s in args.sections.split(",")]
+            macros = [m.strip() for m in args.macros.split(",")] if args.macros else []
+            result = build_custom_template(sections, macros)
+        elif template_name in TEMPLATE_REGISTRY:
+            result = TEMPLATE_REGISTRY[template_name]()
+        else:
+            available = ", ".join(sorted(TEMPLATE_REGISTRY.keys()))
+            print(f"Error: Unknown template '{template_name}'. Available: {available}", file=sys.stderr)
+            return 1
+
+        if args.format == "json":
+            print(json.dumps(format_json_output(result), indent=2))
+        else:
+            print(format_text_output(result))
+
+        return 0
+
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/skills/audit-dev/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: audit-dev
+description: "Auditoría integral de software: arquitectura, código, tests, seguridad, docs y deuda técnica."
+category: "workflow"
+argument-hint: "[full|architecture|security|quality|api|deps]"
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Bash, Task
+---
+# Software Development Audit
+
+## Input
+
+Arg: `full` (default), `architecture`, `security`, `quality`, `api`, `deps`, o path específico.
+
+## Phase 1 — Detectar stack y estructura
+
+Identificar lenguajes/frameworks/package manager. Leer configs raíz. Mapear carpetas. Identificar CI/CD. Leer README/docs.
+
+## Phase 2 — Análisis por dimensión (agents en paralelo)
+
+| Dimensión | Severidad | Qué buscar |
+|-----------|-----------|------------|
+| Arquitectura | CRITICAL | Convenciones del stack, separación responsabilidades, circular deps, entry point claro, patrones consistentes, config hardcoded, error handling |
+| Calidad código | HIGH | Código muerto, duplicación, funciones >50 líneas, complejidad ciclomática, naming inconsistente, TODOs abandonados, magic numbers, errores ignorados |
+| Testing | HIGH | Existencia y cobertura, unit/integration/e2e balance, tests útiles (comportamiento no implementación), flaky/estado global, fixtures, facilidad de ejecución |
+| Seguridad | CRITICAL | Secrets en código, input validation, SQL injection, XSS, auth/authz, CORS, deps vulnerables, rate limiting |
+| API/Contratos | MEDIUM | Documentación (OpenAPI), naming consistente, error responses estándar, versionado, validation, paginación |
+| Dependencias/Infra | MEDIUM | Deps desactualizadas/no usadas, lock file, Docker (base images, multi-stage), CI pipeline (tests, lint, security) |
+| Documentación | LOW | README útil, API docs, ADRs, onboarding posible |
+
+## Phase 3 — Producir reporte
+
+Guardar como `AUDIT.md` en raíz. Secciones: fecha/stack/estado general, resumen ejecutivo (3-5 oraciones), scorecard (tabla dimensión/estado OK-WARN-CRIT/nota), hallazgos críticos, hallazgos importantes, observaciones, lo que está bien, plan de acción recomendado, detalles por dimensión con evidencia (paths, líneas).
+
+## Rules
+
+- Español siempre. Citar file paths y líneas
+- Solución concreta por problema
+- Agents en paralelo por dimensión
+- NO over-engineering (100% coverage, DI frameworks)
+- Calibrar al tamaño/etapa del proyecto
+- Priorizar por impacto real, no purismo
+- Reconocer lo bien hecho

package/skills/audit-game/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: audit-game
+description: "Full game project audit: compare GDD, spec docs and code. Detect contradictions, design gaps, balance issues and coherence problems."
+category: "gamedev"
+argument-hint: "[full|gdd|spec-docs|gdd-vs-code|balance|path]"
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Bash, Task
+---
+# Game Document Audit
+
+Auditoría integral de documentación y código para proyectos de desarrollo de videojuegos.
+
+## Input
+
+El usuario especifica qué auditar. Argumento opcional: `$ARGUMENTS` (e.g., "GDD", "spec-docs", "GDD vs code", "balance", o un path específico)
+
+## Phase 1 — Detectar proyecto y documentos
+
+1. Identificar el tipo de proyecto (Unity, Unreal, etc.) por la estructura de archivos
+2. Buscar documentos de diseño:
+   - GDD (Game Design Document) — buscar en raíz, `docs/`, `Documents/`, `Assets/Documents/`
+   - Spec docs — buscar en `spec-docs/`, `specs/`, `design/`
+   - Auditorías previas — buscar `*AUDIT*`, `*audit*`
+3. Buscar código de gameplay en las carpetas del engine correspondiente
+4. Si no encuentra documentos → preguntar al usuario dónde están
+
+## Phase 2 — Gather Context
+
+1. Leer el/los documento(s) target completamente
+2. Leer documentos relacionados (specs, GDD, README del proyecto)
+3. Leer auditorías previas si existen (para no repetir hallazgos ya resueltos)
+4. Si se audita contra código: usar agents para explorar la implementación actual
+
+## Phase 3 — Cross-Reference Analysis
+
+Analizar 5 dimensiones: A) Contradicciones (CRITICAL), B) Gaps (HIGH), C) Coherencia (MEDIUM), D) Balance Red Flags (MEDIUM), E) Completitud milestone (HIGH).
+
+> → Read references/cross-reference-criteria.md for detailed criteria per dimension, severity classification, and output format
+
+## Phase 4 — Producir reporte
+
+Guardar la auditoría en la ubicación apropiada del proyecto (junto al GDD o en `docs/`). Secciones: Resumen Ejecutivo, Contradicciones, Gaps, Coherencia, Balance, Decisiones Pendientes, Lo Que Está Bien, Próximos Pasos. Cada hallazgo en formato PAS condensado (5 líneas max).
+
+> → Read references/output-template.md for full report template and finding format
+
+## Rules
+- Siempre en español
+- CONCISO — cada hallazgo cabe en 5 líneas máximo
+- Ser específico: citar nombres de sección, valores exactos
+- Para cada problema, 1 solución concreta (no 5 opciones)
+- Correr escenarios mentales para validar fórmulas y balance
+- Si se compara contra código, usar agents para leer la implementación real
+- Priorizar problemas por impacto en el desarrollo
+- Reconocer lo que está bien diseñado, no solo lo que está roto

package/skills/audit-game/references/cross-reference-criteria.md

@@ -0,0 +1,42 @@
+# Cross-Reference Criteria
+
+## A. Contradicciones (CRITICAL)
+- **Doc vs Doc**: Comparar secciones del GDD contra spec docs. Flaggear donde describan la misma mecánica de forma diferente (fórmulas, valores, flujo, terminología).
+- **Doc vs Code**: Comparar comportamiento documentado vs implementado. Flaggear donde el código hace algo diferente a lo que dicen los docs.
+- **Contradicciones internas**: Flaggear donde el MISMO documento dice dos cosas diferentes sobre la misma mecánica.
+
+Para cada contradicción:
+```
+| Aspecto | Fuente A dice | Fuente B dice | Severidad | Recomendación |
+```
+
+## B. Gaps y contenido faltante (HIGH)
+- Secciones con [TBD], vacías o placeholder
+- Mecánicas referenciadas pero nunca definidas
+- Sistemas que dependen de decisiones no tomadas (dependencias bloqueantes)
+- Fórmulas, valores o números de balance faltantes
+- Items/enemigos/bosses listados sin stats concretos
+
+Clasificar cada gap:
+- **Bloqueante**: No se puede implementar sin esta decisión
+- **Importante**: Debe definirse antes del vertical slice / milestone actual
+- **Nice to have**: Puede esperar
+
+## C. Coherencia y lógica (MEDIUM)
+- El sistema tiene sentido lógico? (mecánica que contradice pilares del juego)
+- Edge cases no cubiertos? ("qué pasa cuando X Y Z al mismo tiempo?")
+- Las fórmulas producen valores razonables? Correr math mental con escenarios ejemplo
+- Terminología consistente? (mismo concepto con nombres diferentes en distintos lugares)
+- Las curvas de dificultad tienen sentido?
+
+## D. Balance Red Flags (MEDIUM)
+- Estrategias dominantes sin counterplay
+- Opciones inútiles que son estrictamente peores que alternativas
+- Mecánicas de snowball / death spiral
+- Economía rota (items muy baratos/caros relativo al income)
+- Ratios de daño/HP que hacen combates muy rápidos o muy lentos
+
+## E. Completitud para milestone actual (HIGH)
+- El scope del milestone/prototype lista todo lo necesario?
+- Todos los sistemas en scope están definidos en el doc?
+- Hay dependencias ocultas (Sistema A necesita Sistema B que no está en scope)?

package/skills/audit-game/references/output-template.md

@@ -0,0 +1,48 @@
+# Output Template & Finding Format
+
+## Plantilla de reporte
+
+```markdown
+# Auditoría del GDD — [fecha]
+**Fecha:** [hoy]
+**Estado:** [SALUDABLE / NECESITA ATENCIÓN / CRÍTICO]
+**Scope:** [qué se auditó contra qué]
+
+## RESUMEN EJECUTIVO
+[2-3 oraciones: salud general, problema más grande, próximo paso recomendado]
+
+## 1. CONTRADICCIONES
+[Tabla, ordenada por severidad]
+
+## 2. GAPS / CONTENIDO FALTANTE
+[Agrupado por Bloqueante / Importante / Nice to Have]
+
+## 3. COHERENCIA Y LÓGICA
+[Issues de edge cases, terminología, lógica]
+
+## 4. BALANCE RED FLAGS
+[Problemas de balance con escenarios ejemplo]
+
+## 5. DECISIONES PENDIENTES
+[Lista priorizada con opciones y recomendaciones]
+
+## 6. LO QUE ESTÁ BIEN
+[Qué funciona bien — no solo criticar, reconocer buen diseño]
+
+## 7. PRÓXIMOS PASOS
+[Action items concretos, ordenados por prioridad]
+```
+
+## Formato de hallazgos
+
+Cada hallazgo del reporte debe seguir formato PAS condensado (ver `/doc-pas`):
+
+```markdown
+### [Título del hallazgo] — [CRITICAL/HIGH/MEDIUM]
+
+**Problema:** [1-2 oraciones: qué está mal y qué impacto tiene]
+**Análisis:** [1-2 oraciones: por qué pasa]
+**Solución:** [1-2 oraciones: qué hacer, con valores concretos]
+```
+
+NO escribir párrafos largos explicando el problema. NO divagar con recomendaciones genéricas. Bullet points y números concretos.