higpertext-cli 0.8.0__py3-none-any.whl

higpertext/kernel/infrastructure/context_engine.py

@@ -0,0 +1,303 @@
+"""Context Engine Infrastructure layer — GraphIndex, PackStore, skeletonizer, and TelemetryReader."""
+
+from __future__ import annotations
+import ast
+import json
+import re
+from pathlib import Path
+from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+from higpertext.kernel.domain.context_engine import SymbolRef, ContextPack
+
+# Patrones del formato generado por SemanticGraphGenerator.
+
+
+def _parse_file_line(line: str) -> str | None:
+    prefix = "### 📂 ["
+    if not line.startswith(prefix):
+        return None
+    end = line.find("]", len(prefix))
+    return line[len(prefix):end] if end != -1 else None
+
+
+def _parse_doc_suffix(line: str) -> str:
+    marker = "— *"
+    start = line.find(marker)
+    if start == -1:
+        return ""
+    doc_start = start + len(marker)
+    doc_end = line.find("*", doc_start)
+    return line[doc_start:doc_end].strip() if doc_end != -1 else ""
+
+
+def _parse_symbol_line(line: str, prefix: str, kind: str) -> tuple[str, str, str] | None:
+    stripped = line.strip()
+    if not stripped.startswith(prefix):
+        return None
+    name_start = len(prefix)
+    name_end = stripped.find("`", name_start)
+    if name_end == -1:
+        return None
+    signature = stripped[name_start:name_end]
+    name = signature.split("(", 1)[0].strip()
+    return (name, kind, _parse_doc_suffix(stripped)) if name.isidentifier() else None
+
+
+class GraphIndex:
+    """Lee el semantic graph y expone búsqueda de símbolos por keyword."""
+
+    def __init__(self, project_root: Path) -> None:
+        self._json_path = project_root / WORKSPACE_DIR_NAME / "state" / "semantic_graph.json"
+        self._md_path = project_root / WORKSPACE_DIR_NAME / "state" / "semantic_graph.md"
+        self._symbols: list[SymbolRef] = []
+        self._parse()
+
+    def _parse(self) -> None:
+        if self._json_path.exists():
+            self._parse_json()
+            return
+        self._parse_markdown()
+
+    def _parse_json(self) -> None:
+        raw = json.loads(self._json_path.read_text(encoding="utf-8"))
+        if "symbols" in raw:
+            self._parse_symbols_json(raw["symbols"])
+            return
+        self._parse_files_json(raw.get("files", {}))
+
+    def _parse_symbols_json(self, symbols: list[dict]) -> None:
+        for symbol in symbols:
+            self._symbols.append(
+                SymbolRef(
+                    file=symbol.get("file", ""),
+                    name=symbol.get("name", ""),
+                    kind=symbol.get("type", "symbol"),
+                    doc=symbol.get("docstring", ""),
+                )
+            )
+
+    def _parse_files_json(self, files: dict) -> None:
+        for file_path, data in files.items():
+            for cls in data.get("classes", []):
+                self._symbols.append(
+                    SymbolRef(
+                        file=file_path,
+                        name=cls.get("name", ""),
+                        kind="class",
+                        doc=cls.get("docstring", ""),
+                    )
+                )
+                for method in cls.get("methods", []):
+                    self._symbols.append(
+                        SymbolRef(
+                            file=file_path,
+                            name=method.get("name", ""),
+                            kind="method",
+                            doc=method.get("docstring", ""),
+                        )
+                    )
+            for func in data.get("functions", []):
+                self._symbols.append(
+                    SymbolRef(
+                        file=file_path,
+                        name=func.get("name", ""),
+                        kind="function",
+                        doc=func.get("docstring", ""),
+                    )
+                )
+
+    def _parse_markdown(self) -> None:
+        if not self._md_path.exists():
+            return
+        current_file = ""
+        for line in self._md_path.read_text(encoding="utf-8").splitlines():
+            parsed_file = _parse_file_line(line)
+            if parsed_file:
+                current_file = parsed_file
+                continue
+            if not current_file:
+                continue
+            parsed = _parse_symbol_line(line, "- `def ", "method")
+            if parsed and line[:1].isspace():
+                name, kind, doc = parsed
+                self._symbols.append(SymbolRef(file=current_file, name=name, kind=kind, doc=doc))
+                continue
+            parsed = _parse_symbol_line(line, "- **`class ", "class")
+            if parsed:
+                name, kind, doc = parsed
+                self._symbols.append(SymbolRef(file=current_file, name=name, kind=kind, doc=doc))
+                continue
+            parsed = _parse_symbol_line(line, "- `def ", "function")
+            if parsed:
+                name, kind, doc = parsed
+                self._symbols.append(SymbolRef(file=current_file, name=name, kind=kind, doc=doc))
+
+    def all_symbols(self) -> list[SymbolRef]:
+        return list(self._symbols)
+
+    def search(self, keywords: list[str]) -> list[SymbolRef]:
+        """Devuelve símbolos cuyo nombre, archivo o doc contiene algún keyword."""
+        if not keywords:
+            return []
+        kws = [k.lower() for k in keywords]
+        hits: list[SymbolRef] = []
+        for s in self._symbols:
+            haystack = f"{s.name} {s.file} {s.doc}".lower()
+            if any(k in haystack for k in kws):
+                hits.append(s)
+        return hits
+
+
+class PackStore:
+    """Guarda y referencia context packs como artefactos Markdown en disco."""
+
+    def __init__(self, project_root: Path) -> None:
+        self._dir = project_root / WORKSPACE_DIR_NAME / "state" / "context_packs"
+
+    def save(self, pack: ContextPack) -> Path:
+        self._dir.mkdir(parents=True, exist_ok=True)
+        task_id = self._slug(pack.intent.goal)
+        path = self._dir / f"{task_id}.md"
+        path.write_text(pack.to_markdown(), encoding="utf-8")
+        return path
+
+    @staticmethod
+    def _slug(goal: str) -> str:
+        slug = re.sub(r"[^a-z0-9]+", "-", goal.lower()).strip("-")
+        return slug[:50] or "context-pack"
+
+
+# Umbral a partir del cual un archivo se considera 'grande' y candidato a esqueletización.
+_SKELETON_THRESHOLD_CHARS = 3000
+
+
+def should_skeletonize(source: str) -> bool:
+    """Indica si un archivo supera el umbral para ser esqueletizado."""
+    return len(source) > _SKELETON_THRESHOLD_CHARS
+
+
+def extract_skeleton(source: str) -> str:
+    """Extrae firmas de clases y funciones de un fragmento de código Python."""
+    try:
+        return _extract_via_ast(source)
+    except SyntaxError:
+        return _extract_via_regex(source)
+
+
+def _extract_via_ast(source: str) -> str:
+    """Extrae firmas usando el módulo ast estándar de Python."""
+    tree = ast.parse(source)
+    lines: list[str] = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ClassDef):
+            bases = ", ".join(ast.unparse(b) for b in node.bases)
+            header = f"class {node.name}({bases}):" if bases else f"class {node.name}:"
+            lines.append(header)
+        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            prefix = "async def" if isinstance(node, ast.AsyncFunctionDef) else "def"
+            args = ast.unparse(node.args)
+            ret = f" -> {ast.unparse(node.returns)}" if node.returns else ""
+            lines.append(f"    {prefix} {node.name}({args}){ret}: ...")
+    return "\n".join(lines)
+
+
+def _extract_via_regex(source: str) -> str:
+    """Fallback lineal: extrae líneas que definen clases o funciones sin regex."""
+    signatures: list[str] = []
+    for line in source.splitlines():
+        stripped = line.strip()
+        if not stripped.endswith(":"):
+            continue
+        if _is_signature_line(stripped):
+            signatures.append(f"{stripped} ...")
+    return "\n".join(signatures)
+
+
+def _is_signature_line(line: str) -> bool:
+    if line.startswith("class "):
+        name = line.removeprefix("class ").split("(", 1)[0].removesuffix(":").strip()
+        return name.isidentifier()
+    if line.startswith("async def "):
+        name = line.removeprefix("async def ").split("(", 1)[0].strip()
+        return _has_balanced_signature_tail(line) and name.isidentifier()
+    if line.startswith("def "):
+        name = line.removeprefix("def ").split("(", 1)[0].strip()
+        return _has_balanced_signature_tail(line) and name.isidentifier()
+    return False
+
+
+def _has_balanced_signature_tail(line: str) -> bool:
+    open_index = line.find("(")
+    close_index = line.rfind(")")
+    colon_index = line.rfind(":")
+    return open_index != -1 and open_index < close_index < colon_index
+
+
+class TelemetryReader:
+    """Lee telemetry.jsonl y expone queries por sesión."""
+
+    def __init__(self, project_root: Path) -> None:
+        self._path = project_root / WORKSPACE_DIR_NAME / "state" / "telemetry.jsonl"
+
+    def _all_events(self) -> list[dict]:
+        if not self._path.exists():
+            return []
+        events = []
+        for line in self._path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                events.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+        return events
+
+    def events_for_session(self, session_id: str) -> list[dict]:
+        return [e for e in self._all_events() if e.get("session_id") == session_id]
+
+    def total_tokens(self, session_id: str) -> int:
+        return sum(
+            e.get("estimated_tokens", 0)
+            for e in self.events_for_session(session_id)
+            if e.get("event") == "tool_call"
+        )
+
+    def total_cost(self, session_id: str) -> float:
+        return sum(
+            e.get("estimated_cost_usd", 0.0)
+            for e in self.events_for_session(session_id)
+            if e.get("event") == "tool_call"
+        )
+
+    def exploration_reads(self, session_id: str) -> int:
+        """Lecturas de archivo sin higpertext_related=True (exploración ciega)."""
+        return sum(
+            1
+            for e in self.events_for_session(session_id)
+            if e.get("event") == "activity"
+            and e.get("op_type") == "file-read"
+            and not e.get("higpertext_related", False)
+        )
+
+    def higpertext_reads(self, session_id: str) -> int:
+        """Lecturas de archivo con higpertext_related=True (uso correcto)."""
+        return sum(
+            1
+            for e in self.events_for_session(session_id)
+            if e.get("event") == "activity"
+            and e.get("op_type") == "file-read"
+            and e.get("higpertext_related", False)
+        )
+
+    def hook_intercepts(self, session_id: str) -> int:
+        return sum(
+            1 for e in self.events_for_session(session_id) if e.get("event") == "hook_intercept"
+        )
+
+    def files_read(self, session_id: str) -> set[str]:
+        """Conjunto de archivos leídos en la sesión (targets de activity)."""
+        return {
+            e["target"]
+            for e in self.events_for_session(session_id)
+            if e.get("event") == "activity" and e.get("target")
+        }

higpertext/kernel/infrastructure/database/local_vector_store.py

@@ -0,0 +1,99 @@
+"""LocalVectorStore - Base de datos vectorial persistida en archivo JSON."""
+
+from __future__ import annotations
+import json
+import math
+from pathlib import Path
+from higpertext.kernel.domain.rag import IVectorStore, VectorEntry, DocumentChunk
+
+
+class LocalVectorStore(IVectorStore):
+    """Almacén vectorial en JSON local con búsqueda por similitud coseno."""
+
+    def __init__(self, project_root: Path) -> None:
+        self.project_root = project_root
+        self.store_file = project_root / ".higpertext" / "state" / "vector_store.json"
+        self.entries: list[VectorEntry] = []
+
+    def add_entries(self, entries: list[VectorEntry]) -> None:
+        self.entries.extend(entries)
+
+    def search(
+        self, query_vector: list[float], limit: int = 5
+    ) -> list[tuple[DocumentChunk, float]]:
+        if not self.entries or not query_vector:
+            return []
+
+        results: list[tuple[DocumentChunk, float]] = []
+        for entry in self.entries:
+            score = self._cosine_similarity(query_vector, entry.embedding)
+            results.append((entry.chunk, score))
+
+        # Ordenar por score de similitud descendente
+        results.sort(key=lambda x: x[1], reverse=True)
+        return results[:limit]
+
+    def clear(self) -> None:
+        self.entries = []
+
+    def save(self) -> None:
+        self.store_file.parent.mkdir(parents=True, exist_ok=True)
+        serializable_data = []
+        for entry in self.entries:
+            serializable_data.append(
+                {
+                    "chunk": {
+                        "file": entry.chunk.file,
+                        "content": entry.chunk.content,
+                        "chunk_type": entry.chunk.chunk_type,
+                        "start_line": entry.chunk.start_line,
+                        "end_line": entry.chunk.end_line,
+                        "metadata": entry.chunk.metadata,
+                    },
+                    "embedding": entry.embedding,
+                }
+            )
+
+        tmp_file = self.store_file.with_suffix(".tmp")
+        tmp_file.write_text(
+            json.dumps(serializable_data, indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
+        tmp_file.replace(self.store_file)
+
+    def load(self) -> None:
+        if not self.store_file.exists():
+            self.entries = []
+            return
+
+        try:
+            data = json.loads(self.store_file.read_text(encoding="utf-8"))
+            self.entries = []
+            for item in data:
+                c = item["chunk"]
+                chunk = DocumentChunk(
+                    file=c["file"],
+                    content=c["content"],
+                    chunk_type=c["chunk_type"],
+                    start_line=c["start_line"],
+                    end_line=c["end_line"],
+                    metadata=c.get("metadata", {}),
+                )
+                self.entries.append(VectorEntry(chunk=chunk, embedding=item["embedding"]))
+        except (json.JSONDecodeError, KeyError, OSError):
+            self.entries = []
+
+    @staticmethod
+    def _cosine_similarity(v1: list[float], v2: list[float]) -> float:
+        """Calcula la similitud coseno entre dos vectores."""
+        if len(v1) != len(v2) or not v1:
+            return 0.0
+
+        dot_product = sum(a * b for a, b in zip(v1, v2))
+        norm_a = math.sqrt(sum(a * a for a in v1))
+        norm_b = math.sqrt(sum(b * b for b in v2))
+
+        if norm_a == 0.0 or norm_b == 0.0:
+            return 0.0
+
+        return dot_product / (norm_a * norm_b)

higpertext/kernel/infrastructure/deployment/__init__.py

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

higpertext/kernel/infrastructure/deployment/resource_deployer.py

@@ -0,0 +1,283 @@
+"""ResourceDeployer — despliega y restaura skills, subagentes y playbooks (Infraestructura)."""
+
+from __future__ import annotations
+import json
+from pathlib import Path
+from higpertext.kernel.infrastructure.presentation.markdown_renderer import (
+    MarkdownRenderer,
+)
+from higpertext.kernel.pkg_resources import resolve_resource
+
+from higpertext.kernel.infrastructure.logger import get_logger
+from higpertext.kernel.app_config import (
+    PLAYBOOKS as _PLAYBOOKS,
+    AGENT_JSON as _AGENT_JSON,
+    NO_SKILLS_MSG as _NO_SKILLS_MSG,
+    NO_SUBAGENTS_MSG as _NO_SUBAGENTS_MSG,
+    ANTIGRAVITY_AGENT_TEMPLATE as _AGT,
+)
+_log = get_logger()
+
+
+class ResourceDeployer:
+    """Responsabilidad única: copiar/eliminar recursos efímeros de sesión."""
+
+    def __init__(self, project_root: Path, root_dir: Path) -> None:
+        self.project_root = project_root
+        self.root_dir = root_dir
+
+    def _resolve_template_dirs(self, subdir: str) -> list[Path]:
+        from higpertext.kernel.config_paths import WORKSPACE_DIR_NAME
+        dirs = []
+        agent_templates = self.project_root / WORKSPACE_DIR_NAME / "agent_templates" / subdir
+        if agent_templates.exists():
+            dirs.append(agent_templates)
+        dirs.append(resolve_resource(self.root_dir, "src", "higpertext", "templates", subdir))
+        return dirs
+
+    def deploy_skills(self, skills: list, skills_dest: Path) -> None:
+        if not skills:
+            return
+        skills_dirs = self._resolve_template_dirs("skills")
+        skills_dest.mkdir(parents=True, exist_ok=True)
+        
+        # Construir índice de rglob de todos los directorios ordenados por prioridad
+        index = {}
+        for d in reversed(skills_dirs):
+            if d.exists():
+                for f in d.rglob("*.json"):
+                    index[f.parent.name] = f
+                # También buscar archivos Markdown directos
+                for f in d.rglob("*.md"):
+                    index[f.stem] = f
+
+        for name in skills:
+            src = index.get(name)
+            if not (src and src.exists()):
+                continue
+            try:
+                dest = skills_dest / name
+                dest.mkdir(parents=True, exist_ok=True)
+                if src.suffix == ".json":
+                    data = json.loads(src.read_text(encoding="utf-8"))
+                    (dest / "SKILL.md").write_text(data.get("content", ""), encoding="utf-8")
+                else:
+                    # Si es Markdown directo (.md)
+                    (dest / "SKILL.md").write_text(src.read_text(encoding="utf-8"), encoding="utf-8")
+            except (OSError, json.JSONDecodeError) as e:
+                _log.warning(f"[!] Error generando skill '{name}': {e}")
+
+    def deploy_subagents(self, subagents: list, subagents_dest: Path, skills_str: str = "") -> None:
+        if not subagents:
+            return
+        subagents_dirs = self._resolve_template_dirs("subagents")
+        subagents_dest.mkdir(parents=True, exist_ok=True)
+        
+        index = {}
+        for d in reversed(subagents_dirs):
+            if d.exists():
+                for f in d.rglob("*.json"):
+                    index[f.stem] = f
+                for f in d.rglob("*.md"):
+                    index[f.stem] = f
+
+        is_antigravity = subagents_dest.name == "agents"
+        for name in subagents:
+            src = index.get(name)
+            if not (src and src.exists()):
+                continue
+            try:
+                if src.suffix == ".json":
+                    self._process_subagent_file(src, subagents_dest, name, is_antigravity, skills_str)
+                else:
+                    # Si es Markdown directo (.md)
+                    if is_antigravity:
+                        # Generar el JSON mock de Antigravity
+                        mock_data = {
+                            "description": f"Subagent {name}",
+                            "system_prompt": src.read_text(encoding="utf-8")
+                        }
+                        self._generate_antigravity_agent_json(subagents_dest, name, mock_data)
+                    else:
+                        (subagents_dest / f"{name}.md").write_text(src.read_text(encoding="utf-8"), encoding="utf-8")
+            except (OSError, json.JSONDecodeError) as e:
+                _log.warning(f"[!] Error generando subagente '{name}': {e}")
+
+    def _process_subagent_file(
+        self, src: Path, subagents_dest: Path, name: str, is_antigravity: bool, skills_str: str
+    ) -> None:
+        data = json.loads(src.read_text(encoding="utf-8"))
+        if is_antigravity:
+            self._generate_antigravity_agent_json(subagents_dest, name, data)
+        else:
+            md = MarkdownRenderer.generate_subagent_md(data, skills_str)
+            (subagents_dest / f"{name}.md").write_text(md, encoding="utf-8")
+
+    def _generate_antigravity_agent_json(
+        self, subagents_dest: Path, name: str, data: dict
+    ) -> None:
+        agent_dir = subagents_dest / name
+        agent_dir.mkdir(parents=True, exist_ok=True)
+        system_prompt = self._build_antigravity_system_prompt(data)
+        agent_json = {
+            "name": name,
+            "description": data.get("description", ""),
+            "hidden": _AGT["hidden"],
+            "config": {
+                "customAgent": {
+                    "systemPromptSections": [
+                        {
+                            "title": _AGT["system_prompt_section_title"],
+                            "content": system_prompt.strip(),
+                        }
+                    ],
+                    "toolNames": _AGT["tool_names"],
+                    "systemPromptConfig": _AGT["system_prompt_config"],
+                }
+            },
+        }
+        (agent_dir / _AGENT_JSON).write_text(
+            json.dumps(agent_json, indent=2, ensure_ascii=False),
+            encoding="utf-8",
+        )
+
+    @staticmethod
+    def _build_antigravity_system_prompt(data: dict) -> str:
+        system_prompt = f"{data.get('description', '')}\n\n"
+        for entry in _AGT["system_prompt_keys"]:
+            key, title = entry["key"], entry["title"]
+            if key in data:
+                system_prompt += f"{title}\n" + "\n".join(f"- {x}" for x in data[key]) + "\n\n"
+        return system_prompt
+
+    def deploy_playbooks(
+        self,
+        workflows_dest: Path,
+        skills_str: str,
+        subagents_str: str,
+        session_id: str,
+        assistant: str = "gemini",
+        get_model_fn=None,
+        get_profile_fn=None,
+    ) -> None:
+        tmpl_dir = resolve_resource(self.root_dir, "src", "higpertext", "templates", "workflows")
+        workflows_dest.mkdir(parents=True, exist_ok=True)
+        session_block = (
+            f"\n# Session Info\n- **Session ID**: `{session_id}`\n- **Status**: `active`"
+        )
+        for name in _PLAYBOOKS:
+            src = tmpl_dir / f"{name}.json"
+            if not src.exists():
+                continue
+            try:
+                data = json.loads(src.read_text(encoding="utf-8"))
+                profile_model = self._resolve_model(data, assistant, get_model_fn, get_profile_fn)
+                content = MarkdownRenderer.generate_workflow_base_md(data, assistant, profile_model)
+                content = content.replace("{required_skills_str}", skills_str)
+                content = content.replace("{related_subagents_str}", subagents_str)
+                content += session_block
+                (workflows_dest / f"{name}.md").write_text(content, encoding="utf-8")
+            except (OSError, json.JSONDecodeError) as e:
+                _log.warning(f"[!] Error compilando playbook '{name}': {e}")
+
+    def restore_playbooks(
+        self,
+        workflows_dest: Path,
+        assistant: str = "gemini",
+        get_model_fn=None,
+        get_profile_fn=None,
+    ) -> None:
+        tmpl_dir = resolve_resource(self.root_dir, "src", "higpertext", "templates", "workflows")
+        if not (tmpl_dir.exists() and workflows_dest.exists()):
+            return
+        for name in _PLAYBOOKS:
+            src = tmpl_dir / f"{name}.json"
+            dest = workflows_dest / f"{name}.md"
+            if not src.exists():
+                continue
+            try:
+                data = json.loads(src.read_text(encoding="utf-8"))
+                profile_model = self._resolve_model(data, assistant, get_model_fn, get_profile_fn)
+                content = MarkdownRenderer.generate_workflow_base_md(data, assistant, profile_model)
+                content = content.replace("{required_skills_str}", _NO_SKILLS_MSG)
+                content = content.replace("{related_subagents_str}", _NO_SUBAGENTS_MSG)
+                dest.write_text(content, encoding="utf-8")
+            except (OSError, json.JSONDecodeError) as e:
+                _log.warning(f"[!] Error restaurando playbook '{name}': {e}")
+
+    def build_resource_links(
+        self,
+        skills: list,
+        subagents: list,
+        skills_dest: Path,
+        subagents_dest: Path,
+    ) -> tuple[str, str]:
+        tmpl_skills = resolve_resource(self.root_dir, "src", "higpertext", "templates", "skills")
+        tmpl_subagents = resolve_resource(
+            self.root_dir, "src", "higpertext", "templates", "subagents"
+        )
+        skill_index = (
+            {f.parent.name for f in tmpl_skills.rglob("*.json")} if tmpl_skills.exists() else set()
+        )
+        agent_index = (
+            {f.stem for f in tmpl_subagents.rglob("*.json")} if tmpl_subagents.exists() else set()
+        )
+
+        def _skill_link(name: str) -> str:
+            d = skills_dest / name
+            try:
+                rel = d.relative_to(self.project_root).as_posix()
+                return f"- [{name}](file:///{rel}/SKILL.md)"
+            except ValueError:
+                return f"- `{name}`"
+
+        def _subagent_link(name: str) -> str:
+            is_antigravity = subagents_dest.name == "agents"
+            f = (
+                subagents_dest / name / _AGENT_JSON
+                if is_antigravity
+                else subagents_dest / f"{name}.md"
+            )
+            try:
+                rel = f.relative_to(self.project_root).as_posix()
+                return f"- [{name}](file:///{rel})"
+            except ValueError:
+                return f"- `{name}`"
+
+        skills_lines = [
+            (_skill_link(s) if (s in skill_index or (skills_dest / s).exists()) else f"- `{s}`")
+            for s in sorted(skills)
+        ]
+        sub_lines = [
+            (
+                _subagent_link(sa)
+                if (
+                    sa in agent_index
+                    or (subagents_dest / f"{sa}.md").exists()
+                    or (subagents_dest / sa / _AGENT_JSON).exists()
+                )
+                else f"- `{sa}`"
+            )
+            for sa in sorted(subagents)
+        ]
+        skills_str = "\n".join(skills_lines) if skills_lines else "- `00-quick-reference`"
+        subs_str = "\n".join(sub_lines) if sub_lines else "- `research`"
+        return skills_str, subs_str
+
+    @staticmethod
+    def _resolve_model(data: dict, assistant: str, get_model_fn, get_profile_fn) -> str:
+        if get_profile_fn:
+            try:
+                profile_data = get_profile_fn()
+                if profile_data and "model" in profile_data:
+                    return profile_data["model"]
+            except Exception:  # nosec B110
+                pass
+        if get_model_fn:
+            try:
+                model = get_model_fn(assistant)
+                if model:
+                    return model
+            except Exception:  # nosec B110
+                pass
+        return data.get("model", "")

higpertext/kernel/infrastructure/diagnostics/__init__.py

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