snapcontext 2.2.0__tar.gz → 3.0.0__tar.gz

{snapcontext-2.2.0/snapcontext.egg-info → snapcontext-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snapcontext
-Version: 2.2.0
+Version: 3.0.0
 Summary: SnapContext: Asistente de IA con contexto automático para desarrollo
 Author-email: SnapContext Contributors <tu@email.com>
 License-Expression: MIT
@@ -275,7 +275,7 @@ snapcontext --plan "tarea" --no-confirmar
 
 1. El proveedor de IA descompone la tarea en pasos JSON:
    ```json
-   {"descripcion": "...", "accion": "editar|ejecutar|consultar",
+   {"descripcion": "...", "accion": "editar|ejecutar|consultar|mcp",
     "archivos": ["..."], "comando": "...",
     "dependencias": [1, 2],
     "condicion": "archivo_existe('src/main.py')"}
@@ -283,7 +283,8 @@ snapcontext --plan "tarea" --no-confirmar
 2. Los pasos se muestran numerados y se pide confirmación.
 3. Cada paso se ejecuta secuencialmente: **editar** usa el pipeline completo
    (`_planificar` + `_bucle_test`), **ejecutar** lanza comandos shell,
-   **consultar** pregunta al proveedor.
+   **consultar** pregunta al proveedor y **mcp** (v2.3.0) ejecuta una
+   herramienta MCP guardando su resultado en el contexto del plan.
 4. Tras cada paso eliges: continuar / reintentar / saltar / abortar. Al final
    hay un resumen que se guarda en `historial.json`.
 
@@ -296,10 +297,95 @@ snapcontext --plan "tarea" --no-confirmar
   - `archivo_existe('src/main.py')`
   - `archivo_contiene('src/main.py', 'def main')`
   - `comando_exito('flutter test')`
+  - `variable_existe('mi_variable')` *(v2.3.0)*
+
+  Además, desde v2.3.0 acepta **comparaciones dinámicas** con resultados
+  de pasos previos o variables dejadas en el contexto (por pasos `mcp`):
+
+  ```json
+  {"condicion": "pasos[0].resultado == 'ok'"}
+  {"condicion": "resultados.mi_variable != ''"}
+  ```
 
   Si la condición es falsa, el paso se salta (con aviso) y el plan continúa.
+### Pasos MCP y contexto dinámico (v2.3.0)
+
+Un paso con `"accion": "mcp"` ejecuta una herramienta MCP del registro
+(`grep`, `read_file`, `list_files`, `ast`, `git_status`, `git_diff`,
+`execute_command`, ...) usando los campos `"herramienta"` y `"args"`.
+El resultado queda disponible para los pasos posteriores:
+
+```json
+ {"descripcion": "buscar referencias", "accion": "mcp",
+  "herramienta": "grep", "args": {"patron": "def main"},
+  "variable": "coincidencias"}
+ {"descripcion": "usar resultado", "accion": "ejecutar",
+  "comando": "echo {{coincidencias}}"}
+```
+
+- El resultado siempre se guarda también como `{{resultado}}`; si el paso
+  define `"variable"`, se guarda bajo ese nombre.
+- `execute_command` soporta `background=true` (devuelve un `pid`
+  consultable con `execute_command_status`) y `capture_output=false` para
+  mostrar la salida en tiempo real.
+
+## 🧠 Aprendizaje autónomo: memoria SQLite, skills y curador (v3.0.0)
+
+SnapContext ya no solo ejecuta tareas: **aprende de ellas**. Toda la
+memoria avanzada vive en una base de datos SQLite (`~/.snapcontext/memoria.db`; sin dependencias externas: `sqlite3` viene con Python).
+
+### Skills: procedimientos reutilizables
+
+- Al terminar una tarea con `--plan` **con éxito**, SnapContext extrae
+  los pasos clave y guarda un *skill* (procedimiento reutilizable) en
+  la tabla `skills`, junto a su contexto (archivos, comandos) y
+  metadatos (fecha, usos, fallos, confiabilidad).
+- Cuando repites una tarea similar, busca el skill más parecido con
+  similitud semántica (embeddings; fallback Jaccard/contención sin
+  dependencias) y lo reutiliza como punto de partida.
+- Si el skill falla, se penaliza y queda marcado para revisión; si
+  tiene éxito repetidamente (3+ usos sin fallos) se marca como
+  **confiable** y se prioriza.
+
+Comandos útiles:
+
+```bash
+snapcontext --skills          # lista los skills aprendidos
+snapcontext --curador         # ejecuta una pasada del curador
+snapcontext --daemon          # daemon: curador + cola de skills
+snapcontext --daemon-intervalo 24   # curador cada 24 h
+snapcontext --plan "..." --sin-aprendizaje  # desactiva el aprendizaje
+```
+
+Ejemplo de aprendizaje:
+
+```bash
+snapcontext --plan "migrar pagos a stripe" --auto --no-confirmar
+# → al terminar (código 0): '[aprendizaje] Nuevo skill guardado:
+#    migrar-pagos-a-stripe'
+snapcontext --plan "migrar pagos a stripe ya" --auto --no-confirmar
+# → reutiliza y refuerza el skill existente (sube su confiabilidad)
+```
+
+### Curador autónomo
+
+- Archiva skills sin uso durante más de 30 días.
+- Fusiona skills casi idénticos (similitud ≥ 0.90), conservando el más
+  usado y sumando sus estadísticas.
+- Notifica por CLI los skills con baja confiabilidad (< 0.4).
+- Se ejecuta manualmente (`--curador`) o periódicamente vía daemon.
+
+### Daemon (`--daemon`)
+
+Proceso en segundo plano que cada minuto sondea la memoria: ejecuta el
+curador cuando vence el intervalo configurado (`--daemon-intervalo`,
+168 h por defecto = semanal) y procesa la cola de skills pendientes
+(tabla `cola`) para ejecutarlos sin intervención. La CLI y el chat
+encolan skills con `_cola_encolar()`; el agente `AgenteAprendizaje`
+(en `agentes.py`) expone toda esta memoria al orquestador.
+
 - **Paralelismo**: con `--paralelo N` (junto a `--auto`) se ejecutan hasta N
-  pasos independientes a la vez; los logs llevan el identificador `[paso N]`:
+  pasos independientes a la vez; los logs llevan el identificador `[paso N]`. Desde v2.3.0 el planificador también respeta las dependencias dinámicas: un paso cuya condición usa una variable que otro paso aún no ha producido espera a que esté disponible:
 
   ```bash
   snapcontext --plan "tarea grande" --auto --paralelo 3 --no-confirmar

{snapcontext-2.2.0 → snapcontext-3.0.0}/README.md

@@ -230,7 +230,7 @@ snapcontext --plan "tarea" --no-confirmar
 
 1. El proveedor de IA descompone la tarea en pasos JSON:
    ```json
-   {"descripcion": "...", "accion": "editar|ejecutar|consultar",
+   {"descripcion": "...", "accion": "editar|ejecutar|consultar|mcp",
     "archivos": ["..."], "comando": "...",
     "dependencias": [1, 2],
     "condicion": "archivo_existe('src/main.py')"}
@@ -238,7 +238,8 @@ snapcontext --plan "tarea" --no-confirmar
 2. Los pasos se muestran numerados y se pide confirmación.
 3. Cada paso se ejecuta secuencialmente: **editar** usa el pipeline completo
    (`_planificar` + `_bucle_test`), **ejecutar** lanza comandos shell,
-   **consultar** pregunta al proveedor.
+   **consultar** pregunta al proveedor y **mcp** (v2.3.0) ejecuta una
+   herramienta MCP guardando su resultado en el contexto del plan.
 4. Tras cada paso eliges: continuar / reintentar / saltar / abortar. Al final
    hay un resumen que se guarda en `historial.json`.
 
@@ -251,10 +252,95 @@ snapcontext --plan "tarea" --no-confirmar
   - `archivo_existe('src/main.py')`
   - `archivo_contiene('src/main.py', 'def main')`
   - `comando_exito('flutter test')`
+  - `variable_existe('mi_variable')` *(v2.3.0)*
+
+  Además, desde v2.3.0 acepta **comparaciones dinámicas** con resultados
+  de pasos previos o variables dejadas en el contexto (por pasos `mcp`):
+
+  ```json
+  {"condicion": "pasos[0].resultado == 'ok'"}
+  {"condicion": "resultados.mi_variable != ''"}
+  ```
 
   Si la condición es falsa, el paso se salta (con aviso) y el plan continúa.
+### Pasos MCP y contexto dinámico (v2.3.0)
+
+Un paso con `"accion": "mcp"` ejecuta una herramienta MCP del registro
+(`grep`, `read_file`, `list_files`, `ast`, `git_status`, `git_diff`,
+`execute_command`, ...) usando los campos `"herramienta"` y `"args"`.
+El resultado queda disponible para los pasos posteriores:
+
+```json
+ {"descripcion": "buscar referencias", "accion": "mcp",
+  "herramienta": "grep", "args": {"patron": "def main"},
+  "variable": "coincidencias"}
+ {"descripcion": "usar resultado", "accion": "ejecutar",
+  "comando": "echo {{coincidencias}}"}
+```
+
+- El resultado siempre se guarda también como `{{resultado}}`; si el paso
+  define `"variable"`, se guarda bajo ese nombre.
+- `execute_command` soporta `background=true` (devuelve un `pid`
+  consultable con `execute_command_status`) y `capture_output=false` para
+  mostrar la salida en tiempo real.
+
+## 🧠 Aprendizaje autónomo: memoria SQLite, skills y curador (v3.0.0)
+
+SnapContext ya no solo ejecuta tareas: **aprende de ellas**. Toda la
+memoria avanzada vive en una base de datos SQLite (`~/.snapcontext/memoria.db`; sin dependencias externas: `sqlite3` viene con Python).
+
+### Skills: procedimientos reutilizables
+
+- Al terminar una tarea con `--plan` **con éxito**, SnapContext extrae
+  los pasos clave y guarda un *skill* (procedimiento reutilizable) en
+  la tabla `skills`, junto a su contexto (archivos, comandos) y
+  metadatos (fecha, usos, fallos, confiabilidad).
+- Cuando repites una tarea similar, busca el skill más parecido con
+  similitud semántica (embeddings; fallback Jaccard/contención sin
+  dependencias) y lo reutiliza como punto de partida.
+- Si el skill falla, se penaliza y queda marcado para revisión; si
+  tiene éxito repetidamente (3+ usos sin fallos) se marca como
+  **confiable** y se prioriza.
+
+Comandos útiles:
+
+```bash
+snapcontext --skills          # lista los skills aprendidos
+snapcontext --curador         # ejecuta una pasada del curador
+snapcontext --daemon          # daemon: curador + cola de skills
+snapcontext --daemon-intervalo 24   # curador cada 24 h
+snapcontext --plan "..." --sin-aprendizaje  # desactiva el aprendizaje
+```
+
+Ejemplo de aprendizaje:
+
+```bash
+snapcontext --plan "migrar pagos a stripe" --auto --no-confirmar
+# → al terminar (código 0): '[aprendizaje] Nuevo skill guardado:
+#    migrar-pagos-a-stripe'
+snapcontext --plan "migrar pagos a stripe ya" --auto --no-confirmar
+# → reutiliza y refuerza el skill existente (sube su confiabilidad)
+```
+
+### Curador autónomo
+
+- Archiva skills sin uso durante más de 30 días.
+- Fusiona skills casi idénticos (similitud ≥ 0.90), conservando el más
+  usado y sumando sus estadísticas.
+- Notifica por CLI los skills con baja confiabilidad (< 0.4).
+- Se ejecuta manualmente (`--curador`) o periódicamente vía daemon.
+
+### Daemon (`--daemon`)
+
+Proceso en segundo plano que cada minuto sondea la memoria: ejecuta el
+curador cuando vence el intervalo configurado (`--daemon-intervalo`,
+168 h por defecto = semanal) y procesa la cola de skills pendientes
+(tabla `cola`) para ejecutarlos sin intervención. La CLI y el chat
+encolan skills con `_cola_encolar()`; el agente `AgenteAprendizaje`
+(en `agentes.py`) expone toda esta memoria al orquestador.
+
 - **Paralelismo**: con `--paralelo N` (junto a `--auto`) se ejecutan hasta N
-  pasos independientes a la vez; los logs llevan el identificador `[paso N]`:
+  pasos independientes a la vez; los logs llevan el identificador `[paso N]`. Desde v2.3.0 el planificador también respeta las dependencias dinámicas: un paso cuya condición usa una variable que otro paso aún no ha producido espera a que esté disponible:
 
   ```bash
   snapcontext --plan "tarea grande" --auto --paralelo 3 --no-confirmar

{snapcontext-2.2.0 → snapcontext-3.0.0}/agentes.py

@@ -420,4 +420,76 @@ class AgenteTester:
         limite = getattr(sc, "MAX_ERROR_SALIDA", 4000)
         if len(limpieza) > limite:
             limpieza = "\n--- (salida recortada) ---\n" + limpieza[-limite:]
-        return limpieza
+        return limpieza
+
+
+class AgenteAprendizaje:
+    """Agente de Aprendizaje (v3.0.0): memoria persistente y skills.
+
+    Encapsula la memoria SQLite de SnapContext (skills, historial de
+    aprendizaje, contexto clave/valor) y el curador autónomo. Delega en las
+    funciones del módulo :mod:`snapcontext` para mantener una única fuente
+    de verdad; esta clase aporta la capa de alto nivel que consumen el
+    orquestador y futuras integraciones (chat, web).
+    """
+
+    def inicializar(self) -> str:
+        """Crea la base de datos de memoria si no existe. Devuelve su ruta."""
+        import snapcontext as sc
+
+        return sc._db_init()
+
+    def buscar_skill(self, consulta: str,
+                     umbral: float = 0.75) -> Optional[dict]:
+        """Busca un skill similar a ``consulta`` (embeddings o fallback)."""
+        import snapcontext as sc
+
+        return sc._skill_buscar(consulta, umbral=umbral)
+
+    def generar_skill(self, consulta: str, resultados: List[dict],
+                      raiz: str = ".") -> Optional[int]:
+        """Genera y guarda un skill a partir de una tarea exitosa."""
+        import snapcontext as sc
+
+        return sc._skill_generar(consulta, resultados, raiz=raiz)
+
+    def registrar_exito(self, skill_id: int) -> float:
+        """Refuerza un skill tras reutilizarlo con éxito."""
+        import snapcontext as sc
+
+        return sc._skill_registrar_exito(skill_id)
+
+    def registrar_fallo(self, skill_id: int) -> float:
+        """Penaliza un skill tras un fallo (queda marcado para revisión)."""
+        import snapcontext as sc
+
+        return sc._skill_registrar_fallo(skill_id)
+
+    def aprender_de_tarea(self, consulta: str, todo_ok: bool,
+                          resultados: List[dict], raiz: str = ".",
+                          detalle: str = "") -> Optional[int]:
+        """Gancho principal: registra la tarea y aprende de ella."""
+        import snapcontext as sc
+
+        return sc._aprender_de_tarea(consulta, todo_ok, resultados,
+                                     raiz=raiz, detalle=detalle)
+
+    def encolar_skill(self, skill_id: int) -> int:
+        """Encola un skill para ejecución en segundo plano por el daemon."""
+        import snapcontext as sc
+
+        return sc._cola_encolar(skill_id)
+
+    def curar(self, dias_sin_uso: int = 30,
+              umbral_fusion: float = 0.90) -> dict:
+        """Ejecuta el curador autónomo y devuelve el resumen de acciones."""
+        import snapcontext as sc
+
+        return sc._curador_ejecutar(dias_sin_uso=dias_sin_uso,
+                                    umbral_fusion=umbral_fusion)
+
+    def listar_skills(self, incluir_archivados: bool = False) -> List[dict]:
+        """Lista los skills almacenados en la memoria persistente."""
+        import snapcontext as sc
+
+        return sc._skill_listar(incluir_archivados=incluir_archivados)

{snapcontext-2.2.0 → snapcontext-3.0.0}/orquestador.py

@@ -21,7 +21,7 @@ import sys
 from typing import List, Optional, Tuple
 
 from agentes import (AgenteContexto, AgenteEditor, AgenteEditorAST,
-                     AgenteEditorPropio, AgenteTester)
+                     AgenteEditorPropio, AgenteAprendizaje, AgenteTester)
 
 # Centinela diferenciado del None de "aborto": _planificar lo devuelve cuando
 # el pipeline termina de forma exitosa y temprana (p. ej. --vista-previa).
@@ -43,6 +43,7 @@ class Orquestador:
         self.agente_editor_propio = AgenteEditorPropio()
         self.agente_editor_ast = AgenteEditorAST()
         self.agente_tester = AgenteTester()
+        self.agente_aprendizaje = AgenteAprendizaje()
         self.evento_callback = evento_callback
 
     def _on_evento(self, evento: dict) -> None:
@@ -200,6 +201,17 @@ class Orquestador:
                     )
                     self._emitir_tipo("aider", accion="fin", ok=ok)
             self._emitir_tipo("final", ok=ok)
+            # Aprendizaje continuo (v3.0.0): registrar el resultado de la
+            # tarea en la memoria persistente y generar/reforzar skills.
+            try:
+                if not getattr(args, "sin_aprendizaje", False):
+                    self.agente_aprendizaje.aprender_de_tarea(
+                        consulta, bool(ok),
+                        [{"descripcion": consulta, "accion": "editar",
+                          "archivos": seleccion}],
+                        raiz=str(raiz))
+            except Exception as exc:
+                sc.aviso(f"[aprendizaje] No se pudo registrar ({exc})")
             return 0 if ok else 1
         finally:
             # Si este orquestador fue quien registró el callback global, lo limpia.

{snapcontext-2.2.0 → snapcontext-3.0.0}/pyproject.toml

@@ -6,13 +6,15 @@ build-backend = "setuptools.build_meta"
 # Nombre verificado disponible en PyPI (18/08/2026): pypi.org/pypi/snapcontext → 404.
 # Alternativas si algún día estuviera ocupado: "snapcontext-cli" o "snapcontext-tool".
 name = "snapcontext"
-version = "2.2.0"
+version = "3.0.0"
 description = "SnapContext: Asistente de IA con contexto automático para desarrollo"
 readme = "README.md"
 requires-python = ">=3.9"
 # PEP 639: licencia SPDX + fichero de licencia incluido en el paquete.
 license = "MIT"
 license-files = ["LICENSE"]
+# Nota (v3.0.0): la memoria avanzada usa `sqlite3`, incluido en la stdlib de
+# Python; no añade dependencias externas.
 authors = [
     # TODO: cambia por tu nombre y correo reales antes de publicar.
     { name = "SnapContext Contributors", email = "tu@email.com" },

{snapcontext-2.2.0 → snapcontext-3.0.0/snapcontext.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snapcontext
-Version: 2.2.0
+Version: 3.0.0
 Summary: SnapContext: Asistente de IA con contexto automático para desarrollo
 Author-email: SnapContext Contributors <tu@email.com>
 License-Expression: MIT
@@ -275,7 +275,7 @@ snapcontext --plan "tarea" --no-confirmar
 
 1. El proveedor de IA descompone la tarea en pasos JSON:
    ```json
-   {"descripcion": "...", "accion": "editar|ejecutar|consultar",
+   {"descripcion": "...", "accion": "editar|ejecutar|consultar|mcp",
     "archivos": ["..."], "comando": "...",
     "dependencias": [1, 2],
     "condicion": "archivo_existe('src/main.py')"}
@@ -283,7 +283,8 @@ snapcontext --plan "tarea" --no-confirmar
 2. Los pasos se muestran numerados y se pide confirmación.
 3. Cada paso se ejecuta secuencialmente: **editar** usa el pipeline completo
    (`_planificar` + `_bucle_test`), **ejecutar** lanza comandos shell,
-   **consultar** pregunta al proveedor.
+   **consultar** pregunta al proveedor y **mcp** (v2.3.0) ejecuta una
+   herramienta MCP guardando su resultado en el contexto del plan.
 4. Tras cada paso eliges: continuar / reintentar / saltar / abortar. Al final
    hay un resumen que se guarda en `historial.json`.
 
@@ -296,10 +297,95 @@ snapcontext --plan "tarea" --no-confirmar
   - `archivo_existe('src/main.py')`
   - `archivo_contiene('src/main.py', 'def main')`
   - `comando_exito('flutter test')`
+  - `variable_existe('mi_variable')` *(v2.3.0)*
+
+  Además, desde v2.3.0 acepta **comparaciones dinámicas** con resultados
+  de pasos previos o variables dejadas en el contexto (por pasos `mcp`):
+
+  ```json
+  {"condicion": "pasos[0].resultado == 'ok'"}
+  {"condicion": "resultados.mi_variable != ''"}
+  ```
 
   Si la condición es falsa, el paso se salta (con aviso) y el plan continúa.
+### Pasos MCP y contexto dinámico (v2.3.0)
+
+Un paso con `"accion": "mcp"` ejecuta una herramienta MCP del registro
+(`grep`, `read_file`, `list_files`, `ast`, `git_status`, `git_diff`,
+`execute_command`, ...) usando los campos `"herramienta"` y `"args"`.
+El resultado queda disponible para los pasos posteriores:
+
+```json
+ {"descripcion": "buscar referencias", "accion": "mcp",
+  "herramienta": "grep", "args": {"patron": "def main"},
+  "variable": "coincidencias"}
+ {"descripcion": "usar resultado", "accion": "ejecutar",
+  "comando": "echo {{coincidencias}}"}
+```
+
+- El resultado siempre se guarda también como `{{resultado}}`; si el paso
+  define `"variable"`, se guarda bajo ese nombre.
+- `execute_command` soporta `background=true` (devuelve un `pid`
+  consultable con `execute_command_status`) y `capture_output=false` para
+  mostrar la salida en tiempo real.
+
+## 🧠 Aprendizaje autónomo: memoria SQLite, skills y curador (v3.0.0)
+
+SnapContext ya no solo ejecuta tareas: **aprende de ellas**. Toda la
+memoria avanzada vive en una base de datos SQLite (`~/.snapcontext/memoria.db`; sin dependencias externas: `sqlite3` viene con Python).
+
+### Skills: procedimientos reutilizables
+
+- Al terminar una tarea con `--plan` **con éxito**, SnapContext extrae
+  los pasos clave y guarda un *skill* (procedimiento reutilizable) en
+  la tabla `skills`, junto a su contexto (archivos, comandos) y
+  metadatos (fecha, usos, fallos, confiabilidad).
+- Cuando repites una tarea similar, busca el skill más parecido con
+  similitud semántica (embeddings; fallback Jaccard/contención sin
+  dependencias) y lo reutiliza como punto de partida.
+- Si el skill falla, se penaliza y queda marcado para revisión; si
+  tiene éxito repetidamente (3+ usos sin fallos) se marca como
+  **confiable** y se prioriza.
+
+Comandos útiles:
+
+```bash
+snapcontext --skills          # lista los skills aprendidos
+snapcontext --curador         # ejecuta una pasada del curador
+snapcontext --daemon          # daemon: curador + cola de skills
+snapcontext --daemon-intervalo 24   # curador cada 24 h
+snapcontext --plan "..." --sin-aprendizaje  # desactiva el aprendizaje
+```
+
+Ejemplo de aprendizaje:
+
+```bash
+snapcontext --plan "migrar pagos a stripe" --auto --no-confirmar
+# → al terminar (código 0): '[aprendizaje] Nuevo skill guardado:
+#    migrar-pagos-a-stripe'
+snapcontext --plan "migrar pagos a stripe ya" --auto --no-confirmar
+# → reutiliza y refuerza el skill existente (sube su confiabilidad)
+```
+
+### Curador autónomo
+
+- Archiva skills sin uso durante más de 30 días.
+- Fusiona skills casi idénticos (similitud ≥ 0.90), conservando el más
+  usado y sumando sus estadísticas.
+- Notifica por CLI los skills con baja confiabilidad (< 0.4).
+- Se ejecuta manualmente (`--curador`) o periódicamente vía daemon.
+
+### Daemon (`--daemon`)
+
+Proceso en segundo plano que cada minuto sondea la memoria: ejecuta el
+curador cuando vence el intervalo configurado (`--daemon-intervalo`,
+168 h por defecto = semanal) y procesa la cola de skills pendientes
+(tabla `cola`) para ejecutarlos sin intervención. La CLI y el chat
+encolan skills con `_cola_encolar()`; el agente `AgenteAprendizaje`
+(en `agentes.py`) expone toda esta memoria al orquestador.
+
 - **Paralelismo**: con `--paralelo N` (junto a `--auto`) se ejecutan hasta N
-  pasos independientes a la vez; los logs llevan el identificador `[paso N]`:
+  pasos independientes a la vez; los logs llevan el identificador `[paso N]`. Desde v2.3.0 el planificador también respeta las dependencias dinámicas: un paso cuya condición usa una variable que otro paso aún no ha producido espera a que esté disponible:
 
   ```bash
   snapcontext --plan "tarea grande" --auto --paralelo 3 --no-confirmar

{snapcontext-2.2.0 → snapcontext-3.0.0}/snapcontext.egg-info/SOURCES.txt

@@ -23,9 +23,11 @@ tests/test_jetbrains_170.py
 tests/test_mcp_014.py
 tests/test_mcp_140.py
 tests/test_memoria_015.py
+tests/test_memoria_300.py
 tests/test_orquestador.py
 tests/test_permisos_013.py
 tests/test_plan_012.py
+tests/test_plan_mcp_230.py
 tests/test_v010.py
 tests/test_validacion_130.py
 tests/test_vscode_016.py