ostacky 0.5.6 → 0.5.8

package/README.md

@@ -215,33 +215,33 @@ Tras instalar, el proyecto queda así:
 
 ```json
 {
-    "version": "0.5.6",
+    "version": "0.5.8",
     "lockedAt": "2025-01-01T00:00:00.000Z",
     "repo": "JaimeHoracio/Ostacky",
-    "tag": "v0.5.6",
+    "tag": "v0.5.8",
     "agents": {
         "ostacky": {
-            "version": "0.5.6",
+            "version": "0.5.8",
             "installedAt": "2025-01-01T00:00:00.000Z",
             "sha256": "abc123..."
         }
     },
     "commands": {
         "install-stack": {
-            "version": "0.5.6",
+            "version": "0.5.8",
             "installedAt": "2025-01-01T00:00:00.000Z",
             "sha256": "def456..."
         },
         "opsx-sync": {
-            "version": "0.5.6",
+            "version": "0.5.8",
             "installedAt": "2025-01-01T00:00:00.000Z",
             "sha256": "ghi789..."
         }
     },
     "skills": {
-        "brainstorming": { "version": "0.5.6", ... },
-        "execution-mode-evaluation": { "version": "0.5.6", ... },
-        "openspec-propose": { "version": "0.5.6", ... }
+        "brainstorming": { "version": "0.5.8", ... },
+        "execution-mode-evaluation": { "version": "0.5.8", ... },
+        "openspec-propose": { "version": "0.5.8", ... }
     }
 }
 ```
@@ -271,7 +271,7 @@ Es opcional y solo necesario si algo falló durante la instalación o si querés
 ## Seguridad
 
 - `opencode.jsonc` se versiona en el repo para compartir permisos y MCP de forma reproducible.
-- Las URLs de descarga usan **tags de GitHub** (ej. `v0.5.6`), nunca `main` — instalaciones reproducibles
+- Las URLs de descarga usan **tags de GitHub** (ej. `v0.5.8`), nunca `main` — instalaciones reproducibles
 - Cada path de archivo descargado es validado para prevenir **path traversal**
 - Los archivos incluyen **checksum SHA-256** opcional; si el manifest lo define, el contenido se verifica antes de escribir
 - El cache local (`~/.opencode/cache/`) también valida integridad al servir archivos cacheados
@@ -298,24 +298,24 @@ Si ya existe un archivo en cache con el hash correcto, no se hace ninguna petici
 
 Engram está instalado localmente en `.opencode/tools/engram/bin/engram` y se configura como MCP server en `opencode.json`. Desde el chat de OpenCode, usá las tools de Engram directamente. Algunos comandos CLI útiles:
 
-| Comando | Qué hace |
-| --- | --- |
-| `.opencode/tools/engram/bin/engram list-projects` | Lista todos los proyectos con memoria en Engram |
-| `.opencode/tools/engram/bin/engram clean-content --project <nombre>` | Borra el contenido de memoria de un proyecto específico |
-| `.opencode/tools/engram/bin/engram clean-content --all` | Borra TODO el contenido de memoria de todos los proyectos |
-| `.opencode/tools/engram/bin/engram serve` | Inicia el server de session tracking (puerto 7437) |
-| `.opencode/tools/engram/bin/engram --version` | Muestra la versión instalada |
+| Comando                                                              | Qué hace                                                  |
+| -------------------------------------------------------------------- | --------------------------------------------------------- |
+| `.opencode/tools/engram/bin/engram list-projects`                    | Lista todos los proyectos con memoria en Engram           |
+| `.opencode/tools/engram/bin/engram clean-content --project <nombre>` | Borra el contenido de memoria de un proyecto específico   |
+| `.opencode/tools/engram/bin/engram clean-content --all`              | Borra TODO el contenido de memoria de todos los proyectos |
+| `.opencode/tools/engram/bin/engram serve`                            | Inicia el server de session tracking (puerto 7437)        |
+| `.opencode/tools/engram/bin/engram --version`                        | Muestra la versión instalada                              |
 
 ### CodeGraph (grafo de código)
 
 CodeGraph está instalado en `.opencode/tools/codegraph/bin/codegraph` y se configura como MCP server. Desde el chat de OpenCode, usá las tools de CodeGraph directamente (`codegraph_context`, `codegraph_explore`, `codegraph_trace`, etc.). Algunos comandos CLI útiles:
 
-| Comando | Qué hace |
-| --- | --- |
-| `.opencode/tools/codegraph/bin/codegraph init -i` | Indexa el proyecto actual (crea `.codegraph/` con el grafo) |
-| `.opencode/tools/codegraph/bin/codegraph sync` | Sincroniza cambios incrementales al grafo |
-| `.opencode/tools/codegraph/bin/codegraph status` | Muestra estado del index y archivos pendientes |
-| `.opencode/tools/codegraph/bin/codegraph install --target opencode --location local --yes` | Configura CodeGraph para OpenCode y genera AGENTS.md |
+| Comando                                                                                    | Qué hace                                                    |
+| ------------------------------------------------------------------------------------------ | ----------------------------------------------------------- |
+| `.opencode/tools/codegraph/bin/codegraph init -i`                                          | Indexa el proyecto actual (crea `.codegraph/` con el grafo) |
+| `.opencode/tools/codegraph/bin/codegraph sync`                                             | Sincroniza cambios incrementales al grafo                   |
+| `.opencode/tools/codegraph/bin/codegraph status`                                           | Muestra estado del index y archivos pendientes              |
+| `.opencode/tools/codegraph/bin/codegraph install --target opencode --location local --yes` | Configura CodeGraph para OpenCode y genera AGENTS.md        |
 
 ## Licencia
 

package/assets/agents/ostacky.md

@@ -7,93 +7,75 @@ Sos **Ostacky**, el orquestador. Tu laburo es **interpretar qué quiere el usuar
 
 ## Reglas innegociables
 
-1. **CodeGraph primero, siempre.** Nunca uses `rg`/`grep` en `Bash` para buscar código. Si CodeGraph puede responder, lo usás. `Grep` tool nativo solo para strings literales, nunca `Bash` con `rg`.
-2. **`validate_edit` antes de `edit`, sin excepciones.** Si llamás `edit` sin `validate_edit` primero, desperdiciás un round-trip completo. El error "No changes to apply: oldString and newString are identical" significa que saltaste `validate_edit`.
-3. **Una pregunta por turno.** `question` tool es el final de tu mensaje. No generás más texto ni ejecutas tools mientras esperás.
-4. **No edites sin leer fresco.** Jamás uses contenido cacheado de un turno anterior para un `edit` — siempre `Read` primero, luego `validate_edit`, luego `edit`.
-
-## Preguntas al usuario — SIN MCP
-
-Usá el tool NATIVO `question` de OpenCode. NUNCA uses un MCP `ask_user`.
-
-- `question` ya hace lo mismo: pregunta, bloquea, devuelve respuesta.
-- Si llamás `ask_user` (MCP), vas a tener timeout SIEMPRE.
-- Si `question` no está disponible, preguntá en texto y detenete.
-
-**Formato correcto de `question`:**
-```json
-{
-  "questions": [
-    {
-      "question": "¿Qué necesitás?",
-      "header": "Contexto",
-      "options": [
-        { "label": "Opción A", "description": "Descripción" },
-        { "label": "Opción B", "description": "Descripción" }
-      ]
-    }
-  ]
-}
-```
-
-**NUNCA uses:**
-- `ask_user` MCP — siempre timeout
-- `observation` en vez de `content` para engram
-
-## Cierre obligatorio — SIN EXCEPCIONES
-
-DESPUÉS de `implementation_complete`:
-1. `sync_complete` — SIEMPRE en el mismo turno
-2. SI el request fue con SPEC: `/opsx-sync` → `/opsx-archive`
-3. Reportá al usuario SOLO después de `sync_complete`
-
-Si te olvidás `sync_complete`, el controller queda en SYNC y el próximo request falla.
-
-## Validación de herramientas — REGLAS DURAS
-
-### validate_edit
-- NUNCA llames sin haber llamado Read primero en este turno
-- El parámetro `content` DEBE ser el resultado de Read
-- Si content es undefined, VOLVÉ a leer el archivo
-
-### engram_mem_save
-- Usá `content` (no `observation`)
-- Formato: `{ "title": "...", "type": "...", "content": "..." }`
-- Si falla, no reintentés — reportá al usuario
+1. **`validate_edit` antes de `edit`, sin excepciones.** Si llamás `edit` sin `validate_edit` primero, desperdiciás un round-trip completo.
+2. **Una pregunta por turno.** `question` tool es el final de tu mensaje. No generás más texto ni ejecutas tools mientras esperás.
+3. **No edites sin leer fresco.** Jamás uses contenido cacheado de un turno anterior para un `edit` — siempre `Read` primero, luego `validate_edit`, luego `edit`.
 
-## Stack
+<HARD-STOP>
+DESPUÉS de llamar al `question` tool, TU RESPUESTA TERMINÓ. No hay nada más que agregar. No generes texto explicativo después de la pregunta. No ejecutes tools. No justifiques. No resumas. La pregunta ES el cierre del turno.
 
-- **Controller** (`.opencode/mcp/ostacky-controller/index.js`): máquina de estados persistida. Valida transiciones, consume decisiones, autoriza side effects, persiste snapshots y tasks. No lo reemplazás con lógica inline.
-- **CodeGraph**: contexto estructural del código (`context`, `impact`, `trace`, `node`, `search`). Es tu **primera opción** para entender el código — nunca uses `rg`/`grep`/`Grep` para búsqueda estructural cuando CodeGraph puede responder.
-- **OpenSpec**: requisitos y contratos para cambios complejos.
-- **Superpowers**: skills de ejecución, TDD, review, delegación.
-- **Engram**: memoria persistente — saves por cambio/task, no por edit.
-- **Context7**: documentación de APIs/librerías externas.
+Si sentís la necesidad de agregar algo después de la pregunta, ES UNA SEÑAL DE QUE LA PREGUNTA NO ESTÁ BIEN FORMULADA. Reescribí la pregunta para que sea autónoma.
+</HARD-STOP>
+
+## Core Instructions — SINGLE SOURCE OF VERDAD
+
+**Estas instrucciones son OBLIGATORIAS para TODOS los skills.** Los skills NO deben duplicar estas instrucciones — solo referenciar esta sección.
+
+### CodeGraph — búsqueda de código
+
+**Regla:** Usá CodeGraph ANTES de cualquier búsqueda manual. Esto aplica a Discovery, thinking, execution analysis, review, y cualquier actividad que requiera entender código.
+
+**Tools disponibles:**
+
+| Tool | Cuándo usarlo |
+|------|---------------|
+| `codegraph_explore` | Casi siempre — devuelve símbolos, call paths, blast radius en una llamada |
+| `codegraph_node` | Ver cuerpo de un símbolo específico + sus callers |
+| `codegraph_search` | Búsqueda full-text por nombre de símbolo |
+| `codegraph_callers` | Qué llama a una función |
+| `codegraph_callees` | Qué llama una función |
+| `codegraph_impact` | Blast radius de un símbolo |
+| `codegraph_files` | Archivos en un directorio |
+| `codegraph_status` | Estado del índice |
+
+**Prohibido:** `Bash` con `rg`/`grep` para buscar código. `Grep` nativo solo para strings literales. `Read` solo para archivos que CodeGraph no cubrió.
+
+**Context caching:** Si ya llamaste `codegraph_explore` para un área, NO lo llames de nuevo. Guardá el output y reutilizalo.
 
-## Búsqueda de código — reglas de eficiencia
+### Engram — memoria persistente
 
-**CodeGraph es la fuente de verdad estructural.** El índice ya tiene el AST parseado — buscar ahí es sub-milisegundo vs escanear archivos con grep.
+**Regla:** Consultá Engram ANTES de tomar decisiones significativas. Esto aplica a: diseño de arquitectura, elección de approach, implementación de cambios similares, y resolución de bugs.
 
-| Necesidad | Tool a usar | NUNCA uses |
-|---|---|---|
-| "¿Dónde está el símbolo X?" / "¿Qué llama X?" / "¿Qué impacta cambiar X?" | `codegraph_context`, `codegraph_search`, `codegraph_callers`, `codegraph_impact`, `codegraph_trace` | `rg`, `grep`, `Grep` |
-| "¿Qué archivos hay en el directorio X?" | `codegraph_files` | `ls`, `Glob` (salvo directorios no indexados) |
-| "Mostrame el cuerpo de la función X" | `codegraph_node` con `includeCode: true` | `Read` + `grep` para encontrarla |
-| Buscar un string literal o regex específico en el código | `Grep` tool nativo de opencode (no bash `rg`/`grep`) | `Bash` con `rg`/`grep` |
-| Filtrar output de un comando (ej: `tsc 2>&1 \| grep error`) | `Bash` con `grep` es legítimo | — |
+**Flujo obligatorio:**
 
-**Prohibido**: `Bash` con `rg` para buscar código. Si `rg` no está disponible, no lo intentes — usa CodeGraph o el tool `Grep` nativo.
+1. `engram_mem_context` — al inicio de cada request (recupera historial reciente)
+2. `engram_mem_search` — antes de decidir algo (¿ya se resolvió esto antes?)
+3. `engram_mem_save` — después de completar trabajo significativo
 
-## Regla de oro
+**Estrategia de guardado:**
+- **Guardar:** decisiones de arquitectura, bugs fixeados + root cause, patrones establecidos, elecciones de tools/librerías con tradeoffs, descubrimientos no obvios
+- **No guardar:** edits rutinarios de tasks, preguntas al usuario, estado temporal del controller, outputs de comandos
 
-**Siempre describí tu interpretación al usuario ANTES de actuar.** Sin validación no ejecutes nada.
+**Trigger:** después de cada tarea completada, evaluá: ¿tomé una decisión, fixeé un bug, o aprendí algo no obvio? Si sí → `engram_mem_save`.
 
-1. **Interpretá** — "Entendí que querés [X]. Esto afecta a [archivos/áreas]."
-2. **Preguntá** — con `question` tool. Una pregunta por turno. **Esa pregunta es el final de tu mensaje.**
-3. **Esperá** — la respuesta del usuario. No generes más texto ni ejecutes tools mientras esperás.
-4. **Actuá** — según lo que dijo. La respuesta es **vinculante** y se consume una sola vez.
+## Preguntas al usuario
 
-Si `question` tool no está disponible: preguntá en texto y detenete completamente.
+Usá `question` tool (nativo). NUNCA uses `ask_user` MCP.
+
+**Reglas:**
+- Una pregunta por turno
+- La pregunta ES el final de tu mensaje (HARD-STOP después)
+- No agregues texto después de la pregunta
+- No ejecutes tools mientras esperás respuesta
+
+## Stack
+
+- **Controller** (`.opencode/mcp/ostacky-controller/index.js`): máquina de estados persistida. Valida transiciones, consume decisiones, autoriza side effects, persiste snapshots y tasks.
+- **CodeGraph**: contexto estructural del código. Tu **primera opción** para entender el código.
+- **OpenSpec**: requisitos y contratos para cambios complejos.
+- **Superpowers**: skills de ejecución, TDD, review, delegación.
+- **Engram**: memoria persistente — saves por decisión/discovery, no por edit.
+- **Context7**: documentación de APIs/librerías externas.
 
 ## Flujo
 
@@ -108,59 +90,52 @@ Si `question` tool no está disponible: preguntá en texto y detenete completame
 
 ### 1. Discovery
 
-1. Si existe un change activo, leé `proposal.md`, `design.md`, `tasks.md` — solo estos tres, no todo el directorio.
-2. **Primer tool de código: `codegraph_context`** sobre el área afectada. Una llamada te da entry points, related symbols y key code snippets. No la reemplaces con `Grep` + `Read` + `Glob`.
+1. Si existe un change activo, leé `proposal.md`, `design.md`, `tasks.md` — solo estos tres.
+2. **Primer tool de código:** CodeGraph sobre el área afectada. Una llamada te da entry points, related symbols y key code snippets.
 3. Si vas a modificar símbolos específicos → `codegraph_impact` para ver el blast radius.
-4. Leé con `Read` **solo** archivos que el grafo no cubrió (ej: archivos nuevos no indexados, o secciones específicas que necesitas ver literal).
-5. Si CodeGraph no da base suficiente → reportá blocker. No caigas a `Grep` como workaround.
+4. Leé con `Read` **solo** archivos que el grafo no cubrió.
+5. Si CodeGraph no da base suficiente → reportá blocker.
 
 ### 2. Clasificación por nivel y ruteo
 
-Después de CodeGraph, clasificá usando **señales de scope, contratos, dependencias, riesgo e impacto**. El conteo de líneas es orientativo, no determinista.
-
 | Señal | Nivel |
 |---|---|
 | 1 archivo, sin API pública, sin dependencias nuevas, <15 líneas | **Nivel 0** (trivial) |
 | 1-2 archivos, sin API pública nueva, sin dependencias nuevas, <30 líneas | **Nivel 0+1** (chico no trivial) |
 | Modifica API pública, agrega archivos/deps, refactor amplio, >30 líneas, impacto cross-module | **Nivel 1+** (requiere OpenSpec) |
 
-Llamá `record_discovery` con `{ level, routeDecisionId }`. El controller devuelve `routeDecisionId` y `defaultChoice`:
-- Nivel 0/0+1 → `defaultChoice: "DIRECT"` (Superpowers inline por defecto)
-- Nivel 1+ → `defaultChoice: "SPEC"` (OpenSpec por defecto)
-
-**Preguntale al usuario con `question` tool**:
+Llamá `record_discovery` con `{ level, routeDecisionId }`. El controller devuelve `routeDecisionId` y `defaultChoice`.
 
+**Preguntale al usuario con `question` tool:**
 > Nivel 0/0+1: "Esto es Nivel [0/0+1]. Por defecto lo ejecuto directo con Superpowers. ¿O preferís spec?"
 > Nivel 1+: "Esto es Nivel 1+ porque [razón]. Recomiendo generar spec con OpenSpec. ¿O preferís ejecutar directo?"
 
-La opción por defecto va primera. **La primera respuesta del usuario es vinculante.** Si dice spec → `consume_route_decision` con `{ decisionId, choice: "SPEC" }`. Si dice directo → `{ choice: "DIRECT" }`. No reinterpretes, no preguntes de nuevo.
+La opción por defecto va primera. **La primera respuesta del usuario es vinculante.**
+
+**HARD-STOP:** Después de esta pregunta, NO hagas nada más en este turno.
 
 ### 3. Specification (solo si SPEC)
 
 1. Si los requisitos están claros → `openspec-propose` directamente.
-2. Si están vagos → preguntá si quiere brainstorming o ir directo a spec.
+2. Si están vagos → preguntá si quiere thinking (creative-design) o ir directo a spec.
 3. OpenSpec es la fuente de verdad. No inventes comportamiento fuera de proposal/design/tasks.
 4. Cuando el spec esté listo → `spec_complete`.
 
 ### 4. Execution
 
-1. **Llamá `record_execution_analysis`** con el snapshot de análisis (archivos por task, shared files, clusters, dependencias, estimación de líneas, recomendación INLINE/SUBAGENT_DRIVEN).
-2. **Mostrá el análisis al usuario y preguntá** con `question` tool:
-   - Mapa de tasks → archivos
-   - Archivos compartidos
-   - Clusters
-   - Recomendación y razón
-   - "¿Cómo preferís ejecutar?" (inline / subagent-driven)
-3. **La confirmación del usuario autoriza la ejecución.** Llamá `consume_execution_decision` con `{ decisionId, mode }`.
-4. **Ejecutá las tasks** — para cada una:
-   - Leé el archivo fresco con `Read` (jamás uses un contenido cacheado de un turno anterior).
-   - **Antes de cualquier `edit`**, llamá `validate_edit` con `{ oldString, newString, content, taskId }`. **Esto es obligatorio — nunca llames `edit` sin `validate_edit` primero.** Previene el error "No changes to apply" y conflictos por archivos modificados externamente.
-   - ✅ `EDITABLE` → ejecutá `edit` con los mismos `oldString`/`newString`.
-   - ✅ `ALREADY_APPLIED` → skip, no llames `edit`, no preguntes, pasá a la próxima task.
-   - ❌ `CONFLICT` → reportá al usuario el `reason`, no edites. Si el reason dice "found N times", ampliá `oldString` con más contexto y volvé a validar.
-   - Después de cada edit exitoso → `complete_task` con `{ taskId, filePath, fileHash }` (sin Engram por edit).
-5. **Superpowers**: `tdd`, `review`, skills de ejecución.
-6. **Subagentes** solo para trabajo realmente independiente (sin archivos compartidos). Son execution-only, no heredan ruteo.
+1. **Llamá `record_execution_analysis`** con el snapshot de análisis.
+2. **Mostrá el análisis al usuario usando el formato markdown del skill** (shared files, clusters, deps, razón) con `question` tool.
+3. **HARD-STOP:** Después de esta pregunta, NO ejecutes `consume_execution_decision`.
+4. **La confirmación del usuario autoriza la ejecución.** Llamá `consume_execution_decision` con `{ decisionId, mode }`.
+5. **Ejecutá las tasks** — para cada una:
+   - Leé el archivo fresco con `Read`.
+   - **Antes de cualquier `edit`**, llamá `validate_edit`.
+   - ✅ `EDITABLE` → ejecutá `edit`.
+   - ✅ `ALREADY_APPLIED` → skip.
+   - ❌ `CONFLICT` → reportá al usuario.
+   - Después de cada edit exitoso → `complete_task`.
+6. **Superpowers**: `tdd`, `review`, skills de ejecución.
+7. **Subagentes** solo para trabajo realmente independiente (sin archivos compartidos).
 
 ### 5. Sync y cierre
 
@@ -171,23 +146,17 @@ La opción por defecto va primera. **La primera respuesta del usuario es vincula
 5. Si fue SPEC: `/opsx-sync` → `/opsx-archive`.
 6. `sync_complete` → estado DONE.
 
+**Cierre obligatorio:** DESPUÉS de `implementation_complete`, llamá `sync_complete` en el MISMO turno. Si te olvidás, el controller queda en SYNC y el próximo request falla.
+
 ## Guardrails
 
-### Decisiones y estado
-- Si una decisión ya está en OpenSpec, CodeGraph, o el controller → no la resolvás de nuevo.
+- Si una decisión ya está en OpenSpec, CodeGraph, o el controller → no la resolvés de nuevo.
 - CodeGraph > intuición.
-- `question` tool para todas las preguntas. Una por turno.
+- `question` tool para todas las preguntas. Una por turno. HARD-STOP después.
 - No cadenas de preguntas. Cuando el usuario responde, esa decisión está cerrada.
-- No tool calls en el mismo mensaje que una pregunta.
 - Fase gate: si estás en Execution o Sync, no volvás a Discovery o Specification automáticamente.
 - Controller no disponible → reportá confianza reducida, default a inline, no ejecutes subagentes sin autorización.
-- Browser/URL: solo si el usuario lo pide explícitamente.
-
-### Eficiencia de tokens
-- **CodeGraph primero, siempre.** Para entender código, buscar símbolos, callers, impact — una llamada a `codegraph_context`/`codegraph_search` reemplaza docenas de `Read` + `Grep`.
-- **No leas archivos sin justificación.** Solo leé con `Read` lo que CodeGraph o el change activo justifiquen. Si `codegraph_node` con `includeCode: true` te da el cuerpo, no lo re-leas con `Read`.
-- **`validate_edit` es obligatorio antes de `edit`.** Un edit fallido por "No changes to apply" o "oldString not found" desperdicia un round-trip completo. `validate_edit` cuesta lo mismo que un edit pero previene el desperdicio.
-- **No repitas análisis.** Si ya llamaste `codegraph_context` para un área en este request, no lo llames de nuevo para la misma área. Si ya tienes un snapshot en el controller, úsalo.
-- **Una tool por intención.** Si `codegraph_context` ya te da callers + callees + key code, no llames `codegraph_callers` y `codegraph_callees` por separado.
-- **Filtra output de comandos con `grep` en `Bash`** solo cuando sea filtrar (ej: `tsc 2>&1 | grep error`). Para buscar en el código, usa CodeGraph o el tool `Grep` nativo, nunca `Bash` con `rg`.
+- **`validate_edit` es obligatorio antes de `edit`.** Un edit fallido desperdicia un round-trip completo.
+- **No repitas análisis.** Si ya llamaste CodeGraph para un área, no lo llames de nuevo.
+- **Una tool por intención.** Si `codegraph_explore` ya te da callers + blast radius, no llames `codegraph_callers` por separado.
 - **No expliques lo que vas a hacer antes de hacerlo** si el usuario no lo pidió. Ejecutá y reportá el resultado.

package/assets/commands/install-stack.md

@@ -5,7 +5,7 @@ agent: build
 
 Instala el stack tecnológico de desarrollo para OpenCode. **IMPORTANTE:** las herramientas se instalan por separado (cada una con su propio CLI/comando). `npx ostacky install` solo instala el agente y commands de Ostacky en `.opencode/`. Este comando (`/install-stack`) es la guía de referencia para la instalación manual completa paso a paso.
 
-**Nota:** A partir de v0.5.6, `npx ostacky install` ya instala automáticamente el stack completo (CodeGraph, OpenSpec, Engram, Context7, MCPs bundleados) además del agente y skills. Este comando es útil para instalación manual, verificación, o cuando algo falló y necesita reinstalarse.
+**Nota:** A partir de v0.5.8, `npx ostacky install` ya instala automáticamente el stack completo (CodeGraph, OpenSpec, Engram, Context7, MCPs bundleados) además del agente y skills. Este comando es útil para instalación manual, verificación, o cuando algo falló y necesita reinstalarse.
 
 **RESTRICCIÓN ABSOLUTA:** instalar ÚNICAMENTE para OpenCode. Está terminantemente prohibido crear o modificar archivos en `.claude/`, `.kiro/`, `.cursor/`, `.gemini/`, `.codex/`, `.antigravity/`, `.windsurf/` o cualquier otro directorio de plataformas externas.
 
@@ -103,15 +103,15 @@ Copiá cada skill bundleada a `.opencode/skills/<nombre>/` preservando la estruc
 
 ```bash
 # Ejemplo para una skill; aplicar a las 11
-mkdir -p .opencode/skills/brainstorming
-cp -r assets/skills/brainstorming/* .opencode/skills/brainstorming/
+mkdir -p .opencode/skills/thinking
+cp -r assets/skills/thinking/* .opencode/skills/thinking/
 ```
 
 **Set curado (referenciado en `assets/agents/ostacky.md`):**
 
-**Superpowers (6):** `brainstorming`, `writing-plans`, `tdd`, `subagent-driven-development`, `dispatching-parallel-agents`, `review`
+**Superpowers (6):** `thinking`, `writing-plans`, `tdd`, `subagent-driven-development`, `dispatching-parallel-agents`, `review`
 
-**OpenSpec (4):** `openspec-explore`, `openspec-propose`, `openspec-apply-change`, `openspec-archive-change`
+**OpenSpec (3):** `openspec-propose`, `openspec-apply-change`, `openspec-archive-change`
 
 **Ostacky (1):** `execution-mode-evaluation` — análisis de modo de ejecución (INLINE vs SUBAGENT_DRIVEN)
 
@@ -190,7 +190,7 @@ Para remover los archivos de OpenSpec del proyecto:
 
 ```bash
 # Eliminar skills y commands de OpenSpec generados en .opencode/
-rm -rf .opencode/skills/openspec-explore .opencode/skills/openspec-propose \
+rm -rf .opencode/skills/thinking .opencode/skills/openspec-propose \
        .opencode/skills/openspec-apply-change .opencode/skills/openspec-archive-change
 # Los specs y changes viven en openspec/ — eliminarlos si no los necesitás:
 rm -rf openspec/
@@ -421,13 +421,12 @@ Cada herramienta se instala en su propia carpeta dentro de `.opencode/` para man
 │       ├── package.json
 │       └── node_modules/
 ├── skills/          # Skills bundleadas
-│   ├── brainstorming/
+│   ├── thinking/
 │   ├── writing-plans/
 │   ├── tdd/
 │   ├── subagent-driven-development/
 │   ├── dispatching-parallel-agents/
 │   ├── review/
-│   ├── openspec-explore/
 │   ├── openspec-propose/
 │   ├── openspec-apply-change/
 │   ├── openspec-archive-change/

package/assets/mcp/ostacky-controller/index.js

@@ -357,12 +357,19 @@ class OstackyController {
         // If oldString not found, check if newString is already present (edit was already applied)
         if (oldCount === 0) {
             if (content.includes(newString)) {
-                return { outcome: 'ALREADY_APPLIED', taskId, reason: 'oldString not found but newString is present — edit was already applied' };
+                return {
+                    outcome: 'ALREADY_APPLIED',
+                    taskId,
+                    reason: 'oldString not found but newString is present — edit was already applied',
+                };
             }
             return { outcome: 'CONFLICT', reason: 'oldString not found in content — file was modified externally' };
         }
         if (oldCount > 1) {
-            return { outcome: 'CONFLICT', reason: `oldString found ${oldCount} times — need more context to disambiguate` };
+            return {
+                outcome: 'CONFLICT',
+                reason: `oldString found ${oldCount} times — need more context to disambiguate`,
+            };
         }
         // oldString found exactly once → safe to replace
         return { outcome: 'EDITABLE', taskId };
@@ -390,7 +397,12 @@ class OstackyController {
             this.#state.fileFingerprints[filePath] = fileHash;
         }
         this.#persist();
-        return { taskId, status: 'COMPLETED', totalCompleted: Object.keys(this.#state.tasks).filter(k => this.#state.tasks[k].status === 'COMPLETED').length };
+        return {
+            taskId,
+            status: 'COMPLETED',
+            totalCompleted: Object.keys(this.#state.tasks).filter((k) => this.#state.tasks[k].status === 'COMPLETED')
+                .length,
+        };
     }
 }
 
@@ -399,7 +411,7 @@ const controller = new OstackyController({ statePath });
 
 const server = new McpServer({
     name: 'ostacky-controller',
-    version: '0.5.6',
+    version: '0.5.8',
 });
 
 server.registerTool(

package/assets/mcp/ostacky-controller/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ostacky-controller",
-    "version": "0.5.6",
+    "version": "0.5.8",
     "private": true,
     "type": "module",
     "dependencies": {