agent-devkit 0.1.5 → 0.2.0

package/runtime/cli/aikit/control_router.py

@@ -0,0 +1,298 @@
+"""Natural-language control routing for tools, integrations, skills and LLMs."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+from cli.aikit.decision_store import forget_decision, list_decisions, reset_decisions, set_decision
+from cli.aikit.llm import BACKENDS
+from cli.aikit.providers import load_providers
+from cli.aikit.toolchain import load_toolchain
+
+
+CATEGORY_ALIASES: dict[str, tuple[str, ...]] = {
+    "tools": ("tool", "tools", "ferramenta", "ferramentas", "cli", "clis", "toolchain"),
+    "integrations": ("integration", "integrations", "integracao", "integracoes", "integração", "integrações", "provider", "providers"),
+    "skills": ("skill", "skills", "habilidade", "habilidades"),
+    "llms": ("llm", "llms", "modelo", "modelos", "backend", "backends"),
+}
+LIST_MARKERS = ("mostre", "mostrar", "liste", "listar", "ver", "exiba", "exibir")
+ENABLE_MARKERS = ("reative", "ative", "habilite", "enable")
+DISABLE_MARKERS = ("desative", "desabilite", "disable", "bloqueie", "bloquear")
+FORGET_MARKERS = ("esqueca", "esqueça", "remova", "remover", "limpe", "limpar", "delete", "apague", "apagar")
+DECISION_MARKERS = ("decisao", "decisão", "decisoes", "decisões", "decision", "decisions", "bloqueio")
+TOKEN_PATTERN = re.compile(r"[a-z0-9._:-]+")
+SKILL_ROW_PATTERN = re.compile(r"^\|\s*`([^`]+)`\s*\|")
+
+
+def dispatch_natural_control_prompt(root: Path, normalized_prompt: str) -> dict[str, Any] | None:
+    action = detect_action(normalized_prompt)
+    category = detect_category(normalized_prompt)
+    if action == "list":
+        return list_payload(root, category=category)
+    if action == "reset" and category:
+        result = reset_decisions(category)
+        return control_payload(
+            status="ok",
+            response=f"Decisoes de {category} foram resetadas.",
+            result={"action": "reset", "category": category, "decision": result},
+        )
+    if action not in {"enable", "disable", "forget"}:
+        return None
+
+    index = build_control_index(root)
+    matches = resolve_target(index, normalized_prompt, category=category)
+    if not matches:
+        return needs_input_unknown(root, normalized_prompt, category=category)
+    if len(matches) > 1:
+        return needs_input_ambiguous(matches, normalized_prompt, category=category)
+
+    target = matches[0]
+    if action == "forget":
+        decision = forget_decision(str(target["category"]), str(target["id"]))
+        return control_payload(
+            status="ok",
+            response=f"Decisao local sobre {target['id']} removida.",
+            result={"action": "forget", "category": target["category"], "id": target["id"], "removed": decision.get("removed"), "decision": decision},
+        )
+
+    state = "enabled" if action == "enable" else "disabled_by_user"
+    decision = set_decision(str(target["category"]), str(target["id"]), state, reason=f"natural prompt: {action}")
+    return control_payload(
+        status="ok",
+        response=f"{target['id']} foi {'ativado' if state == 'enabled' else 'desativado'} para {target['category']}.",
+        result={"action": action, "category": target["category"], "id": target["id"], "state": state, "decision": decision.get("item")},
+    )
+
+
+def plan_natural_control_prompt(root: Path, normalized_prompt: str) -> dict[str, Any] | None:
+    action = detect_action(normalized_prompt)
+    category = detect_category(normalized_prompt)
+    if action == "list":
+        payload = list_payload(root, category=category)
+        payload["dry_run"] = True
+        return payload
+    if action == "reset" and category:
+        return control_payload(
+            status="planned",
+            response=f"Dry-run: decisoes de {category} seriam resetadas.",
+            result={"action": "reset", "category": category},
+        ) | {"dry_run": True, "ok": True}
+    if action not in {"enable", "disable", "forget"}:
+        return None
+    index = build_control_index(root)
+    matches = resolve_target(index, normalized_prompt, category=category)
+    if not matches:
+        payload = needs_input_unknown(root, normalized_prompt, category=category)
+        payload["dry_run"] = True
+        return payload
+    if len(matches) > 1:
+        payload = needs_input_ambiguous(matches, normalized_prompt, category=category)
+        payload["dry_run"] = True
+        return payload
+    target = matches[0]
+    state = "enabled" if action == "enable" else "disabled_by_user"
+    return control_payload(
+        status="planned",
+        response=f"Dry-run: {target['id']} seria {'ativado' if action == 'enable' else 'desativado' if action == 'disable' else 'removido das decisoes'} para {target['category']}.",
+        result={"action": action, "category": target["category"], "id": target["id"], "state": state if action != "forget" else None},
+    ) | {"dry_run": True, "ok": True}
+
+
+def build_control_index(root: Path) -> dict[str, list[dict[str, Any]]]:
+    return {
+        "tools": tool_items(root),
+        "integrations": integration_items(root),
+        "skills": skill_items(root),
+        "llms": llm_items(),
+    }
+
+
+def tool_items(root: Path) -> list[dict[str, Any]]:
+    return [
+        item("tools", tool_id, label=str(spec.get("label") or tool_id), source="toolchain", aliases=aliases_for(tool_id, spec.get("label")))
+        for tool_id, spec in load_toolchain(root).items()
+    ]
+
+
+def integration_items(root: Path) -> list[dict[str, Any]]:
+    items = []
+    for provider in load_providers(root):
+        provider_id = str(provider.get("id") or "")
+        if provider_id:
+            items.append(item("integrations", provider_id, label=str(provider.get("name") or provider_id), source="providers", aliases=aliases_for(provider_id, provider.get("name"))))
+    return items
+
+
+def skill_items(root: Path) -> list[dict[str, Any]]:
+    catalog = root / "vendor" / "skills" / "CATALOG.md"
+    if not catalog.exists():
+        return []
+    items = []
+    for line in catalog.read_text(encoding="utf-8").splitlines():
+        match = SKILL_ROW_PATTERN.match(line)
+        if not match:
+            continue
+        skill_id = match.group(1).strip()
+        if skill_id and skill_id.lower() != "skill":
+            items.append(item("skills", skill_id, label=skill_id, source="vendor-skills", aliases=aliases_for(skill_id)))
+    return items
+
+
+def llm_items() -> list[dict[str, Any]]:
+    return [
+        item("llms", backend_id, label=backend.display_name, source="llm-backends", aliases=aliases_for(backend_id, backend.display_name))
+        for backend_id, backend in BACKENDS.items()
+    ]
+
+
+def item(category: str, item_id: str, *, label: str, source: str, aliases: set[str]) -> dict[str, Any]:
+    return {"category": category, "id": item_id, "label": label, "source": source, "aliases": sorted(aliases)}
+
+
+def aliases_for(item_id: str, label: Any = None) -> set[str]:
+    values = {normalize(item_id)}
+    if label:
+        values.add(normalize(str(label)))
+    values.add(normalize(item_id.replace("-", " ")))
+    values.add(normalize(item_id.replace("_", " ")))
+    for token in re.split(r"[-_\s]+", item_id):
+        normalized = normalize(token)
+        if normalized and normalized not in {"cli", "mcp", "api", "tool", "skill", "plugin"}:
+            values.add(normalized)
+    if item_id.endswith("-cli"):
+        values.add(normalize(item_id.removesuffix("-cli")))
+    if item_id.endswith("-mcp"):
+        values.add(normalize(item_id.removesuffix("-mcp")))
+    return {value for value in values if value}
+
+
+def detect_action(prompt: str) -> str | None:
+    if contains_any(prompt, LIST_MARKERS):
+        return "list"
+    if contains_any(prompt, FORGET_MARKERS) and contains_any(prompt, DECISION_MARKERS) and detect_category(prompt):
+        return "reset"
+    if contains_any(prompt, FORGET_MARKERS) and contains_any(prompt, DECISION_MARKERS):
+        return "forget"
+    if contains_any(prompt, FORGET_MARKERS) and detect_category(prompt):
+        return "reset"
+    if contains_any(prompt, DISABLE_MARKERS):
+        return "disable"
+    if contains_any(prompt, ENABLE_MARKERS):
+        return "enable"
+    return None
+
+
+def detect_category(prompt: str) -> str | None:
+    for category, aliases in CATEGORY_ALIASES.items():
+        if contains_any(prompt, aliases):
+            return category
+    return None
+
+
+def list_payload(root: Path, *, category: str | None) -> dict[str, Any]:
+    index = build_control_index(root)
+    if category:
+        result = {
+            "kind": "control-index",
+            "status": "ok",
+            "category": category,
+            "items": public_items(index.get(category, [])),
+            "decisions": list_decisions(category),
+        }
+        return control_payload(status="ok", response=f"Estes sao os itens catalogados para {category}.", result=result)
+    result = {
+        "kind": "control-index",
+        "status": "ok",
+        "categories": {key: public_items(value) for key, value in index.items()},
+        "decisions": list_decisions(),
+    }
+    return control_payload(status="ok", response="Estes sao os recursos controlaveis catalogados.", result=result)
+
+
+def resolve_target(index: dict[str, list[dict[str, Any]]], prompt: str, *, category: str | None) -> list[dict[str, Any]]:
+    candidates = index.get(category, []) if category else [item for items in index.values() for item in items]
+    prompt_tokens = set(TOKEN_PATTERN.findall(prompt))
+    matches = []
+    for candidate in candidates:
+        aliases = set(candidate.get("aliases") or [])
+        if any(alias_matches_prompt(alias, prompt, prompt_tokens) for alias in aliases):
+            matches.append(candidate)
+            continue
+        candidate_tokens = set(TOKEN_PATTERN.findall(normalize(str(candidate.get("id") or ""))))
+        if candidate_tokens and candidate_tokens <= prompt_tokens:
+            matches.append(candidate)
+    return sorted(unique_matches(matches), key=lambda item: (str(item["category"]), str(item["id"])))
+
+
+def unique_matches(matches: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    seen: set[tuple[str, str]] = set()
+    unique = []
+    for match in matches:
+        key = (str(match.get("category")), str(match.get("id")))
+        if key not in seen:
+            seen.add(key)
+            unique.append(match)
+    return unique
+
+
+def alias_matches_prompt(alias: str, prompt: str, prompt_tokens: set[str]) -> bool:
+    if not alias:
+        return False
+    alias_tokens = set(TOKEN_PATTERN.findall(alias))
+    if len(alias_tokens) == 1:
+        return alias in prompt_tokens
+    return alias in prompt
+
+
+def needs_input_unknown(root: Path, prompt: str, *, category: str | None) -> dict[str, Any]:
+    index = build_control_index(root)
+    categories = [category] if category else sorted(index)
+    return {
+        "kind": "agent",
+        "status": "needs-input",
+        "ok": False,
+        "mode": "control-center-route",
+        "requires_llm": False,
+        "unknown_control_target": True,
+        "category": category,
+        "prompt": prompt,
+        "available_categories": categories,
+        "response": "Nao encontrei esse recurso nos catalogos locais controlaveis.",
+        "result": {"categories": {key: public_items(index.get(key, [])) for key in categories}},
+        "exit_code": 2,
+    }
+
+
+def needs_input_ambiguous(matches: list[dict[str, Any]], prompt: str, *, category: str | None) -> dict[str, Any]:
+    return {
+        "kind": "agent",
+        "status": "needs-input",
+        "ok": False,
+        "mode": "control-center-route",
+        "requires_llm": False,
+        "ambiguous_control_target": True,
+        "category": category,
+        "prompt": prompt,
+        "matches": public_items(matches),
+        "response": "Encontrei mais de um recurso compativel. Informe a categoria ou id exato.",
+        "exit_code": 2,
+    }
+
+
+def control_payload(*, status: str, response: str, result: dict[str, Any]) -> dict[str, Any]:
+    return {"kind": "agent", "status": status, "ok": status == "ok", "mode": "control-center-route", "requires_llm": False, "response": response, "result": result}
+
+
+def public_items(items: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    return [{"category": item.get("category"), "id": item.get("id"), "label": item.get("label"), "source": item.get("source")} for item in items]
+
+
+def contains_any(prompt: str, markers: tuple[str, ...]) -> bool:
+    return any(normalize(marker) in prompt for marker in markers)
+
+
+def normalize(value: str) -> str:
+    return " ".join(value.lower().split())

package/runtime/cli/aikit/core/__init__.py

@@ -0,0 +1 @@
+"""Reusable Agent DevKit core package."""

package/runtime/cli/aikit/core/capability_contract.py

@@ -0,0 +1,112 @@
+"""Canonical capability contract helpers."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from cli.aikit.core.requests import CapabilityRunRequest
+from cli.aikit.runtime_paths import ROOT
+from cli.aikit.write_policy import write_policy_metadata
+
+
+def capability_policy(manifest: dict[str, Any]) -> dict[str, Any]:
+    return write_policy_metadata(manifest.get("write_policy"))
+
+
+def normalize_capability_artifacts(value: Any) -> list[dict[str, Any]]:
+    artifacts = value if isinstance(value, list) else []
+    normalized: list[dict[str, Any]] = []
+    for item in artifacts:
+        if isinstance(item, str):
+            normalized.append(
+                {
+                    "path": item,
+                    "kind": artifact_kind(item),
+                    "description": "",
+                    "sensitive": False,
+                    "created": None,
+                }
+            )
+            continue
+        if isinstance(item, dict):
+            path = str(item.get("path") or item.get("ref") or "").strip()
+            normalized.append(
+                {
+                    "path": path,
+                    "kind": str(item.get("kind") or artifact_kind(path)),
+                    "description": str(item.get("description") or ""),
+                    "sensitive": bool(item.get("sensitive", False)),
+                    "created": item.get("created"),
+                }
+            )
+    return normalized
+
+
+def artifact_kind(path: str) -> str:
+    suffix = Path(path).suffix.lower().lstrip(".")
+    if suffix in {"md", "markdown"}:
+        return "markdown"
+    if suffix in {"json"}:
+        return "json"
+    if suffix in {"xlsx", "xlsm"}:
+        return "xlsx"
+    if suffix in {"pptx"}:
+        return "pptx"
+    if suffix in {"drawio"}:
+        return "drawio"
+    if suffix in {"log", "txt"}:
+        return "log" if suffix == "log" else "other"
+    return "other"
+
+
+def normalize_capability_definition(
+    manifest: dict[str, Any],
+    *,
+    agent_id: str,
+    capability_path: Path | None = None,
+) -> dict[str, Any]:
+    execution = manifest.get("execution") if isinstance(manifest.get("execution"), dict) else {}
+    outputs = manifest.get("outputs") if isinstance(manifest.get("outputs"), dict) else {}
+    entrypoint = manifest.get("entrypoint") if isinstance(manifest.get("entrypoint"), dict) else {}
+    capability_id = str(manifest.get("id") or "")
+    short_id = capability_id.rsplit(".", 1)[-1] if capability_id else ""
+    return {
+        "id": capability_id,
+        "short_id": short_id,
+        "agent_id": agent_id,
+        "path": str(capability_path.resolve().relative_to(ROOT)) if capability_path else None,
+        "entrypoint": entrypoint,
+        "inputs": manifest.get("inputs") if isinstance(manifest.get("inputs"), dict) else {},
+        "outputs": {
+            **outputs,
+            "artifacts": normalize_capability_artifacts(outputs.get("artifacts")),
+        },
+        "requires": manifest.get("requires") if isinstance(manifest.get("requires"), dict) else {},
+        "runtime": manifest.get("runtime") if isinstance(manifest.get("runtime"), dict) else {},
+        "execution": {
+            "modes": list(execution.get("modes") or []),
+            "idempotency": execution.get("idempotency"),
+            "timeout_seconds": execution.get("timeout_seconds"),
+        },
+        "policy": capability_policy(manifest),
+    }
+
+
+def capability_request_metadata(request: CapabilityRunRequest) -> dict[str, Any]:
+    return {
+        "origin": request.origin,
+        "request_id": request.request_id,
+        "inputs": dict(request.inputs or {}),
+        "source_id": request.source_id,
+        "dry_run": request.dry_run,
+    }
+
+
+def structured_inputs_to_argv(request: CapabilityRunRequest) -> list[str]:
+    args = list(request.capability_args)
+    if request.source_id and "--source" not in args and not any(item.startswith("--source=") for item in args):
+        args.extend(["--source", request.source_id])
+    if request.dry_run and "--dry-run" not in args:
+        args.append("--dry-run")
+    return args

package/runtime/cli/aikit/core/requests.py

@@ -0,0 +1,69 @@
+"""Structured requests for reusable Agent DevKit core calls."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Iterable
+
+
+CAPABILITY_RUN_ORIGINS = {"cli", "mcp", "scheduler", "agent-prompt", "core"}
+
+
+@dataclass(frozen=True)
+class AgentPromptRequest:
+    prompt: str
+    llm: str | None = None
+    dry_run: bool = False
+    session_id: str | None = None
+    new_session: bool = False
+    no_llm_fallback: bool = False
+    prog_name: str = "agent"
+    project: str | None = None
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.prompt, str):
+            raise ValueError("AgentPromptRequest.prompt must be a string")
+        if not isinstance(self.prog_name, str) or not self.prog_name.strip():
+            raise ValueError("AgentPromptRequest.prog_name must be a non-empty string")
+
+
+@dataclass(frozen=True)
+class CapabilityRunRequest:
+    agent_id: str
+    capability_id: str
+    capability_args: Iterable[str] = ()
+    capture_output: bool = True
+    origin: str = "core"
+    request_id: str | None = None
+    inputs: dict[str, Any] | None = None
+    source_id: str | None = None
+    dry_run: bool = False
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.agent_id, str) or not self.agent_id.strip():
+            raise ValueError("CapabilityRunRequest.agent_id must be a non-empty string")
+        if not isinstance(self.capability_id, str) or not self.capability_id.strip():
+            raise ValueError("CapabilityRunRequest.capability_id must be a non-empty string")
+        if self.capability_args is None:
+            object.__setattr__(self, "capability_args", ())
+        elif isinstance(self.capability_args, str):
+            raise ValueError("CapabilityRunRequest.capability_args must be an iterable of strings, not a string")
+        args = tuple(self.capability_args)
+        if not all(isinstance(item, str) for item in args):
+            raise ValueError("CapabilityRunRequest.capability_args must contain only strings")
+        object.__setattr__(self, "capability_args", args)
+        if not isinstance(self.capture_output, bool):
+            raise ValueError("CapabilityRunRequest.capture_output must be a boolean")
+        if self.origin not in CAPABILITY_RUN_ORIGINS:
+            allowed = ", ".join(sorted(CAPABILITY_RUN_ORIGINS))
+            raise ValueError(f"CapabilityRunRequest.origin must be one of: {allowed}")
+        if self.request_id is not None and not isinstance(self.request_id, str):
+            raise ValueError("CapabilityRunRequest.request_id must be a string when provided")
+        if self.source_id is not None and not isinstance(self.source_id, str):
+            raise ValueError("CapabilityRunRequest.source_id must be a string when provided")
+        if self.inputs is None:
+            object.__setattr__(self, "inputs", {})
+        elif not isinstance(self.inputs, dict):
+            raise ValueError("CapabilityRunRequest.inputs must be a mapping when provided")
+        if not isinstance(self.dry_run, bool):
+            raise ValueError("CapabilityRunRequest.dry_run must be a boolean")

package/runtime/cli/aikit/core/runtime.py

@@ -0,0 +1,64 @@
+"""Core runtime facade independent from CLI argument parsing."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from cli.aikit.capability_runtime import (
+    list_agents,
+    list_all_capabilities,
+    list_capabilities,
+    load_agent,
+    load_capability,
+    run_capability,
+    summarize_agent,
+)
+from cli.aikit.core.capability_contract import structured_inputs_to_argv
+from cli.aikit.core.requests import AgentPromptRequest, CapabilityRunRequest
+from cli.aikit.natural_prompt_runtime import run_agent_prompt_request
+
+
+def run_agent_prompt(request: AgentPromptRequest) -> dict[str, Any]:
+    return run_agent_prompt_request(request)
+
+
+def list_agent_modules() -> dict[str, Any]:
+    return {"kind": "agents", "items": list_agents()}
+
+
+def list_capability_modules(agent_id: str | None = None) -> dict[str, Any]:
+    if agent_id:
+        agent = load_agent(agent_id)
+        return {
+            "kind": "capabilities",
+            "agent": agent["id"],
+            "items": list_capabilities(agent["path"]),
+        }
+    return {
+        "kind": "capabilities",
+        "agent": None,
+        "items": list_all_capabilities(),
+    }
+
+
+def inspect_capability_request(agent_id: str, capability_id: str) -> dict[str, Any]:
+    agent = load_agent(agent_id)
+    capability = load_capability(agent["path"], capability_id)
+    return {
+        "kind": "capability",
+        "agent": summarize_agent(agent),
+        "capability": capability,
+    }
+
+
+def run_capability_request(request: CapabilityRunRequest) -> dict[str, Any]:
+    agent = load_agent(request.agent_id)
+    return run_capability(
+        agent,
+        request.capability_id,
+        structured_inputs_to_argv(request),
+        capture_output=request.capture_output,
+        origin=request.origin,
+        request_id=request.request_id,
+        request_data=dict(request.inputs or {}),
+    )

package/runtime/cli/aikit/decision_store.py

@@ -122,6 +122,23 @@ def reset_decisions(category: str | None = None) -> dict[str, Any]:
     return {"kind": "decisions-reset", "status": "reset", "category": category, "path": str(path)}
 
 
+def forget_decision(category: str, item_id: str) -> dict[str, Any]:
+    validate_category(category)
+    validate_item_id(item_id)
+    data = load_decisions()
+    key = decision_key(category, item_id)
+    removed = data.get("items", {}).pop(key, None)
+    path = save_decisions(data)
+    return {
+        "kind": "decision-forget",
+        "status": "forgotten" if isinstance(removed, dict) else "not-found",
+        "path": str(path),
+        "category": category,
+        "id": item_id,
+        "removed": public_decision(removed) if isinstance(removed, dict) else None,
+    }
+
+
 def is_disabled(category: str, item_id: str) -> bool:
     decision = get_decision(category, item_id)
     return bool(decision and decision.get("state") in {"disabled_by_user", "denied_by_user"})

package/runtime/cli/aikit/diagnostics.py

@@ -7,7 +7,7 @@ import os
 from pathlib import Path
 from typing import Any
 
-from cli.aikit.app_home import APP_DIRS, app_home
+from cli.aikit.app_home import APP_DIRS, app_home, app_home_status
 from cli.aikit.llm import config_path as llm_config_path
 from cli.aikit.llm import doctor_backends
 from cli.aikit.lock import lock_path, lock_status, read_lock
@@ -44,6 +44,7 @@ def runtime_diagnostics(
         "status": status,
         "root": str(root),
         "app_home": str(app_home()),
+        "app_home_status": app_home_status(),
         "app_dirs": {
             name: {
                 "path": str(app_home() / name),
@@ -204,14 +205,17 @@ def claude_source(root: Path) -> dict[str, Any]:
     skill = plugin / "skills" / "ai-devkit-router" / "SKILL.md"
     commands = plugin / "commands"
     scripts = plugin / "scripts"
+    agents = plugin / "agents"
     return {
         "id": "claude-code",
         "path": str(plugin),
         "manifest_exists": manifest.exists(),
         "skill_exists": skill.exists(),
         "commands_exists": commands.is_dir(),
+        "agents_exists": agents.is_dir(),
+        "subagents": sorted(path.stem for path in agents.glob("*.md") if path.name != "README.md") if agents.is_dir() else [],
         "scripts_exists": scripts.is_dir(),
-        "status": "ok" if manifest.exists() and skill.exists() and commands.is_dir() and scripts.is_dir() else "error",
+        "status": "ok" if manifest.exists() and skill.exists() and commands.is_dir() and agents.is_dir() and scripts.is_dir() else "error",
     }
 
 
@@ -246,11 +250,14 @@ def installed_plugins(base: Path, lock: dict[str, Any]) -> dict[str, Any]:
         claude_plugin = base / ".claude" / "plugins" / "ai-devkit" / "plugin.json"
         claude_skill = base / ".claude" / "skills" / "ai-devkit-router" / "SKILL.md"
         claude_commands = base / ".claude" / "commands"
+        claude_agents = base / ".claude" / "plugins" / "ai-devkit" / "agents"
         status["claude-code"] = {
             "plugin_exists": claude_plugin.exists(),
             "skill_exists": claude_skill.exists(),
             "commands_exists": claude_commands.is_dir(),
-            "status": "ok" if claude_plugin.exists() and claude_skill.exists() and claude_commands.is_dir() else "missing",
+            "agents_exists": claude_agents.is_dir(),
+            "subagents": sorted(path.stem for path in claude_agents.glob("*.md") if path.name != "README.md") if claude_agents.is_dir() else [],
+            "status": "ok" if claude_plugin.exists() and claude_skill.exists() and claude_commands.is_dir() and claude_agents.is_dir() else "missing",
         }
     if "claude-desktop" in hosts:
         claude_desktop_plugin = base / ".claude" / "plugins" / "ai-devkit-skill" / "plugin.json"