higpertext-cli 0.8.0__py3-none-any.whl

higpertext/kernel/infrastructure/telemetry_reporter.py

@@ -0,0 +1,132 @@
+"""TelemetryReporter — dashboard de telemetría en terminal (Infraestructura)."""
+
+from __future__ import annotations
+from pathlib import Path
+
+from higpertext.kernel.app_config import (
+    TELEMETRY_BOX_WIDTH as _W,
+    TELEMETRY_BAR_WIDTH as _BAR_W,
+    TELEMETRY_EMPTY_TITLE,
+    TELEMETRY_EMPTY_LINES,
+    TELEMETRY_SECTION_LABELS as _LABELS,
+    TELEMETRY_ACTIVITY_ICONS as _ICONS,
+)
+from higpertext.kernel.application.telemetry import TelemetryAggregator
+from higpertext.kernel.infrastructure.logger import HtxLogger, get_logger, render_box
+
+
+def _box_row(text: str = "") -> str:
+    pad = _W - len(text) - 2
+    return f"║  {text}{' ' * pad}║"
+
+
+def _sep() -> str:
+    return "─" * (_W + 2)
+
+
+def render(
+    project_root: Path,
+    days: int = 7,
+    project_id: str | None = None,
+    *,
+    logger: HtxLogger | None = None,
+) -> str:
+    """Genera el dashboard de telemetría y lo emite vía logger.
+
+    Args:
+        project_root: Raíz del proyecto.
+        days:         Ventana de días a analizar.
+        project_id:   Filtro opcional de proyecto.
+        logger:       Instancia HtxLogger a usar. Si es None se obtiene el singleton.
+
+    Returns:
+        El string renderizado (compatibilidad con callers que capturan output).
+    """
+    log: HtxLogger = logger or get_logger(project_root)
+    agg = TelemetryAggregator(project_root, project_id=project_id)
+    m = agg.compute(days)
+
+    if not m:
+        block = render_box(
+            TELEMETRY_EMPTY_TITLE,
+            [_box_row(line) for line in TELEMETRY_EMPTY_LINES],
+        )
+        log.warning(block)
+        return block + "\n"
+
+    project_label = f"  ·  {project_id}" if project_id else ""
+    h = int(m["total_duration_min"] // 60)
+    mn = int(m["total_duration_min"] % 60)
+    duration_str = f"{h}h {mn}m" if h else f"{mn}m"
+
+    active_hint = f"  (activa: {m['sessions_active']})" if m["sessions_active"] else ""
+
+    corr = m["correlations"]
+    adoption = corr["higpertext_adoption_pct"]
+    adoption_bar = _bar(adoption, 100)
+    higpertext_calls = corr["higpertext_calls"]
+    higpertext_direct = corr.get("higpertext_direct_calls", 0)
+    bash_direct = corr["bash_direct_calls"]
+
+    rows = [
+        _box_row(),
+        _box_row(f"Sesiones        :  {m['sessions_total']}{active_hint}"),
+        _box_row(f"Tiempo total    :  {duration_str}"),
+        _box_row(f"Commits         :  {m['commits_total']}  (solicitudes resueltas)"),
+        _box_row(f"Tool calls      :  {m['tool_calls_total']}"),
+        _box_row(f"Tokens est.     :  {m['estimated_tokens']:,}"),
+        _box_row(f"Costo est.      :  ${m['estimated_cost_usd']:.4f} USD"),
+        _box_row(),
+        _box_row(_LABELS["correlations"]),
+        _box_row(_sep()[: _W - 2]),
+        _box_row(f"Tokens/sesión   :  {corr['tokens_per_session']:,}"),
+        _box_row(f"Costo/commit    :  ${corr['cost_per_commit_usd']:.4f} USD"),
+        _box_row(f"Commits/sesión  :  {corr['commits_per_session']}"),
+        _box_row(f"Adopción higpertext  :  {adoption_bar} {adoption}%"),
+        _box_row(
+            f"  intercepts+caps: {higpertext_calls - higpertext_direct}"
+            f"  ·  htx.py directo: {higpertext_direct}"
+            f"  ·  bash: {bash_direct}"
+        ),
+        _box_row(),
+    ]
+
+    if m["top_capabilities"]:
+        rows.append(_box_row(_LABELS["top_caps"]))
+        rows.append(_box_row(_sep()[: _W - 2]))
+        for i, (cap, count) in enumerate(m["top_capabilities"], 1):
+            rows.append(_box_row(f"  {i}. {cap:<30} ×{count}"))
+
+    if m.get("top_direct_tools"):
+        rows.append(_box_row(_LABELS["top_tools"]))
+        rows.append(_box_row(_sep()[: _W - 2]))
+        for i, (tool, count) in enumerate(m["top_direct_tools"], 1):
+            rows.append(_box_row(f"  {i}. {tool:<30} ×{count}"))
+
+    recent = m.get("recent_activity", [])
+    if recent:
+        rows += [_box_row(), _box_row(_LABELS["recent_activity"])]
+        rows.append(_box_row(_sep()[: _W - 2]))
+        for act in recent:
+            icon = _activity_icon(act["op_type"])
+            target = act["target"]
+            max_target = _W - 12
+            if len(target) > max_target:
+                target = "…" + target[-(max_target - 1):]
+            rows.append(_box_row(f"  {icon} {target}"))
+
+    rows.append(_box_row())
+
+    title = f"HIGPERTEXT TELEMETRY  ·  últimos {days} días{project_label}"
+    block = render_box(title, rows)
+    log.info(block)
+    return block + "\n"
+
+
+def _activity_icon(op_type: str) -> str:
+    return _ICONS.get(op_type, _ICONS["default"])
+
+
+def _bar(value: float, total: float) -> str:
+    filled = int(round(value / total * _BAR_W)) if total else 0
+    return "█" * filled + "░" * (_BAR_W - filled)

higpertext/kernel/infrastructure/validation/__init__.py

@@ -0,0 +1 @@
+# Infrastructure validation init

higpertext/kernel/infrastructure/validation/contract_validator.py

@@ -0,0 +1,163 @@
+"""Validador de contratos técnicos definidos en el JSON de cada capacidad (Infraestructura)."""
+
+from __future__ import annotations
+import re
+import json
+from pathlib import Path
+
+
+class ContractValidator:
+    """Validador de contratos técnicos definidos en el JSON de cada capacidad."""
+
+    @staticmethod
+    def validate(
+        params: dict,
+        stdout: str,
+        stderr: str,
+        returncode: int,
+        capability_data: dict,
+    ) -> tuple[bool, list[str]]:
+        errors = []
+        errors.extend(ContractValidator._validate_params(params, capability_data))
+
+        contract = capability_data.get("contract", {})
+        if not contract:
+            return len(errors) == 0, errors
+
+        errors.extend(
+            ContractValidator._validate_contract(stdout, stderr, params, capability_data, contract)
+        )
+        return len(errors) == 0, errors
+
+    @staticmethod
+    def _validate_params(params: dict, capability_data: dict) -> list[str]:
+        errors = []
+        for param_def in capability_data.get("parameters", []):
+            name = param_def.get("name")
+            if name is None:
+                continue
+
+            if param_def.get("required", False) and name not in params:
+                errors.append(f"El parámetro obligatorio '{name}' no fue provisto.")
+                continue
+
+            if name in params:
+                validator = ContractValidator._param_type_validators().get(
+                    param_def.get("type", "string").lower()
+                )
+                if validator:
+                    errors.extend(validator(name, params[name]))
+        return errors
+
+    @staticmethod
+    def _param_type_validators() -> dict[str, callable]:
+        return {
+            "integer": ContractValidator._validate_integer_param,
+            "boolean": ContractValidator._validate_boolean_param,
+            "array": ContractValidator._validate_array_param,
+        }
+
+    @staticmethod
+    def _validate_integer_param(name: str, value) -> list[str]:
+        try:
+            int(value)
+            return []
+        except (ValueError, TypeError):
+            return [
+                f"El parámetro '{name}' debe ser de tipo entero (recibido: '{value}')."
+            ]
+
+    @staticmethod
+    def _validate_boolean_param(name: str, value) -> list[str]:
+        if isinstance(value, bool) or str(value).lower() in (
+            "true",
+            "false",
+            "1",
+            "0",
+        ):
+            return []
+        return [
+            f"El parámetro '{name}' debe ser booleano (recibido: '{value}')."
+        ]
+
+    @staticmethod
+    def _validate_array_param(name: str, value) -> list[str]:
+        if isinstance(value, (list, tuple)) or isinstance(value, str):
+            return []
+        return [
+            f"El parámetro '{name}' debe ser de tipo array (recibido: '{value}')."
+        ]
+
+    @staticmethod
+    def _validate_contract(
+        stdout: str,
+        stderr: str,
+        params: dict,
+        capability_data: dict,
+        contract: dict,
+    ) -> list[str]:
+        errors = []
+        expected_format = contract.get("format", "").lower()
+
+        if expected_format == "json":
+            errors.extend(
+                ContractValidator._validate_json_output(stdout, contract.get("required_fields", []))
+            )
+
+        errors.extend(ContractValidator._validate_patterns(stdout, stderr, contract))
+        errors.extend(
+            ContractValidator._validate_expected_files(params, capability_data, contract.get("expected_files", []))
+        )
+
+        return errors
+
+    @staticmethod
+    def _validate_json_output(stdout: str, required_fields: list[str]) -> list[str]:
+        errors = []
+        try:
+            json_data = json.loads(stdout)
+            for field in required_fields:
+                if field not in json_data:
+                    errors.append(f"El output JSON no contiene el campo obligatorio: '{field}'")
+        except json.JSONDecodeError:
+            errors.append("El contrato exige formato JSON, pero el output no es JSON válido.")
+        return errors
+
+    @staticmethod
+    def _validate_patterns(stdout: str, stderr: str, contract: dict) -> list[str]:
+        errors = []
+        for pattern in contract.get("required_patterns", []):
+            if not re.search(pattern, stdout):
+                errors.append(f"El output no contiene el patrón requerido: '{pattern}'")
+
+        for pattern in contract.get("forbidden_patterns", []):
+            if re.search(pattern, stdout) or re.search(pattern, stderr):
+                errors.append(f"Se detectó un patrón prohibido en el output/stderr: '{pattern}'")
+        return errors
+
+    @staticmethod
+    def _validate_expected_files(
+        params: dict,
+        capability_data: dict,
+        file_templates: list[str],
+    ) -> list[str]:
+        errors = []
+        for file_template in file_templates:
+            try:
+                interpolated_path = file_template
+                for key, val in params.items():
+                    interpolated_path = interpolated_path.replace(f"{{{key}}}", str(val))
+                for param_def in capability_data.get("parameters", []):
+                    p_name = param_def.get("name")
+                    if p_name and f"{{{p_name}}}" in interpolated_path and "default" in param_def:
+                        interpolated_path = interpolated_path.replace(
+                            f"{{{p_name}}}", str(param_def["default"])
+                        )
+                target_file = Path(interpolated_path).resolve()
+                if not target_file.exists():
+                    errors.append(f"Archivo esperado no fue creado: '{interpolated_path}'")
+                elif target_file.stat().st_size == 0:
+                    errors.append(f"Archivo '{interpolated_path}' creado pero vacío (0 bytes).")
+            except OSError as e:
+                errors.append(f"Error validando archivo '{file_template}': {e}")
+        return errors

higpertext/kernel/pkg_resources.py

@@ -0,0 +1,38 @@
+"""Resolución de recursos empaquetados — fallback dev tree -> wheel instalado."""
+
+from __future__ import annotations
+from pathlib import Path
+
+
+def pkg_data_root() -> Path | None:
+    """Raíz de higpertext_data (perfiles, capabilities json, templates, hooks_catalog)."""
+    try:
+        import higpertext_data
+
+        return Path(higpertext_data.__path__[0]).resolve()
+    except (ImportError, AttributeError, IndexError):
+        return None
+
+
+def installed_src_root() -> Path | None:
+    """Raíz equivalente a src/ vía el paquete higpertext instalado (módulos .py reales)."""
+    try:
+        import higpertext
+
+        return Path(higpertext.__path__[0]).resolve().parent
+    except (ImportError, AttributeError, IndexError):
+        return None
+
+
+def resolve_resource(base_dir: Path, *rel_parts: str) -> Path:
+    """base_dir/rel_parts si existe; si no, cae a pkg_data_root()/rel_parts[1:]
+    cuando rel_parts[0] == 'src'."""
+    dev_path = base_dir.joinpath(*rel_parts)
+    if dev_path.exists():
+        return dev_path
+    pkg_root = pkg_data_root()
+    if pkg_root is not None and rel_parts and rel_parts[0] == "src":
+        pkg_path = pkg_root.joinpath(*rel_parts[1:])
+        if pkg_path.exists():
+            return pkg_path
+    return dev_path

higpertext/kernel/session_manager.py

@@ -0,0 +1,319 @@
+"""higpertext Session Manager — fachada del ciclo de vida de sesiones temporales.
+
+Delega en:
+- SessionContextBuilder  (resolución de skills/subagentes)
+- ResourceDeployer       (despliegue y restauración de recursos)
+- MarkdownRenderer       (generación de Markdown — via ResourceDeployer)
+"""
+
+from __future__ import annotations
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+
+import datetime
+import json
+import os
+import secrets
+import shutil
+from pathlib import Path
+
+from higpertext.kernel.infrastructure.presentation.markdown_renderer import (
+    MarkdownRenderer,
+)
+from higpertext.kernel.infrastructure.deployment.resource_deployer import (
+    ResourceDeployer,
+)
+from higpertext.kernel.application.context_builder import SessionContextBuilder
+from higpertext.kernel.infrastructure.logger import get_logger
+from higpertext.kernel.app_config import (
+    DEFAULT_ASSISTANT as _DEFAULT_ASSISTANT,
+    DEFAULT_PROFILE as _DEFAULT_PROFILE,
+    ASSISTANT_PATHS as _ASSISTANT_PATHS,
+)
+
+_log = get_logger()
+
+
+class SessionManager:
+    """Fachada: orquesta el ciclo de vida completo de una sesión temporal."""
+
+    def __init__(self, project_root: Path, root_dir: Path) -> None:
+        self.project_root = project_root
+        self.root_dir = root_dir
+        self.session_file = project_root / WORKSPACE_DIR_NAME / "state" / "session.json"
+        self.env_file = project_root / WORKSPACE_DIR_NAME / "config" / "environment.json"
+        self.session_file.parent.mkdir(parents=True, exist_ok=True)
+        self.env_file.parent.mkdir(parents=True, exist_ok=True)
+        self._context_builder = SessionContextBuilder(project_root, root_dir)
+        self._deployer = ResourceDeployer(project_root, root_dir)
+
+    # --- Environment helpers ---
+
+    def get_assistant_and_profile(self) -> tuple[str, str]:
+        if not self.env_file.exists():
+            return _DEFAULT_ASSISTANT, _DEFAULT_PROFILE
+        try:
+            data = json.loads(self.env_file.read_text(encoding="utf-8"))
+            return (
+                data.get("assistant", _DEFAULT_ASSISTANT),
+                data.get("active_profile", _DEFAULT_PROFILE),
+            )
+        except (OSError, json.JSONDecodeError):
+            return _DEFAULT_ASSISTANT, _DEFAULT_PROFILE
+
+    def get_model(self, assistant: str) -> str | None:
+        try:
+            if self.env_file.exists():
+                data = json.loads(self.env_file.read_text(encoding="utf-8"))
+                model = data.get("llm", {}).get("assistants", {}).get(assistant, {}).get("model")
+                if model:
+                    return model
+            return None
+        except (OSError, json.JSONDecodeError):
+            return None
+
+    def get_paths(self, assistant: str) -> tuple[Path, Path, Path]:
+        wf, sk, sa = _ASSISTANT_PATHS.get(assistant, _ASSISTANT_PATHS[_DEFAULT_ASSISTANT])
+        root = self.project_root
+        return root / wf, root / sk, root / sa
+
+    def get_agent_system_dir(self) -> Path:
+        env_path = os.getenv("AGENT_SYSTEM_PATH")
+        if env_path and Path(env_path).exists():
+            return Path(env_path).resolve()
+        candidate = self.root_dir.parent.parent / "app" / "APP_Scripts_PowerShell" / "AgentSystem"
+        return candidate if candidate.exists() else self.root_dir
+
+    # --- Session lifecycle ---
+
+    def start_session(
+        self,
+        profile_name: str,
+        assistant: str,
+        skills: list | None = None,
+        subagents: list | None = None,
+    ) -> dict:
+        self.clean_session()
+        skills, subagents = self._context_builder.resolve_resources(profile_name, skills, subagents)
+
+        session_id = f"sess_{int(datetime.datetime.now().timestamp())}_{secrets.token_hex(2)}"
+        session_data = {
+            "session_id": session_id,
+            "profile": profile_name,
+            "assistant": assistant,
+            "status": "active",
+            "created_at": datetime.datetime.now().isoformat(),
+            "active_skills": skills,
+            "active_subagents": subagents,
+            "tasks": [],
+        }
+        self.session_file.parent.mkdir(parents=True, exist_ok=True)
+        self.session_file.write_text(
+            json.dumps(session_data, indent=4, ensure_ascii=False), encoding="utf-8"
+        )
+
+        wf_dest, sk_dest, sa_dest = self.get_paths(assistant)
+        self._run_adapter_hook(assistant, "on_session_start", profile_name)
+        self._deployer.deploy_skills(skills, sk_dest)
+        skills_str, beans_str = self._deployer.build_resource_links(
+            skills, subagents, sk_dest, sa_dest
+        )
+        self._deployer.deploy_subagents(subagents, sa_dest, skills_str)
+        self._deployer.deploy_playbooks(
+            wf_dest,
+            skills_str,
+            beans_str,
+            session_id,
+            assistant,
+            get_model_fn=self.get_model,
+            get_profile_fn=self._load_active_profile_data,
+        )
+        # Mirror gemini resources to .agents/ (antigravity deprecated, same flow)
+        if assistant == "gemini":
+            self._mirror_gemini_to_agents(self.project_root)
+        self._refresh_semantic_graph()
+        _log.ok(f"[SUCCESS] Sesión temporal '{session_id}' iniciada.")
+        return session_data
+
+    def _mirror_gemini_to_agents(self, project_root: Path) -> None:
+        import shutil as _shutil
+
+        mapping = {"skills": "skills", "agents": "agents", "workflows": "workflows"}
+        for src_sub, dst_sub in mapping.items():
+            src = project_root / ".gemini" / src_sub
+            dst = project_root / ".agents" / dst_sub
+            if not src.exists():
+                continue
+            dst.mkdir(parents=True, exist_ok=True)
+            for item in src.iterdir():
+                if item.is_file():
+                    _shutil.copy2(item, dst / item.name)
+                elif item.is_dir():
+                    _shutil.copytree(item, dst / item.name, dirs_exist_ok=True)
+
+    def clean_session(self) -> bool:
+        assistant = self._read_session_assistant()
+        wf_dest, sk_dest, sa_dest = self.get_paths(assistant)
+
+        for d in (sk_dest, sa_dest):
+            if d.exists():
+                try:
+                    shutil.rmtree(d)
+                except OSError:  # nosec B110
+                    pass
+
+        if assistant == "gemini":
+            for sub in ("skills", "agents", "workflows"):
+                d = self.project_root / ".agents" / sub
+                if d.exists():
+                    try:
+                        shutil.rmtree(d)
+                    except OSError:  # nosec B110
+                        pass
+
+        # Limpiar cache de capabilities
+        cache_dir = self.project_root / WORKSPACE_DIR_NAME / "__cache__"
+        if cache_dir.exists():
+            for f in cache_dir.glob("*.json"):
+                try:
+                    f.unlink()
+                except OSError:  # nosec B110
+                    pass
+
+        self._run_adapter_hook(assistant, "on_session_clean")
+        self._deployer.restore_playbooks(
+            wf_dest,
+            assistant,
+            get_model_fn=self.get_model,
+            get_profile_fn=self._load_active_profile_data,
+        )
+
+        from higpertext.kernel.infrastructure.file_repositories import (
+            FileSessionRepository,
+        )
+        from higpertext.kernel.application.session_services import (
+            SessionApplicationService,
+        )
+        from higpertext.kernel.infrastructure.file_repositories import (
+            FileProfileRepository,
+        )
+
+        # Generar reporte de telemetría de forma automática antes de borrar recursos
+        try:
+            from higpertext.kernel.infrastructure.telemetry_reporter import render as render_telemetry
+            from higpertext.kernel.infrastructure import OutputStore
+
+            report_content = render_telemetry(self.project_root, days=7)
+            OutputStore(self.project_root).write(
+                "common.telemetry-report", report_content, fmt="txt"
+            )
+
+            # Generar el Diario de Decisiones
+            from higpertext.capabilities.common.scripts.commit_rationale_log import (
+                main as run_rationale_log,
+            )
+
+            try:
+                import sys as _sys
+
+                _orig = _sys.argv
+                _sys.argv = [_sys.argv[0]]
+                run_rationale_log()
+                _sys.argv = _orig
+            except Exception:  # nosec B110
+                pass
+
+            # Generar el Análisis de Desviación Arquitectónica
+            from higpertext.capabilities.common.scripts.architecture_drift_report import (
+                main as run_drift_report,
+            )
+
+            try:
+                _sys.argv = [_sys.argv[0]]
+                run_drift_report()
+            except Exception:  # nosec B110
+                pass
+            finally:
+                _sys.argv = _orig
+
+            from higpertext.capabilities.common.scripts.report_viewer import (
+                main as run_report_viewer,
+            )
+
+            try:
+                _sys.argv = [_sys.argv[0]]
+                run_report_viewer()
+            except Exception:  # nosec B110
+                pass
+            finally:
+                _sys.argv = _orig
+        except Exception as e:  # nosec B110
+            pass
+
+        session_repo = FileSessionRepository(self.session_file)
+        profile_repo = FileProfileRepository(self.project_root / "src" / "config" / "profiles")
+        session_service = SessionApplicationService(session_repo, profile_repo)
+        session_service.clean_session()
+
+        _log.ok("[SUCCESS] Sesión temporal y recursos limpiados exitosamente.")
+        return True
+
+    # --- Private helpers ---
+
+    def _read_session_assistant(self) -> str:
+        if self.session_file.exists():
+            try:
+                data = json.loads(self.session_file.read_text(encoding="utf-8"))
+                return data.get("assistant", _DEFAULT_ASSISTANT)
+            except (OSError, json.JSONDecodeError):  # nosec B110
+                pass
+        assistant, _ = self.get_assistant_and_profile()
+        return assistant
+
+    def _refresh_semantic_graph(self) -> None:
+        try:
+            from higpertext.kernel.infrastructure.parser.semantic_graph import (
+                SemanticGraphGenerator,
+            )
+
+            _log.info("[*] Actualizando grafo semántico del proyecto...")
+            SemanticGraphGenerator.generate(self.project_root)
+            _log.ok("[SUCCESS] Grafo semántico actualizado.")
+        except (ImportError, OSError) as e:
+            _log.warning(f"[WARNING] No se pudo actualizar el grafo semántico: {e}")
+
+    def _load_active_profile_data(self):
+        try:
+            _, active_profile = self.get_assistant_and_profile()
+            from higpertext.kernel.engine import HigpertextEngine
+
+            engine = HigpertextEngine(self.root_dir)
+            return engine.profiles.load_profile(active_profile)
+        except Exception:
+            return None
+
+    def _run_adapter_hook(self, assistant: str, hook_name: str, profile_name: str = "") -> None:
+        try:
+            import sys
+
+            if str(self.root_dir) not in sys.path:
+                sys.path.append(str(self.root_dir))
+            from higpertext.adapters.adapter_utils import get_adapter_class
+
+            adapter_cls = get_adapter_class(assistant)
+            if not (adapter_cls and hasattr(adapter_cls, hook_name)):
+                return
+            if hook_name == "on_session_start" and profile_name:
+                from higpertext.kernel.engine import HigpertextEngine
+
+                engine = HigpertextEngine(self.root_dir)
+                context = engine.get_agent_context(profile_name)
+                if context:
+                    getattr(adapter_cls, hook_name)(context, self.project_root)
+            else:
+                getattr(adapter_cls, hook_name)(self.project_root)
+        except Exception as e:
+            _log.warning(f"[!] Error ejecutando {hook_name} para '{assistant}': {e}")
+
+    @classmethod
+    def _generate_workflow_base_md(cls, data, assistant="gemini", profile_model=None):
+        return MarkdownRenderer.generate_workflow_base_md(data, assistant, profile_model)

higpertext/templates/env/generic-shell.yaml

@@ -0,0 +1,21 @@
+id: generic-shell
+description: Alpine shell runner for simple local commands
+services:
+  app:
+    image: alpine:3.20
+    working_dir: /workspace
+    volumes:
+      - .:/workspace
+    command: sleep infinity
+tasks:
+  echo:
+    service: app
+    command: echo higpertext-env-ready
+defaults:
+  service: app
+  task: echo
+  timeout_seconds: 120
+  cleanup: true
+security:
+  network: isolated
+  privileged: false