snapcontext 4.2.0__tar.gz → 4.3.0__tar.gz

{snapcontext-4.2.0/snapcontext.egg-info → snapcontext-4.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snapcontext
-Version: 4.2.0
+Version: 4.3.0
 Summary: SnapContext: Asistente de IA con contexto automático para desarrollo
 Author-email: SnapContext Contributors <tu@email.com>
 License-Expression: MIT
@@ -45,7 +45,7 @@ Dynamic: license-file
 
 # SnapContext
 
-![v4.2.0](https://img.shields.io/badge/version-4.2.0-blue.svg)
+![v4.3.0](https://img.shields.io/badge/version-4.3.0-blue.svg)
 [![PyPI](https://badge.fury.io/py/snapcontext.svg)](https://pypi.org/project/snapcontext/)
 [![CI](https://img.shields.io/github/actions/workflow/status/NicolasBruna24/snapcontext/ci.yml?branch=main&label=tests)](https://github.com/NicolasBruña24/snapcontext/actions)
 ![Python 3.9+](https://img.shields.io/badge/python-3.9%2B-blue.svg)
@@ -85,6 +85,62 @@ pip install aider-chat                  # ediciones de código
 snapcontext --init                      # asistente inicial + API key
 ```
 
+## 🐳 Sandboxing con Docker (v4.3.0)
+
+Ejecuta los comandos de SnapContext (bucle de pruebas, `execute_command`,
+pasos `ejecutar` del planificador, plugins…) dentro de un **contenedor Docker
+aislado**. Ideal cuando no se confía en el código o necesitas dependencias
+específicas.
+
+### Uso básico
+
+```bash
+# Todo el trabajo de comandos dentro del contenedor
+snapcontext "arreglar el checkout" --test-loop --sandbox
+
+# Con imagen personalizada y comando de preparación
+snapcontext "añadir tests" --test-loop --sandbox \
+    --sandbox-imagen python:3.11-slim \
+    --sandbox-comando "pip install pytest"
+
+# En el planificador: pasos "ejecutar" y MCP con comandos usan el sandbox;
+# "editar" y "consultar" siguen en el host.
+snapcontext "migrar a pytest" --plan --sandbox
+
+# Imagen por defecto sin flag:
+export SNAPCONTEXT_SANDBOX_IMAGE=ubuntu:22.04   # PowerShell: $env:SNAPCONTEXT_SANDBOX_IMAGE="..."
+```
+
+### Cómo funciona
+
+- **Detección**: `_docker_disponible()` comprueba `docker --version` (binario)
+  y `docker info` (daemon activo).
+- **Ejecución**: cada comando se lanza como
+  `docker run --rm -v "<proyecto>:/workspace" -w /workspace -e GEMINI_API_KEY … <imagen> sh -c "<comando>"`.
+- **Montaje**: el directorio del proyecto se monta en `/workspace`.
+- **Variables de entorno**: las claves (`*_API_KEY`, `OLLAMA_URL`, …) se pasan
+  al contenedor automáticamente.
+- **Preparación**: `--sandbox-comando` antepone un comando de setup
+  (`apt update && apt install -y …`) antes del comando principal.
+
+### Qué corre dentro y fuera del sandbox
+
+| Dentro del contenedor | Fuera (host) |
+| --- | --- |
+| Bucle de pruebas (`--test-loop`) | Herramientas de solo lectura (`grep`, `read_file`, `list_files`, `ast`) |
+| MCP `execute_command` (+ background) | Pasos `editar` y `consultar` del planificador |
+| Pasos `ejecutar` del planificador | Selección de contexto, chat con la IA |
+| Plugins y herramientas de usuario | |
+
+### Errores y logs
+
+- Cada comando sandboxeado registra `ℹ [sandbox] Ejecutando en contenedor: …`.
+- Si un comando falla dentro del contenedor se muestra su salida y código como
+  siempre.
+- Si Docker no está disponible y usaste `--sandbox` explícitamente,
+  SnapContext falla con un mensaje claro; sin el flag nunca cambia nada
+  (compatibilidad total).
+
 ## 🧰 Instalación y onboarding sin fricción (v3.1.x)
 
 Objetivo: instalar SnapContext y empezar a usarlo en menos de 5 minutos.

{snapcontext-4.2.0 → snapcontext-4.3.0}/README.md

@@ -1,6 +1,6 @@
 # SnapContext
 
-![v4.2.0](https://img.shields.io/badge/version-4.2.0-blue.svg)
+![v4.3.0](https://img.shields.io/badge/version-4.3.0-blue.svg)
 [![PyPI](https://badge.fury.io/py/snapcontext.svg)](https://pypi.org/project/snapcontext/)
 [![CI](https://img.shields.io/github/actions/workflow/status/NicolasBruna24/snapcontext/ci.yml?branch=main&label=tests)](https://github.com/NicolasBruña24/snapcontext/actions)
 ![Python 3.9+](https://img.shields.io/badge/python-3.9%2B-blue.svg)
@@ -40,6 +40,62 @@ pip install aider-chat                  # ediciones de código
 snapcontext --init                      # asistente inicial + API key
 ```
 
+## 🐳 Sandboxing con Docker (v4.3.0)
+
+Ejecuta los comandos de SnapContext (bucle de pruebas, `execute_command`,
+pasos `ejecutar` del planificador, plugins…) dentro de un **contenedor Docker
+aislado**. Ideal cuando no se confía en el código o necesitas dependencias
+específicas.
+
+### Uso básico
+
+```bash
+# Todo el trabajo de comandos dentro del contenedor
+snapcontext "arreglar el checkout" --test-loop --sandbox
+
+# Con imagen personalizada y comando de preparación
+snapcontext "añadir tests" --test-loop --sandbox \
+    --sandbox-imagen python:3.11-slim \
+    --sandbox-comando "pip install pytest"
+
+# En el planificador: pasos "ejecutar" y MCP con comandos usan el sandbox;
+# "editar" y "consultar" siguen en el host.
+snapcontext "migrar a pytest" --plan --sandbox
+
+# Imagen por defecto sin flag:
+export SNAPCONTEXT_SANDBOX_IMAGE=ubuntu:22.04   # PowerShell: $env:SNAPCONTEXT_SANDBOX_IMAGE="..."
+```
+
+### Cómo funciona
+
+- **Detección**: `_docker_disponible()` comprueba `docker --version` (binario)
+  y `docker info` (daemon activo).
+- **Ejecución**: cada comando se lanza como
+  `docker run --rm -v "<proyecto>:/workspace" -w /workspace -e GEMINI_API_KEY … <imagen> sh -c "<comando>"`.
+- **Montaje**: el directorio del proyecto se monta en `/workspace`.
+- **Variables de entorno**: las claves (`*_API_KEY`, `OLLAMA_URL`, …) se pasan
+  al contenedor automáticamente.
+- **Preparación**: `--sandbox-comando` antepone un comando de setup
+  (`apt update && apt install -y …`) antes del comando principal.
+
+### Qué corre dentro y fuera del sandbox
+
+| Dentro del contenedor | Fuera (host) |
+| --- | --- |
+| Bucle de pruebas (`--test-loop`) | Herramientas de solo lectura (`grep`, `read_file`, `list_files`, `ast`) |
+| MCP `execute_command` (+ background) | Pasos `editar` y `consultar` del planificador |
+| Pasos `ejecutar` del planificador | Selección de contexto, chat con la IA |
+| Plugins y herramientas de usuario | |
+
+### Errores y logs
+
+- Cada comando sandboxeado registra `ℹ [sandbox] Ejecutando en contenedor: …`.
+- Si un comando falla dentro del contenedor se muestra su salida y código como
+  siempre.
+- Si Docker no está disponible y usaste `--sandbox` explícitamente,
+  SnapContext falla con un mensaje claro; sin el flag nunca cambia nada
+  (compatibilidad total).
+
 ## 🧰 Instalación y onboarding sin fricción (v3.1.x)
 
 Objetivo: instalar SnapContext y empezar a usarlo en menos de 5 minutos.

{snapcontext-4.2.0 → snapcontext-4.3.0}/agentes.py

@@ -702,6 +702,12 @@ class AgenteTester:
         import snapcontext as sc
 
         sc.depurar(f"[AgenteTester] Ejecutando pruebas: {' '.join(comando)}")
+        # v4.3.0: con --sandbox activo las pruebas corren en el contenedor.
+        if sc.sandbox_activo():
+            codigo, stdout, stderr = sc._ejecutar_pruebas_argv(
+                comando, directorio)
+            return subprocess.CompletedProcess(
+                comando, codigo, stdout=stdout, stderr=stderr)
         return subprocess.run(
             comando, cwd=directorio, capture_output=True, text=True
         )

{snapcontext-4.2.0 → snapcontext-4.3.0}/pyproject.toml

@@ -6,7 +6,7 @@ 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 = "4.2.0"
+version = "4.3.0"
 description = "SnapContext: Asistente de IA con contexto automático para desarrollo"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -89,4 +89,4 @@ packages = ["web"]
 
 [tool.setuptools.package-data]
 # El estático de la interfaz web debe viajar dentro del paquete instalado.
-"web" = ["static/index.html"]
+"web" = ["static/index.html"]

{snapcontext-4.2.0 → snapcontext-4.3.0/snapcontext.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snapcontext
-Version: 4.2.0
+Version: 4.3.0
 Summary: SnapContext: Asistente de IA con contexto automático para desarrollo
 Author-email: SnapContext Contributors <tu@email.com>
 License-Expression: MIT
@@ -45,7 +45,7 @@ Dynamic: license-file
 
 # SnapContext
 
-![v4.2.0](https://img.shields.io/badge/version-4.2.0-blue.svg)
+![v4.3.0](https://img.shields.io/badge/version-4.3.0-blue.svg)
 [![PyPI](https://badge.fury.io/py/snapcontext.svg)](https://pypi.org/project/snapcontext/)
 [![CI](https://img.shields.io/github/actions/workflow/status/NicolasBruna24/snapcontext/ci.yml?branch=main&label=tests)](https://github.com/NicolasBruña24/snapcontext/actions)
 ![Python 3.9+](https://img.shields.io/badge/python-3.9%2B-blue.svg)
@@ -85,6 +85,62 @@ pip install aider-chat                  # ediciones de código
 snapcontext --init                      # asistente inicial + API key
 ```
 
+## 🐳 Sandboxing con Docker (v4.3.0)
+
+Ejecuta los comandos de SnapContext (bucle de pruebas, `execute_command`,
+pasos `ejecutar` del planificador, plugins…) dentro de un **contenedor Docker
+aislado**. Ideal cuando no se confía en el código o necesitas dependencias
+específicas.
+
+### Uso básico
+
+```bash
+# Todo el trabajo de comandos dentro del contenedor
+snapcontext "arreglar el checkout" --test-loop --sandbox
+
+# Con imagen personalizada y comando de preparación
+snapcontext "añadir tests" --test-loop --sandbox \
+    --sandbox-imagen python:3.11-slim \
+    --sandbox-comando "pip install pytest"
+
+# En el planificador: pasos "ejecutar" y MCP con comandos usan el sandbox;
+# "editar" y "consultar" siguen en el host.
+snapcontext "migrar a pytest" --plan --sandbox
+
+# Imagen por defecto sin flag:
+export SNAPCONTEXT_SANDBOX_IMAGE=ubuntu:22.04   # PowerShell: $env:SNAPCONTEXT_SANDBOX_IMAGE="..."
+```
+
+### Cómo funciona
+
+- **Detección**: `_docker_disponible()` comprueba `docker --version` (binario)
+  y `docker info` (daemon activo).
+- **Ejecución**: cada comando se lanza como
+  `docker run --rm -v "<proyecto>:/workspace" -w /workspace -e GEMINI_API_KEY … <imagen> sh -c "<comando>"`.
+- **Montaje**: el directorio del proyecto se monta en `/workspace`.
+- **Variables de entorno**: las claves (`*_API_KEY`, `OLLAMA_URL`, …) se pasan
+  al contenedor automáticamente.
+- **Preparación**: `--sandbox-comando` antepone un comando de setup
+  (`apt update && apt install -y …`) antes del comando principal.
+
+### Qué corre dentro y fuera del sandbox
+
+| Dentro del contenedor | Fuera (host) |
+| --- | --- |
+| Bucle de pruebas (`--test-loop`) | Herramientas de solo lectura (`grep`, `read_file`, `list_files`, `ast`) |
+| MCP `execute_command` (+ background) | Pasos `editar` y `consultar` del planificador |
+| Pasos `ejecutar` del planificador | Selección de contexto, chat con la IA |
+| Plugins y herramientas de usuario | |
+
+### Errores y logs
+
+- Cada comando sandboxeado registra `ℹ [sandbox] Ejecutando en contenedor: …`.
+- Si un comando falla dentro del contenedor se muestra su salida y código como
+  siempre.
+- Si Docker no está disponible y usaste `--sandbox` explícitamente,
+  SnapContext falla con un mensaje claro; sin el flag nunca cambia nada
+  (compatibilidad total).
+
 ## 🧰 Instalación y onboarding sin fricción (v3.1.x)
 
 Objetivo: instalar SnapContext y empezar a usarlo en menos de 5 minutos.

{snapcontext-4.2.0 → snapcontext-4.3.0}/snapcontext.egg-info/SOURCES.txt

@@ -35,6 +35,7 @@ tests/test_permisos_013.py
 tests/test_plan_012.py
 tests/test_plan_mcp_230.py
 tests/test_plugins_400.py
+tests/test_sandbox_430.py
 tests/test_seguridad_rendimiento_420.py
 tests/test_v010.py
 tests/test_validacion_130.py

{snapcontext-4.2.0 → snapcontext-4.3.0}/snapcontext.py

@@ -39,6 +39,7 @@ Open-source y pensado para ser fácil de extender (ver ejecutar_bucle_test).
 
 import argparse
 import ast
+import contextlib
 import difflib
 import fnmatch
 import json
@@ -111,7 +112,7 @@ except ImportError:  # pragma: no cover
 import concurrent.futures
 from concurrent.futures import ThreadPoolExecutor
 
-VERSION = "4.2.0"
+VERSION = "4.3.0"
 
 # v3.1.0 — Claves de API reconocidas para el modo por defecto (offline).
 CLAVES_API_CONOCIDAS = (
@@ -2532,7 +2533,9 @@ def ejecutar_bucle_test(consulta: str, archivos: List[str], directorio: str,
     """
     if not comando_test:
         raise RuntimeError("El comando de pruebas está vacío (--comando-test).")
-    if shutil.which(comando_test[0]) is None:
+    # v4.3.0: en sandbox el binario vive dentro del contenedor; la comprobación
+    # de PATH del host no aplica.
+    if not _SANDBOX_ACTIVO and shutil.which(comando_test[0]) is None:
         raise RuntimeError(
             f"No se encontró el comando de pruebas '{comando_test[0]}'. "
             "Ajusta --comando-test."
@@ -2556,9 +2559,16 @@ def ejecutar_bucle_test(consulta: str, archivos: List[str], directorio: str,
 
         solicitud = " ".join(comando_test)
         info(f"Ejecutando pruebas: {solicitud}")
-        resultado = subprocess.run(
-            comando_test, cwd=directorio, capture_output=True, text=True
-        )
+        # v4.3.0: con --sandbox las pruebas corren dentro del contenedor.
+        if _SANDBOX_ACTIVO:
+            codigo, stdout, stderr = _ejecutar_pruebas_argv(
+                comando_test, directorio)
+            resultado = subprocess.CompletedProcess(
+                comando_test, codigo, stdout=stdout, stderr=stderr)
+        else:
+            resultado = subprocess.run(
+                comando_test, cwd=directorio, capture_output=True, text=True
+            )
         if resultado.returncode == 0:
             exito(f"¡Pruebas superadas en la iteración {iteracion}!")
             return True
@@ -3213,6 +3223,11 @@ def _ejecutar_comando(comando: str, directorio: str = ".",
     raiz = Path(directorio).expanduser()
     if not raiz.is_dir():
         return (-1, "", f"El directorio no existe: {raiz}")
+    # v4.3.0: con --sandbox activo el comando corre dentro del contenedor.
+    if _SANDBOX_ACTIVO:
+        info(f"[sandbox] Ejecutando en contenedor: {comando}")
+        comando = _envolver_sandbox(comando, str(raiz))
+        raiz = Path.cwd()  # docker se lanza desde el host; el mount ya es absoluto
     try:
         proc = subprocess.run(
             comando,
@@ -3231,6 +3246,155 @@ def _ejecutar_comando(comando: str, directorio: str = ".",
     except OSError as exc:
         return (-1, "", f"Error ejecutando '{comando}': {exc}")
 
+
+# ---------------------------------------------------------------------------
+# 🐳 Sandboxing con Docker (v4.3.0)
+# ---------------------------------------------------------------------------
+# Imagen por defecto del sandbox (ligera, con Python y herramientas comunes).
+# Puede sobrescribirse con --sandbox-imagen o SNAPCONTEXT_SANDBOX_IMAGE.
+SANDBOX_IMAGEN_DEFECTO = "python:3.11-slim"
+SANDBOX_DIR_TRABAJO = "/workspace"
+# Nombres/patrones de variables de entorno que se pasan al contenedor.
+_SANDBOX_VARS_CLAVE = ("GEMINI_API_KEY", "ANTHROPIC_API_KEY", "OPENAI_API_KEY",
+                       "DEEPSEEK_API_KEY", "GROQ_API_KEY", "OLLAMA_URL",
+                       "SNAPCONTEXT_SANDBOX_IMAGE")
+
+# Estado global del sandbox (lo activa _activar_sandbox desde main()).
+_SANDBOX_ACTIVO: bool = False
+_SANDBOX_IMAGEN: str = SANDBOX_IMAGEN_DEFECTO
+_SANDBOX_COMANDO_PREP: Optional[str] = None
+
+
+def _docker_disponible() -> bool:
+    """Comprueba que Docker está instalado Y que el daemon está en ejecución.
+
+    - ``docker --version`` existe en el PATH.
+    - ``docker info`` responde sin error (daemon activo).
+
+    Nunca lanza excepciones; devuelve ``False`` ante cualquier problema.
+    """
+    if shutil.which("docker") is None:
+        return False
+    try:
+        proc = subprocess.run(
+            ["docker", "info"], capture_output=True, text=True,
+            timeout=30, creationflags=(
+                subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0),
+        )
+        return proc.returncode == 0
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+
+
+def _sandbox_imagen_resuelta(explicita: Optional[str] = None) -> str:
+    """Resuelve la imagen del sandbox: flag > variable de entorno > defecto."""
+    return (explicita or os.environ.get("SNAPCONTEXT_SANDBOX_IMAGE", "").strip()
+            or SANDBOX_IMAGEN_DEFECTO)
+
+
+def _activar_sandbox(imagen: Optional[str] = None,
+                     comando_prep: Optional[str] = None,
+                     estricto: bool = True) -> bool:
+    """Activa el sandbox global si Docker está disponible.
+
+    Args:
+        imagen: imagen Docker (--sandbox-imagen o env por defecto).
+        comando_prep: comando de preparación previo (--sandbox-comando).
+        estricto: si es ``True`` (``--sandbox`` explícito) y Docker no está
+            disponible lanza ``RuntimeError``; si es ``False`` solo avisa y
+            continúa sin sandbox.
+
+    Devuelve ``True`` si el sandbox quedó activo.
+    """
+    global _SANDBOX_ACTIVO, _SANDBOX_IMAGEN, _SANDBOX_COMANDO_PREP
+    if not _docker_disponible():
+        mensaje = (
+            "--sandbox solicitado pero Docker no está disponible "
+            "(¿instalado? ¿el daemon está en ejecución?). "
+            "Instala Docker Desktop o inicia el servicio 'docker'."
+        )
+        _SANDBOX_ACTIVO = False
+        if estricto:
+            raise RuntimeError(mensaje)
+        aviso(mensaje + "\n  → Se continúa SIN sandbox.")
+        return False
+    _SANDBOX_ACTIVO = True
+    _SANDBOX_IMAGEN = _sandbox_imagen_resuelta(imagen)
+    _SANDBOX_COMANDO_PREP = (comando_prep or "").strip() or None
+    exito(f"🐳 Sandbox activo (imagen: {_SANDBOX_IMAGEN}, "
+          f"directorio montado en {SANDBOX_DIR_TRABAJO}).")
+    return True
+
+
+def _desactivar_sandbox() -> None:
+    """Desactiva el sandbox global (vuelve al comportamiento normal)."""
+    global _SANDBOX_ACTIVO, _SANDBOX_COMANDO_PREP
+    _SANDBOX_ACTIVO = False
+    _SANDBOX_COMANDO_PREP = None
+
+
+def sandbox_activo() -> bool:
+    """Indica si el sandbox Docker está activo."""
+    return _SANDBOX_ACTIVO
+
+
+def _envolver_sandbox(comando: str, directorio: str = ".") -> str:
+    """Envuelve ``comando`` en un ``docker run`` dentro del sandbox.
+
+    Genera algo como::
+
+        docker run --rm -v "<dir>:/workspace" -w /workspace \
+                   -e GEMINI_API_KEY ... <imagen> sh -c "<comando>"
+
+    Si hay comando de preparación (--sandbox-comando), se antepone con
+    ``&&``. Sin sandbox activo devuelve ``comando`` tal cual.
+    """
+    if not _SANDBOX_ACTIVO:
+        return comando
+    raiz = Path(directorio).expanduser().resolve()
+    partes = ["docker", "run", "--rm",
+              "-v", f"{raiz}:{SANDBOX_DIR_TRABAJO}",
+              "-w", SANDBOX_DIR_TRABAJO]
+    # Pasar las variables de entorno relevantes del host al contenedor.
+    vistas = set()
+    for nombre in list(os.environ):
+        incluir = nombre in _SANDBOX_VARS_CLAVE or nombre.endswith("_API_KEY")
+        if incluir and nombre not in vistas:
+            vistas.add(nombre)
+            partes.extend(["-e", nombre])
+    partes.append(_SANDBOX_IMAGEN)
+    if _SANDBOX_COMANDO_PREP:
+        comando = f"{_SANDBOX_COMANDO_PREP} && ({comando})"
+    partes.extend(["sh", "-c", comando])
+    return shlex.join(partes)
+
+
+def _ejecutar_pruebas_argv(comando: List[str], directorio: str) -> tuple:
+    """Ejecuta un comando de pruebas (lista argv) respetando el sandbox.
+
+    Devuelve ``(codigo_retorno, stdout, stderr)`` como :func:`_ejecutar_comando`.
+    """
+    if not comando:
+        return (-1, "", "El comando de pruebas está vacío.")
+    return _ejecutar_comando(" ".join(comando), directorio, timeout=1800)
+
+
+@contextlib.contextmanager
+def _sandbox_pausado():
+    """Desactiva temporalmente el sandbox (herramientas de solo lectura).
+
+    Las herramientas MCP que no modifican el sistema (grep, git_status,
+    git_diff...) se ejecutan fuera del contenedor para mayor velocidad.
+    """
+    global _SANDBOX_ACTIVO
+    previo = _SANDBOX_ACTIVO
+    _SANDBOX_ACTIVO = False
+    try:
+        yield
+    finally:
+        _SANDBOX_ACTIVO = previo
+
+
 # --- Procesos en segundo plano para execute_command (v2.3.0) -----------------
 _PROCESOS_FONDO: dict = {}   # pid → estado (para ejecución en background)
 
@@ -3245,6 +3409,11 @@ def _lanzar_proceso_fondo(comando: str, directorio: str = ".",
     raiz = Path(directorio).expanduser()
     if not raiz.is_dir():
         return {"ok": False, "error": f"El directorio no existe: {raiz}"}
+    # v4.3.0: los procesos en segundo plano también respetan --sandbox.
+    if _SANDBOX_ACTIVO:
+        info(f"[sandbox] Ejecutando en contenedor (background): {comando}")
+        comando = _envolver_sandbox(comando, str(raiz))
+        raiz = Path.cwd()
     try:
         if capture_output:
             proc = subprocess.Popen(
@@ -6292,7 +6461,11 @@ def _tool_grep(patron: str, directorio: str = ".",
         comando = f'grep -rn -i -m 5 "{patron}" .'
     else:
         comando = f'findstr /s /n /i "{patron}" *.py *.dart *.js *.ts *.go *.rs'
-    codigo, stdout, stderr = _ejecutar_comando(comando, directorio, timeout=60)
+    codigo, stdout, stderr = (None, None, None)
+    # v4.3.0: grep es de solo lectura → corre fuera del sandbox.
+    with _sandbox_pausado():
+        codigo, stdout, stderr = _ejecutar_comando(comando, directorio,
+                                                   timeout=60)
     lineas = [l for l in (stdout or "").splitlines() if l.strip()]
     return {"ok": codigo == 0 or bool(lineas),
             "buscador": herramienta, "total": len(lineas),
@@ -6381,8 +6554,9 @@ def _tool_git_status(directorio: str = ".") -> dict:
         return {"ok": False, "error": f"'{directorio}' no es un repositorio git"}
     _, rama, _ = _ejecutar_comando("git rev-parse --abbrev-ref HEAD",
                                    directorio, timeout=15)
-    codigo, salida, _ = _ejecutar_comando("git status --porcelain",
-                                          directorio, timeout=30)
+    with _sandbox_pausado():  # v4.3.0: solo lectura → fuera del sandbox
+        codigo, salida, _ = _ejecutar_comando("git status --porcelain",
+                                              directorio, timeout=30)
     modificados = [l.strip() for l in (salida or "").splitlines() if l.strip()]
     return {"ok": codigo == 0, "rama": (rama or "").strip(),
             "cambios": modificados, "total_cambios": len(modificados)}
@@ -6396,7 +6570,9 @@ def _tool_git_diff(directorio: str = ".", archivo: Optional[str] = None,
     comando = "git diff HEAD"
     if archivo:
         comando += f' -- "{archivo}"'
-    codigo, salida, stderr = _ejecutar_comando(comando, directorio, timeout=60)
+    with _sandbox_pausado():  # v4.3.0: solo lectura → fuera del sandbox
+        codigo, salida, stderr = _ejecutar_comando(comando, directorio,
+                                                   timeout=60)
     lineas = (salida or "").splitlines()
     return {"ok": codigo == 0, "archivo": archivo,
             "total_lineas": len(lineas),
@@ -7580,7 +7756,8 @@ CATEGORIAS_AYUDA = (
      ("--git-commit", "--no-git-commit", "--branch")),
     ("Planificador y bucles",
      ("--paralelo", "--max-intentos", "--test-loop", "--server-loop",
-      "--manual-loop", "--comando-test", "--dispositivo", "--url-defecto",
+      "--manual-loop", "--comando-test", "--sandbox", "--sandbox-imagen",
+      "--sandbox-comando", "--dispositivo", "--url-defecto",
       "--max-iteraciones")),
     ("Otros",
      ("consulta", "--directorio", "--aider-opciones", "--depurar",
@@ -8517,6 +8694,23 @@ def crear_parser() -> argparse.ArgumentParser:
         "--comando-test", default=COMANDO_TEST_DEFECTO,
         help='Comando de pruebas del bucle (por defecto: "flutter test").',
     )
+    # v4.3.0: sandbox opcional con Docker.
+    parser.add_argument(
+        "--sandbox", action="store_true",
+        help="(v4.3.0) Ejecuta comandos y pruebas dentro de un contenedor "
+             "Docker aislado (monta el proyecto en /workspace). Si Docker no "
+             "está disponible, falla con error claro.",
+    )
+    parser.add_argument(
+        "--sandbox-imagen", dest="sandbox_imagen", default=None,
+        help="Imagen Docker del sandbox (por defecto: python:3.11-slim o "
+             "SNAPCONTEXT_SANDBOX_IMAGE).",
+    )
+    parser.add_argument(
+        "--sandbox-comando", dest="sandbox_comando", default=None,
+        help='Comando de preparación dentro del contenedor antes del comando '
+             'principal (ej.: "apt update && apt install -y make").',
+    )
     parser.add_argument(
         "--max-iteraciones", type=int, default=MAX_ITERACIONES_TEST_DEFECTO,
         help="Máximo de iteraciones del bucle de pruebas.",
@@ -9497,6 +9691,14 @@ def main(argv: Optional[List[str]] = None) -> int:
         # para todos los modos (chat, planificador, ...).
         global CONFIRMAR_ACCIONES
         CONFIRMAR_ACCIONES = getattr(args, "confirmar", True)
+        # v4.3.0: activar el sandbox Docker si se pidió --sandbox. Es lo
+        # primero para que TODO comando posterior ya nazca en el contenedor
+        # (bucle de pruebas, MCP execute_command, pasos "ejecutar" del plan).
+        if getattr(args, "sandbox", False):
+            _activar_sandbox(
+                imagen=getattr(args, "sandbox_imagen", None),
+                comando_prep=getattr(args, "sandbox_comando", None),
+                estricto=True)
         # v3.1.1: --bienvenida explícito ejecuta el tutorial y marca el
         # primer uso como completado (por si quiere volver a verlo).
         if getattr(args, "bienvenida", False):

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_auto_017.py

@@ -183,7 +183,7 @@ class TestFlagsAutoCli(unittest.TestCase):
         self.assertTrue(args.plan)
 
     def test_version_es_1_2_0(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_diagnostico_310.py

@@ -35,7 +35,7 @@ class TestFlagsCli310(unittest.TestCase):
                                                      ).bienvenida)
 
     def test_version_es_3_1_0(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 class TestApiKeyDetection(unittest.TestCase):

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_diff_editor_210.py

@@ -98,7 +98,7 @@ class TestFlagsEdicion(unittest.TestCase):
         self.assertEqual(parser.parse_args(["--modo-edicion", "sobrescribir", "c"]).modo_edicion, "sobrescribir")
 
     def test_version_es_2_1_0(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_editor_ast_220.py

@@ -174,7 +174,7 @@ class TestFlagsEdicionAST(unittest.TestCase):
         self.assertEqual(args2.modo_edicion, "auto")
 
     def test_version_es_2_2_0(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_editor_propio_200.py

@@ -86,7 +86,7 @@ class TestFlagsEditor(unittest.TestCase):
         self.assertIsInstance(orch.agente_editor_propio, AgenteEditorPropio)
 
     def test_version_es_2_0_0(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_exe_150.py

@@ -14,7 +14,7 @@ import snapcontext as sc  # noqa: E402
 
 class TestVersion(unittest.TestCase):
     def test_version_150_coherente(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 class TestEstaticoWeb(unittest.TestCase):

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_jetbrains_170.py

@@ -17,7 +17,7 @@ import snapcontext as sc  # noqa: E402
 
 class TestVersion(unittest.TestCase):
     def test_version_170_coherente(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 class TestEstructuraJetBrains(unittest.TestCase):

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_mcp_014.py

@@ -217,7 +217,7 @@ class TestFormatoYAutoContexto(BaseMCP):
 
 class TestVersionMCPCli(BaseMCP):
     def test_version_es_1_2_0(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_mcp_140.py

@@ -248,7 +248,7 @@ class TestChatComandosGrafo(unittest.TestCase):
 
 class TestVersion(unittest.TestCase):
     def test_version_140_coherente(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_memoria_015.py

@@ -179,7 +179,7 @@ class TestFlagsMemoriaCli(BaseMemoria):
             ["--init-claude"]).init_claude)
 
     def test_version_es_1_2_0(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_memoria_300.py

@@ -312,7 +312,7 @@ class TestFlagsCLI(unittest.TestCase):
         self.assertEqual(args.daemon_intervalo, 24)
 
     def test_version_300(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_permisos_013.py

@@ -182,7 +182,7 @@ class TestFlagsConfirmarCLI(unittest.TestCase):
         self.assertFalse(self._parse(["--chat", "--no-confirmar"]).confirmar)
 
     def test_version_es_1_2_0(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_plan_012.py

@@ -269,7 +269,7 @@ class TestFlagsPlanCLI(unittest.TestCase):
         self.assertIsNone(self._parse(["--plan", "x"]).branch)
 
     def test_version_es_1_2_0(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_plan_mcp_230.py

@@ -210,7 +210,7 @@ class TestEjecutarToolExecuteCommand(unittest.TestCase):
 
 class TestVersionYFlags(unittest.TestCase):
     def test_version_230(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
     def test_flag_paralelo(self):
         args = sc.crear_parser().parse_args(["--plan", "t", "--paralelo", "3"])

snapcontext-4.3.0/tests/test_sandbox_430.py

@@ -0,0 +1,249 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests de la v4.3.0: sandbox opcional con Docker."""
+
+import argparse
+import os
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+from unittest import mock
+
+RAIZ = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(RAIZ))
+
+import snapcontext as sc  # noqa: E402
+
+
+def _args_base(**extra) -> argparse.Namespace:
+    base = {"consulta": None, "depurar": False, "auto": False,
+            "confirmar": True, "modelo": None, "test_loop": False,
+            "aider_opciones": "", "comando_test": "pytest"}
+    base.update(extra or {})
+    return argparse.Namespace(**base)
+
+
+class TestDeteccionDocker(unittest.TestCase):
+    """Detección de Docker: presencia, ausencia y daemon parado."""
+
+    def test_sin_binario_en_path_no_disponible(self):
+        with mock.patch.object(sc.shutil, "which", return_value=None):
+            self.assertFalse(sc._docker_disponible())
+
+    def test_docker_info_ok_disponible(self):
+        proc = mock.Mock(returncode=0)
+        with mock.patch.object(sc.shutil, "which", return_value="docker"), \
+                mock.patch.object(sc.subprocess, "run", return_value=proc):
+            self.assertTrue(sc._docker_disponible())
+
+    def test_docker_daemon_parado_no_disponible(self):
+        proc = mock.Mock(returncode=1)
+        with mock.patch.object(sc.shutil, "which", return_value="docker"), \
+                mock.patch.object(sc.subprocess, "run", return_value=proc):
+            self.assertFalse(sc._docker_disponible())
+
+    def test_error_al_llamar_docker_tolerado(self):
+        with mock.patch.object(sc.shutil, "which", return_value="docker"), \
+                mock.patch.object(sc.subprocess, "run",
+                                  side_effect=OSError("boom")):
+            self.assertFalse(sc._docker_disponible())
+
+
+class TestActivacionSandbox(unittest.TestCase):
+    def setUp(self):
+        sc._desactivar_sandbox()
+
+    def tearDown(self):
+        sc._desactivar_sandbox()
+
+    def test_activacion_estricta_falla_sin_docker(self):
+        with mock.patch.object(sc, "_docker_disponible", return_value=False):
+            with self.assertRaises(RuntimeError):
+                sc._activar_sandbox(estricto=True)
+        self.assertFalse(sc.sandbox_activo())
+
+    def test_activacion_no_estricta_avisa_y_continua(self):
+        with mock.patch.object(sc, "_docker_disponible", return_value=False), \
+                mock.patch.object(sc, "aviso") as fake_aviso:
+            self.assertFalse(sc._activar_sandbox(estricto=False))
+            fake_aviso.assert_called_once()
+        self.assertFalse(sc.sandbox_activo())
+
+    def test_activacion_con_docker(self):
+        with mock.patch.object(sc, "_docker_disponible", return_value=True):
+            self.assertTrue(sc._activar_sandbox(imagen="ubuntu:22.04",
+                                                comando_prep="apt update"))
+        self.assertTrue(sc.sandbox_activo())
+        self.assertEqual(sc._SANDBOX_IMAGEN, "ubuntu:22.04")
+        self.assertEqual(sc._SANDBOX_COMANDO_PREP, "apt update")
+
+    def test_imagen_por_variable_de_entorno(self):
+        env = {"SNAPCONTEXT_SANDBOX_IMAGE": "python:3.12"}
+        with mock.patch.dict(os.environ, env, clear=False):
+            self.assertEqual(sc._sandbox_imagen_resuelta(), "python:3.12")
+            # El flag explícito tiene prioridad sobre la variable.
+            self.assertEqual(sc._sandbox_imagen_resuelta("alpine"),
+                             "alpine")
+
+    def test_flag_cli_parseado(self):
+        args = sc.crear_parser().parse_args(
+            ["--sandbox", "--sandbox-imagen", "ubuntu:22.04",
+             "--sandbox-comando", "apt update", "consulta"])
+        self.assertTrue(args.sandbox)
+        self.assertEqual(args.sandbox_imagen, "ubuntu:22.04")
+        self.assertEqual(args.sandbox_comando, "apt update")
+        # Sin flags → False (compatibilidad).
+        args2 = sc.crear_parser().parse_args(["consulta"])
+        self.assertFalse(args2.sandbox)
+
+
+class TestEnvolverSandbox(unittest.TestCase):
+    def setUp(self):
+        sc._desactivar_sandbox()
+        self.dir_tmp = tempfile.mkdtemp()
+
+    def tearDown(self):
+        sc._desactivar_sandbox()
+
+    def test_sin_sandbox_devuelve_comando_intacto(self):
+        self.assertEqual(sc._envolver_sandbox("pytest", "."), "pytest")
+
+    def test_envuelve_con_mount_y_workdir(self):
+        sc._SANDBOX_ACTIVO = True
+        sc._SANDBOX_IMAGEN = "python:3.11-slim"
+        sc._SANDBOX_COMANDO_PREP = None
+        envuelto = sc._envolver_sandbox("pytest -q", self.dir_tmp)
+        self.assertIn("docker run --rm", envuelto)
+        self.assertIn("-w /workspace", envuelto)
+        self.assertIn("python:3.11-slim", envuelto)
+        self.assertIn("pytest -q", envuelto)
+
+    def test_comando_prep_antepuesto(self):
+        sc._SANDBOX_ACTIVO = True
+        sc._SANDBOX_IMAGEN = "python:3.11-slim"
+        sc._SANDBOX_COMANDO_PREP = "pip install pytest"
+        envuelto = sc._envolver_sandbox("pytest", self.dir_tmp)
+        self.assertIn("pip install pytest && (pytest)", envuelto)
+
+
+class TestEjecucionEnSandbox(unittest.TestCase):
+    def setUp(self):
+        sc._desactivar_sandbox()
+
+    def tearDown(self):
+        sc._desactivar_sandbox()
+
+    def _activar(self):
+        sc._SANDBOX_ACTIVO = True
+        sc._SANDBOX_IMAGEN = "python:3.11-slim"
+        sc._SANDBOX_COMANDO_PREP = None
+
+    def test_ejecutar_comando_usa_docker_run(self):
+        self._activar()
+        with mock.patch.object(sc.subprocess, "run") as fake_run:
+            fake_run.return_value = mock.Mock(returncode=0, stdout="hola",
+                                              stderr="")
+            codigo, stdout, _ = sc._ejecutar_comando("echo hola", ".")
+            self.assertEqual(codigo, 0)
+            self.assertIn("hola", stdout)
+            comando_lanzado = fake_run.call_args[0][0]
+            self.assertIn("docker run --rm", comando_lanzado)
+            self.assertIn("echo hola", comando_lanzado)
+
+    def test_ejecutar_comando_error_se_propaga_igual(self):
+        self._activar()
+        with mock.patch.object(sc.subprocess, "run") as fake_run:
+            fake_run.return_value = mock.Mock(returncode=5, stdout="",
+                                              stderr="boom")
+            codigo, _, stderr = sc._ejecutar_comando("exit 5", ".")
+        self.assertEqual(codigo, 5)
+        self.assertIn("boom", stderr)
+
+    def test_ejecutar_pruebas_argv_en_sandbox(self):
+        self._activar()
+        with mock.patch.object(sc.subprocess, "run") as fake_run:
+            fake_run.return_value = mock.Mock(returncode=0, stdout="", stderr="")
+            codigo, _, _ = sc._ejecutar_pruebas_argv(["pytest", "-q"], ".")
+            self.assertEqual(codigo, 0)
+            self.assertIn("pytest -q", fake_run.call_args[0][0])
+
+    def test_mcp_execute_command_en_sandbox(self):
+        self._activar()
+        with mock.patch.object(sc.subprocess, "run") as fake_run:
+            fake_run.return_value = mock.Mock(returncode=0, stdout="ok",
+                                              stderr="")
+            res = sc._tool_execute_command("echo ok", ".")
+            self.assertTrue(res["ok"])
+            self.assertIn("docker run --rm", fake_run.call_args[0][0])
+
+    def test_herramientas_lectura_no_usan_docker(self):
+        # grep es de solo lectura: no pasa por docker (usa su propia función).
+        self._activar()
+        tmp = tempfile.mkdtemp()
+        (Path(tmp) / "a.py").write_text("def hola():\n    pass\n",
+                                        encoding="utf-8")
+        with mock.patch.object(sc.subprocess, "run") as fake_run:
+            fake_run.return_value = mock.Mock(returncode=0, stdout="a.py:1:x",
+                                              stderr="")
+            res = sc._tool_grep("hola", tmp)
+            # Solo lectura → se ejecuta en el host, SIN envolver en docker.
+            lanzado = fake_run.call_args[0][0]
+            self.assertNotIn("docker", str(lanzado))
+        self.assertTrue(res["ok"])
+
+
+class TestIntegracionPlanYBucle(unittest.TestCase):
+    def setUp(self):
+        sc._desactivar_sandbox()
+        self.dir_tmp = tempfile.mkdtemp()
+        # Comando real no destructivo según plataforma.
+        self.comando = ("cmd /c echo hola"
+                        if os.name == "nt" else "echo hola")
+
+    def tearDown(self):
+        sc._desactivar_sandbox()
+
+    def _activar_mock_docker(self):
+        sc._SANDBOX_ACTIVO = True
+        sc._SANDBOX_IMAGEN = "python:3.11-slim"
+        sc._SANDBOX_COMANDO_PREP = None
+
+    def test_paso_plan_ejecutar_en_sandbox(self):
+        self._activar_mock_docker()
+        with mock.patch.object(sc, "_confirmar_accion", return_value=True), \
+                mock.patch.object(sc.subprocess, "run") as fake_run:
+            fake_run.return_value = mock.Mock(returncode=0, stdout="hola",
+                                              stderr="")
+            ok, detalle = sc._ejecutar_paso_plan(
+                {"accion": "ejecutar", "descripcion": "paso",
+                 "comando": self.comando},
+                _args_base(), self.dir_tmp)
+        self.assertTrue(ok)
+        self.assertIn("docker run --rm", fake_run.call_args[0][0])
+
+    def test_bucle_test_saltara_check_host_en_sandbox(self):
+        # Con sandbox activo NO se exige el binario en el PATH del host.
+        self._activar_mock_docker()
+        with mock.patch.object(sc.shutil, "which",
+                               return_value=None) as fake_which, \
+                mock.patch.object(sc, "ejecutar_aider"), \
+                mock.patch.object(sc, "_ejecutar_pruebas_argv",
+                                  return_value=(0, "ok", "")):
+            self.assertTrue(sc.ejecutar_bucle_test(
+                "tarea", ["a.py"], ".", "", ["binario-inexistente"], 1))
+            fake_which.assert_not_called()
+
+    def test_agente_tester_en_sandbox(self):
+        from agentes import AgenteTester
+        self._activar_mock_docker()
+        with mock.patch.object(sc.subprocess, "run") as fake_run:
+            fake_run.return_value = mock.Mock(returncode=0, stdout="", stderr="")
+            res = AgenteTester().ejecutar_pruebas(["pytest"], ".")
+            self.assertEqual(res.returncode, 0)
+            self.assertIn("docker run --rm", fake_run.call_args[0][0])
+
+
+if __name__ == "__main__":
+    unittest.main()
+

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_v010.py

@@ -168,7 +168,7 @@ class TestFlagsCLI(unittest.TestCase):
         self.assertTrue(args.vista_previa)
 
     def test_version_es_1_2_0(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 class TestComandosAgenteChat(unittest.TestCase):

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_validacion_130.py

@@ -126,7 +126,7 @@ class TestIniciarProyecto(unittest.TestCase):
 class TestVersion(unittest.TestCase):
     def test_version_130_coherente(self):
         import snapcontext as sc
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_vscode_016.py

@@ -91,7 +91,7 @@ class TestEstructuraVsCode(unittest.TestCase):
 
 class TestVersionCli(unittest.TestCase):
     def test_version_es_1_2_0(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 if __name__ == "__main__":

{snapcontext-4.2.0 → snapcontext-4.3.0}/tests/test_web_160.py

@@ -17,7 +17,7 @@ INDEX = RAIZ / "web" / "static" / "index.html"
 
 class TestVersion(unittest.TestCase):
     def test_version_160_coherente(self):
-        self.assertEqual(sc.VERSION, "4.2.0")
+        self.assertEqual(sc.VERSION, "4.3.0")
 
 
 class TestFrontendV160(unittest.TestCase):