higpertext-cli 0.8.0__py3-none-any.whl

higpertext/kernel/application/skill_hook_compiler.py

@@ -0,0 +1,85 @@
+"""SkillHookCompiler — lee el perfil activo y registra sus hook tasks en hooks_config.json."""
+
+from __future__ import annotations
+import json
+from pathlib import Path
+
+from higpertext.kernel.infrastructure.hook_config_loader import (
+    load_hooks_config,
+    load_hook_definitions,
+    save_hooks_config,
+)
+from higpertext.kernel.infrastructure.logger import get_logger
+
+_log = get_logger()
+
+
+class SkillHookCompiler:
+    """Sincroniza los hook IDs activos en hooks_config.json según el perfil."""
+
+    def __init__(self, project_root: Path) -> None:
+        self.project_root = project_root
+        from higpertext.kernel.config_paths import CAPABILITIES_DIR
+
+        self._caps_root = project_root / "src" / "higpertext" / "capabilities"
+        if not self._caps_root.exists():
+            # Fallback to قدیمی/legacy or other folder, or global dir if project
+            # specific doesn't exist
+            legacy_caps = project_root / "src" / "capabilities"
+            if legacy_caps.exists():
+                self._caps_root = legacy_caps
+            else:
+                self._caps_root = CAPABILITIES_DIR
+
+    # Perfiles que activan evaluación de calidad de código
+    _QUALITY_PROFILES: frozenset[str] = frozenset({"software_developer", "devsecops", "ado_admin"})
+
+    def compile(self, profile_name: str, capabilities: list[str]) -> None:
+        # Hooks consolidados base — activos en todos los perfiles
+        hook_ids: list[str] = [
+            "hook_bash_guard",  # todas las reglas Bash en cadena
+            "hook_post_observer",  # telemetría + aviso de output masivo
+            "hook_session_prompt",  # auto-start + estado de sesión + skills
+            "hook_session_stop",  # cierre de turno y verificación de commits
+            "hook_context_manager",  # preserva estado higpertext antes de compresión
+            "hook_read_guard",  # evita lecturas completas de archivos grandes
+            "hook_security_guard_pre",  # bloquea comandos/rutas sensibles
+            "hook_security_guard_post",  # enmascara secretos en outputs
+        ]
+        if profile_name in self._QUALITY_PROFILES:
+            hook_ids.append("hook_code_quality")
+        for cap_id in capabilities:
+            hook_id = self._resolve_hook_id(cap_id)
+            if hook_id and hook_id not in hook_ids:
+                hook_ids.append(hook_id)
+
+        config = load_hooks_config(self.project_root)
+
+        # Siempre sincroniza las definiciones desde el catálogo canónico del engine
+        # (.higpertext/hooks_config.json) para que los proyectos destino reflejen
+        # cualquier actualización (nuevos hooks, cambios de matcher, etc.).
+        from higpertext.kernel.config_paths import PROJECT_ROOT as ENGINE_ROOT
+
+        definitions = load_hook_definitions(ENGINE_ROOT)
+        if definitions:
+            config["hooks"] = definitions
+
+        config.setdefault("profile_hooks", {})[profile_name] = hook_ids
+        save_hooks_config(self.project_root, config)
+        _log.info(
+            f"SkillHookCompiler: {len(hook_ids)} hooks compilados para perfil '{profile_name}'"
+        )
+
+    def _resolve_hook_id(self, cap_id: str) -> str | None:
+        """Lee hook_task_id del JSON de la capability; devuelve None si no existe."""
+        namespace, _, name = cap_id.partition(".")
+        if not name:
+            return None
+        cap_file = self._caps_root / namespace / f"{name}.json"
+        if not cap_file.exists():
+            return None
+        try:
+            data = json.loads(cap_file.read_text(encoding="utf-8"))
+            return data.get("hook_task_id") or None
+        except (OSError, json.JSONDecodeError):
+            return None

higpertext/kernel/application/telemetry.py

@@ -0,0 +1,326 @@
+"""Telemetry Application layer — TelemetryCollector and TelemetryAggregator."""
+
+from __future__ import annotations
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+from higpertext.kernel.app_config import TELEMETRY_FILE as _STORE_FILENAME
+
+import json
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+from typing import Any
+from collections import Counter
+
+
+class TelemetryCollector:
+    """Escribe eventos de telemetría de forma atómica al store JSONL."""
+
+    def __init__(self, project_root: Path, project_id: str | None = None) -> None:
+        self._store = project_root / WORKSPACE_DIR_NAME / "state" / _STORE_FILENAME
+        self._project_id = project_id or _resolve_project_id(project_root)
+
+    def record(self, event: str, **fields: Any) -> None:
+        """Registra un evento con timestamp UTC y project_id. Silencia errores de I/O."""
+        entry = {"ts": _now(), "event": event, "project_id": self._project_id, **fields}
+        try:
+            with self._store.open("a", encoding="utf-8") as fh:
+                fh.write(json.dumps(entry, ensure_ascii=False) + "\n")
+        except OSError:  # nosec B110
+            pass
+
+    def session_start(self, session_id: str, profile: str) -> None:
+        self.record("session_start", session_id=session_id, profile=profile)
+
+    def session_stop(self, session_id: str, profile: str, duration_min: float) -> None:
+        self.record(
+            "session_stop",
+            session_id=session_id,
+            profile=profile,
+            duration_min=round(duration_min, 2),
+        )
+
+    def commit(
+        self,
+        session_id: str,
+        commit_hash: str,
+        commit_type: str,
+        scope: str,
+        profile: str,
+    ) -> None:
+        self.record(
+            "commit",
+            session_id=session_id,
+            hash=commit_hash,
+            type=commit_type,
+            scope=scope,
+            profile=profile,
+        )
+
+    def capability_used(self, session_id: str, capability_id: str) -> None:
+        self.record("capability_used", session_id=session_id, capability=capability_id)
+
+    def hook_intercept(self, session_id: str, capability_id: str, command_fragment: str) -> None:
+        """Registra cuando el enforcer redirige un comando bash a una capacidad."""
+        self.record(
+            "hook_intercept",
+            session_id=session_id,
+            capability=capability_id,
+            fragment=command_fragment[:80],
+        )
+
+    def hook_passthrough(self, session_id: str, command_fragment: str) -> None:
+        """Registra cuando el enforcer deja pasar un comando sin redirigir."""
+        self.record(
+            "hook_passthrough",
+            session_id=session_id,
+            fragment=command_fragment[:80],
+        )
+
+    def tool_call(
+        self,
+        session_id: str,
+        tool_name: str,
+        input_chars: int,
+        output_chars: int,
+    ) -> None:
+        """Registra una tool call con estimación de tokens por conteo de chars."""
+        input_tokens = input_chars // 4
+        output_tokens = output_chars // 4
+        cache_read_tokens = int(input_tokens * 0.80)
+        cache_write_tokens = int(input_tokens * 0.20)
+        estimated_tokens = input_tokens + output_tokens
+        estimated_cost_usd = (
+            cache_read_tokens * 0.30 / 1_000_000
+            + cache_write_tokens * 3.75 / 1_000_000
+            + output_tokens * 15.0 / 1_000_000
+        )
+        self.record(
+            "tool_call",
+            session_id=session_id,
+            tool=tool_name,
+            input_chars=input_chars,
+            output_chars=output_chars,
+            estimated_tokens=estimated_tokens,
+            estimated_cost_usd=round(estimated_cost_usd, 6),
+        )
+
+
+class TelemetryAggregator:
+    """Calcula métricas agregadas y correlaciones desde el store JSONL."""
+
+    def __init__(self, project_root: Path, project_id: str | None = None) -> None:
+        self._store = project_root / WORKSPACE_DIR_NAME / "state" / _STORE_FILENAME
+        self._project_id = project_id
+
+    def load(self, days: int = 7) -> list[dict]:
+        """Carga eventos de los últimos N días, filtrando por project_id si se especificó."""
+        if not self._store.exists():
+            return []
+        cutoff = datetime.now(timezone.utc) - timedelta(days=days)
+        events: list[dict] = []
+        for line in self._store.read_text(encoding="utf-8").splitlines():
+            if not line.strip():
+                continue
+            try:
+                e = json.loads(line)
+                ts = datetime.fromisoformat(e.get("ts", ""))
+                if ts < cutoff:
+                    continue
+                if self._project_id and e.get("project_id") and e["project_id"] != self._project_id:
+                    continue
+                events.append(e)
+            except (json.JSONDecodeError, ValueError):
+                continue
+        return events
+
+    def projects(self) -> list[str]:
+        """Retorna todos los project_id únicos presentes en el store."""
+        if not self._store.exists():
+            return []
+        ids: set[str] = set()
+        for line in self._store.read_text(encoding="utf-8").splitlines():
+            if not line.strip():
+                continue
+            try:
+                e = json.loads(line)
+                pid = e.get("project_id")
+                if pid:
+                    ids.add(pid)
+            except json.JSONDecodeError:
+                continue
+        return sorted(ids)
+
+    def compute_activity(self, days: int = 1, limit: int = 20) -> list[dict]:
+        """Retorna las últimas `limit` actividades ordenadas por timestamp desc."""
+        events = self.load(days)
+        activities = []
+
+        for e in events:
+            ev = e.get("event", "")
+            if ev == "activity":
+                activities.append(
+                    {
+                        "ts": e.get("ts", ""),
+                        "tool": e.get("tool", ""),
+                        "op_type": e.get("op_type", ""),
+                        "target": e.get("target", ""),
+                        "scope": e.get("scope", ""),
+                        "higpertext_related": e.get("higpertext_related", False),
+                        "session_id": e.get("session_id", ""),
+                    }
+                )
+            elif ev == "commit":
+                activities.append(
+                    {
+                        "ts": e.get("ts", ""),
+                        "tool": "Commit",
+                        "op_type": "commit",
+                        "target": f"{e.get('type', '?')}({e.get('scope', '')}):"
+                        f" {e.get('hash', '')}",
+                        "scope": "git",
+                        "higpertext_related": True,
+                        "session_id": e.get("session_id", ""),
+                    }
+                )
+            elif ev == "hook_intercept" and e.get("capability") != "BLOCKED":
+                activities.append(
+                    {
+                        "ts": e.get("ts", ""),
+                        "tool": "higpertext",
+                        "op_type": "higpertext-task",
+                        "target": e.get("capability", ""),
+                        "scope": "higpertext",
+                        "higpertext_related": True,
+                        "session_id": e.get("session_id", ""),
+                    }
+                )
+
+        activities.sort(key=lambda x: x["ts"], reverse=True)
+        return activities[:limit]
+
+    def compute(self, days: int = 7) -> dict[str, Any]:
+        events = self.load(days)
+        if not events:
+            return {}
+
+        sessions: dict[str, dict] = {}
+        commits: list[dict] = []
+        capabilities: Counter = Counter()
+        intercepts: Counter = Counter()
+        tool_calls_total = 0
+        higpertext_direct_calls = 0
+        tool_calls_by_name: Counter = Counter()
+        estimated_tokens = 0
+        estimated_cost = 0.0
+
+        for e in events:
+            ev = e.get("event", "")
+            sid = e.get("session_id", "unknown")
+
+            if ev == "session_start":
+                sessions.setdefault(sid, {})["start_ts"] = e.get("ts")
+                sessions[sid]["profile"] = e.get("profile", "")
+
+            elif ev == "session_stop":
+                sessions.setdefault(sid, {})["stop_ts"] = e.get("ts")
+                sessions[sid]["duration_min"] = e.get("duration_min", 0)
+
+            elif ev == "commit":
+                commits.append(e)
+
+            elif ev == "capability_used":
+                capabilities[e.get("capability", "unknown")] += 1
+
+            elif ev == "hook_intercept":
+                cap = e.get("capability", "unknown")
+                if cap != "BLOCKED":
+                    intercepts[cap] += 1
+
+            elif ev == "tool_call":
+                tool_calls_total += 1
+                tool_calls_by_name[e.get("tool", "unknown")] += 1
+                estimated_tokens += e.get("estimated_tokens", 0)
+                estimated_cost += e.get("estimated_cost_usd", 0.0)
+                if e.get("is_higpertext_call"):
+                    higpertext_direct_calls += 1
+
+        active_sessions = sum(1 for s in sessions.values() if "stop_ts" not in s)
+        total_duration_min = sum(s.get("duration_min", 0) for s in sessions.values())
+
+        tokens_per_session = estimated_tokens // len(sessions) if sessions else 0
+        cost_per_commit = round(estimated_cost / len(commits), 4) if commits else 0.0
+        commits_per_session = round(len(commits) / len(sessions), 2) if sessions else 0.0
+
+        total_intercepts = sum(intercepts.values())
+        total_capability_used = sum(capabilities.values())
+        higpertext_calls = total_intercepts + total_capability_used + higpertext_direct_calls
+        bash_direct = tool_calls_total - higpertext_direct_calls
+        higpertext_adoption_pct = (
+            round(higpertext_calls / (higpertext_calls + bash_direct) * 100, 1)
+            if (higpertext_calls + bash_direct) > 0
+            else 0.0
+        )
+
+        all_caps: Counter = Counter()
+        all_caps.update(capabilities)
+        all_caps.update(intercepts)
+        top_capabilities = all_caps.most_common(5)
+
+        return {
+            "period_days": days,
+            "sessions_total": len(sessions),
+            "sessions_active": active_sessions,
+            "total_duration_min": round(total_duration_min, 1),
+            "commits_total": len(commits),
+            "tool_calls_total": tool_calls_total,
+            "estimated_tokens": estimated_tokens,
+            "estimated_cost_usd": round(estimated_cost, 4),
+            "correlations": {
+                "tokens_per_session": tokens_per_session,
+                "cost_per_commit_usd": cost_per_commit,
+                "commits_per_session": commits_per_session,
+                "higpertext_adoption_pct": higpertext_adoption_pct,
+                "higpertext_calls": higpertext_calls,
+                "higpertext_direct_calls": higpertext_direct_calls,
+                "bash_direct_calls": bash_direct,
+            },
+            "top_capabilities": top_capabilities,
+            "top_direct_tools": tool_calls_by_name.most_common(5),
+            "commits": commits,
+            "recent_activity": self.compute_activity(days, limit=12),
+        }
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+def get_collector(project_root: Path | None = None) -> TelemetryCollector:
+    """Factory que resuelve la raíz del proyecto si no se provee."""
+    if project_root is None:
+        project_root = _resolve_root()
+    return TelemetryCollector(project_root)
+
+
+def _resolve_root() -> Path:
+    candidate = Path(__file__).resolve().parent
+    for _ in range(8):
+        if (candidate / "src/config/htx_config.json").exists():
+            return candidate
+        candidate = candidate.parent
+    _fallback = Path("/home/aomerge/Documentos/Proyects/agents/LLM-agent")
+    if (_fallback / "src/config/htx_config.json").exists():
+        return _fallback
+    return Path.cwd()
+
+
+def _resolve_project_id(project_root: Path) -> str:
+    env_file = project_root / WORKSPACE_DIR_NAME / "config" / "environment.json"
+    try:
+        data = json.loads(env_file.read_text(encoding="utf-8"))
+        return (
+            data.get("variables", {}).get("repository_id")
+            or data.get("project_name")
+            or project_root.name
+        )
+    except (OSError, json.JSONDecodeError):
+        return project_root.name

higpertext/kernel/application/workflow_manager.py

@@ -0,0 +1,176 @@
+"""higpertext Workflow Manager — compila workflows YAML al esquema interno JSON
+y los gestiona (Aplicación)."""
+
+import os
+import json
+from pathlib import Path
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+
+from higpertext.kernel.infrastructure.logger import get_logger
+
+_log = get_logger()
+
+try:
+    import yaml
+    HAS_YAML = True
+except ImportError:
+    HAS_YAML = False
+
+
+class WorkflowManager:
+    def __init__(self, workflows_dir: Path):
+        self.workflows_dir = workflows_dir
+        self.workflows_dir.mkdir(parents=True, exist_ok=True)
+
+    def _get_custom_workflows_dir(self) -> Path:
+        """Obtiene la ruta del directorio de flujos personalizados del proyecto actual
+        (.higpertext/workflows)."""
+        project_root = Path(os.getcwd()).resolve()
+        return project_root / WORKSPACE_DIR_NAME / "workflows"
+
+    def _write_inline_capabilities(self, capabilities_data: list) -> None:
+        """Registra capacidades inline definidas en el YAML
+        en .higpertext/capabilities/ y scripts/."""
+        project_root = Path(os.getcwd()).resolve()
+        caps_dir = project_root / WORKSPACE_DIR_NAME / "capabilities"
+        scripts_dir = project_root / WORKSPACE_DIR_NAME / "scripts"
+        caps_dir.mkdir(parents=True, exist_ok=True)
+        scripts_dir.mkdir(parents=True, exist_ok=True)
+
+        for c_def in capabilities_data:
+            if not isinstance(c_def, dict) or "id" not in c_def:
+                continue
+            c_id = c_def["id"]
+            c_lang = c_def.get("language", "bash")
+            ext = ".py" if c_lang == "python" else ".ps1" if c_lang == "powershell" else ".sh"
+            script_path = scripts_dir / f"{c_id}{ext}"
+            script_path.write_text(c_def.get("script", ""), encoding="utf-8")
+            try:
+                script_path.chmod(0o755)
+            except OSError:  # nosec B110
+                pass
+            cap_json = {
+                "id": c_id,
+                "name": c_def.get("name", c_id),
+                "description": c_def.get("description", "Capacidad inline personalizada"),
+                "language": c_lang,
+                "entrypoint": str(script_path.resolve()),
+                "is_custom": True,
+                "parameters": c_def.get("parameters", []),
+            }
+            (caps_dir / f"{c_id}.json").write_text(
+                json.dumps(cap_json, indent=4, ensure_ascii=False), encoding="utf-8"
+            )
+
+    def _extract_steps(self, data: dict) -> list:
+        """Extrae la lista de pasos desde 'steps' o desde 'jobs[].steps'."""
+        if "steps" in data and isinstance(data["steps"], list):
+            return data["steps"]
+        raw: list = []
+        for job in data.get("jobs", []):
+            if isinstance(job, dict):
+                raw.extend(job.get("steps", []))
+        return raw
+
+    def _build_chain(self, raw_steps: list) -> list:
+        """Convierte la lista de pasos raw al formato de execution_chain interno."""
+        chain = []
+        for idx, st in enumerate(raw_steps, 1):
+            if not isinstance(st, dict) or not st.get("task"):
+                continue
+            chain.append(
+                {
+                    "step": idx,
+                    "task": st["task"],
+                    "params": st.get("inputs", st.get("params", {})),
+                    "on_failure": st.get(
+                        "on_failure",
+                        "continue" if st.get("continueOnError") else "abort",
+                    ),
+                    "retries": int(st.get("retries", 0)),
+                    "retry_delay": int(st.get("retry_delay", st.get("retryDelay", 5))),
+                }
+            )
+        return chain
+
+    def compile_yaml_workflow(self, yaml_file: Path) -> dict | None:
+        """Lee y compila un archivo YAML estilo CI/CD al esquema interno JSON de higpertext."""
+        if not HAS_YAML:
+            _log.warning(f"[Warning] No se pudo compilar '{yaml_file.name}': PyYAML no instalado.")
+            return None
+        try:
+            data = yaml.safe_load(yaml_file.read_text(encoding="utf-8"))
+            if not isinstance(data, dict):
+                return None
+
+            wf_id = data.get("id", data.get("name", yaml_file.stem))
+            wf_json = {
+                "id": wf_id,
+                "name": data.get("displayName", data.get("name", wf_id)),
+                "description": data.get("description", "Flujo personalizado del proyecto"),
+                "version": data.get("version", "1.0.0"),
+                "required_profile": data.get("required_profile", "any"),
+                "parameters": data.get("parameters", []),
+                "execution_chain": self._build_chain(self._extract_steps(data)),
+            }
+
+            if isinstance(data.get("capabilities"), list):
+                self._write_inline_capabilities(data["capabilities"])
+
+            compiled_dir = yaml_file.parent / "compiled"
+            compiled_dir.mkdir(parents=True, exist_ok=True)
+            (compiled_dir / f"{wf_id}.json").write_text(
+                json.dumps(wf_json, indent=4, ensure_ascii=False), encoding="utf-8"
+            )
+            return wf_json
+        except (OSError, json.JSONDecodeError, yaml.YAMLError) as e:
+            _log.warning(f"[!] Error compilando YAML {yaml_file}: {e}")
+            return None
+
+    def _get_all_workflows(self) -> list:
+        """Carga y retorna todos los flujos del sistema
+        y los flujos YAML compilados del proyecto actual."""
+        wfs = []
+        # 1. Flujos del sistema en JSON
+        for file in self.workflows_dir.rglob("*.json"):
+            try:
+                wfs.append(json.loads(file.read_text(encoding="utf-8")))
+            except (OSError, json.JSONDecodeError):
+                continue
+
+        # 2. Flujos personalizados del proyecto actual en YAML
+        custom_dir = self._get_custom_workflows_dir()
+        if custom_dir.exists():
+            for file in custom_dir.glob("*.yaml"):
+                compiled_wf = self.compile_yaml_workflow(file)
+                if compiled_wf:
+                    wfs.append(compiled_wf)
+            for file in custom_dir.glob("*.yml"):
+                compiled_wf = self.compile_yaml_workflow(file)
+                if compiled_wf:
+                    wfs.append(compiled_wf)
+
+        return wfs
+
+    def load_workflow(self, workflow_id: str) -> dict:
+        for wf in self._get_all_workflows():
+            if wf.get("id") == workflow_id or wf.get("id", "").split(".")[-1] == workflow_id:
+                return wf
+        raise FileNotFoundError(f"Workflow no encontrado: {workflow_id}")
+
+    def list_workflows(self) -> list:
+        wfs = []
+        for wf in self._get_all_workflows():
+            wfs.append(
+                {
+                    "id": wf.get("id"),
+                    "name": wf.get("name"),
+                    "description": wf.get("description"),
+                    "required_profile": wf.get("required_profile"),
+                    "parameters": wf.get("parameters", []),
+                }
+            )
+        return wfs
+
+    def get_all_workflows_data(self) -> list:
+        return self._get_all_workflows()

higpertext/kernel/config_paths.py

@@ -0,0 +1,66 @@
+"""Single source of truth for project directory paths, driven by src/config/htx_config.json."""
+
+from __future__ import annotations
+import json
+from pathlib import Path
+
+_ROOT = Path(__file__).resolve()
+while _ROOT.name != "LLM-agent" and _ROOT.parent != _ROOT:
+    _ROOT = _ROOT.parent
+
+if not (_ROOT / "src" / "config" / "htx_config.json").exists():
+    _fallback_root = Path("/home/aomerge/Documentos/Proyects/agents/LLM-agent")
+    if _fallback_root.exists():
+        _ROOT = _fallback_root
+
+_CONFIG_FILE = _ROOT / "src" / "config" / "htx_config.json"
+
+
+def _load() -> dict[str, Path]:
+    raw = json.loads(_CONFIG_FILE.read_text(encoding="utf-8")).get("paths", {})
+    return {key: _ROOT / value for key, value in raw.items()}
+
+
+_PATHS: dict[str, Path] = _load()
+
+
+def get(key: str) -> Path:
+    """Return the absolute Path for a named project directory."""
+    return _PATHS[key]
+
+
+# Convenience constants
+CAPABILITIES_DIR: Path = _PATHS["capabilities"]
+PROFILES_DIR: Path = _PATHS["profiles"]
+WORKFLOWS_DIR: Path = _PATHS["workflows"]
+HOOKS_GLOBAL_DIR: Path = _PATHS["hooks_global"]
+HOOKS_PROFILES_DIR: Path = _PATHS["hooks_profiles"]
+HOOKS_CUSTOM_DIR: Path = _PATHS["hooks_custom"]
+GOVERNANCE_DIR: Path = _PATHS["governance"]
+TEMPLATES_DIR: Path = _PATHS["templates"]
+ENVIRONMENTS_DIR: Path = _PATHS["environments"]
+SKILLS_TEMPLATES_DIR: Path = _PATHS["skills_templates"]
+SUBAGENTS_TEMPLATES_DIR: Path = _PATHS["subagents_templates"]
+PROJECT_ROOT: Path = _ROOT
+
+# Load workspace_dir name from config
+def _load_workspace_dir_name() -> str:
+    try:
+        data = json.loads(_CONFIG_FILE.read_text(encoding="utf-8"))
+        return data.get("htx", {}).get("workspace_dir", ".higpertext")
+    except Exception:
+        return ".higpertext"
+
+WORKSPACE_DIR_NAME: str = _load_workspace_dir_name()
+WORKSPACE_DIR_PATH: Path = _ROOT / WORKSPACE_DIR_NAME
+
+
+def _load_file_extension() -> str:
+    try:
+        data = json.loads(_CONFIG_FILE.read_text(encoding="utf-8"))
+        return data.get("htx", {}).get("file_extension", ".json")
+    except Exception:
+        return ".json"
+
+
+FILE_EXTENSION: str = _load_file_extension()

higpertext/kernel/domain/__init__.py

@@ -0,0 +1,12 @@
+# Domain layer init
+from higpertext.kernel.domain.governance import Rule, Severity, Scope, Verdict, Finding
+from higpertext.kernel.domain.agent_registry import AgentRecord, SyncResult
+from higpertext.kernel.domain.env_runtime import EnvironmentTemplate, RunSpec, RunState
+from higpertext.kernel.domain.commit_reporter import Commit, FileChange, CommitReport, CommitType, Layer
+from higpertext.kernel.domain.roadmap_reporter import Phase, PhaseStatus, Roadmap, RoadmapReport
+from higpertext.kernel.domain.compilers import ICompiler
+from higpertext.kernel.domain.profile_learner import SessionPattern, SkillProfile, score_session, classify_patterns, load_weights, save_weights
+from higpertext.kernel.domain.context_engine import ContextPack, FileSkeleton, SymbolRef, TaskIntent, EfficiencyReport, TaskNode, TaskGraph, WindowState, load_window_state, save_window_state, reset_window_state
+from higpertext.kernel.domain.semantic_engine import Symbol, SymbolType, Relation, RelationType, Cluster, SemanticGraph
+
+