agent-devkit 0.2.0 → 0.3.1

package/runtime/cli/aikit/cli_parser.py

@@ -9,8 +9,10 @@ DETERMINISTIC_COMMANDS = (
     "architecture",
     "roadmap",
     "catalog",
+    "plan",
     "route",
     "eval",
+    "secret",
     "secrets",
     "agents",
     "capabilities",
@@ -18,12 +20,14 @@ DETERMINISTIC_COMMANDS = (
     "run",
     "doctor",
     "commands",
+    "onboard",
     "llm",
     "providers",
     "provider",
     "credential",
     "source",
     "memory",
+    "shared-memory",
     "personality",
     "setup",
     "alias",
@@ -40,17 +44,23 @@ DETERMINISTIC_COMMANDS = (
     "tools",
     "integrations",
     "skills",
+    "skill",
+    "script",
     "decisions",
     "ollama",
+    "local-llm",
     "mcp",
     "local",
     "workflow",
+    "team",
+    "knowledge",
+    "knowledge-base",
     "contribute",
     "contribution",
     "install",
     "wizard",
 )
-LLM_COMMANDS = ("agent",)
+LLM_COMMANDS = ("agent", "execute", "orchestrate")
 
 
 def build_parser(prog: str | None = None) -> argparse.ArgumentParser:
@@ -87,6 +97,10 @@ def build_parser(prog: str | None = None) -> argparse.ArgumentParser:
     commands_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
     commands_parser.add_argument("action", nargs="?", default="list", choices=["list"])
 
+    onboard_parser = subparsers.add_parser("onboard", help="inspect startup state and guide first use")
+    onboard_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
+    onboard_parser.add_argument("action", nargs="?", default="show", choices=["show", "minimal", "complete"])
+
     architecture_parser = subparsers.add_parser("architecture", help="show the Agent DevKit architecture contract")
     architecture_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
     architecture_parser.add_argument("action", nargs="?", default="show", choices=["show"])
@@ -98,8 +112,28 @@ def build_parser(prog: str | None = None) -> argparse.ArgumentParser:
 
     catalog_parser = subparsers.add_parser("catalog", help="search and inspect the Agent DevKit catalog")
     catalog_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
-    catalog_parser.add_argument("action", nargs="?", default="list", choices=["list", "search", "show"])
+    catalog_parser.add_argument("action", nargs="?", default="list", choices=["list", "search", "show", "inspect", "rebuild-index"])
     catalog_parser.add_argument("query", nargs="?")
+    catalog_parser.add_argument("target", nargs="?")
+    catalog_parser.add_argument("--type", dest="item_type")
+    catalog_parser.add_argument("--provider")
+    catalog_parser.add_argument("--status")
+    catalog_parser.add_argument("--write-policy")
+    catalog_parser.add_argument("--readiness")
+
+    for command_name, help_text in (
+        ("plan", "build an explicit agentic execution plan without executing it"),
+        ("execute", "execute a natural-language task through the agentic runtime"),
+        ("orchestrate", "orchestrate a natural-language task with planning and review gates"),
+    ):
+        agentic_parser = subparsers.add_parser(command_name, help=help_text)
+        agentic_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
+        agentic_parser.add_argument("--llm", help="LLM backend id to use")
+        agentic_parser.add_argument("--dry-run", action="store_true", help="show execution plan without invoking LLM or external writes")
+        agentic_parser.add_argument("--no-llm-fallback", action="store_true", help="disable automatic fallback to secondary LLM backends")
+        agentic_parser.add_argument("--session", dest="session_id", help="resume a local conversation session")
+        agentic_parser.add_argument("--new-session", action="store_true", help="start a new local conversation session")
+        agentic_parser.add_argument("prompt", nargs=argparse.REMAINDER)
 
     route_parser = subparsers.add_parser("route", help="explain deterministic routing without execution")
     route_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
@@ -119,6 +153,14 @@ def build_parser(prog: str | None = None) -> argparse.ArgumentParser:
     secrets_parser.add_argument("key", nargs="?")
     secrets_parser.add_argument("--env", dest="env")
 
+    secret_parser = subparsers.add_parser("secret", help="manage safe secret references")
+    secret_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
+    secret_parser.add_argument("action", nargs="?", default="doctor", choices=["set", "get", "list", "delete", "doctor"])
+    secret_parser.add_argument("provider", nargs="?")
+    secret_parser.add_argument("key", nargs="?")
+    secret_parser.add_argument("--env", dest="env")
+    secret_parser.add_argument("--ref", dest="secret_ref")
+
     providers_parser = subparsers.add_parser("providers", help="list provider registry entries")
     providers_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
     providers_parser.add_argument("action", nargs="?", default="list", choices=["list"])
@@ -159,20 +201,42 @@ def build_parser(prog: str | None = None) -> argparse.ArgumentParser:
     wizard_parser.add_argument("--status", help="filter wizard list by status")
     wizard_parser.add_argument("--no-run", action="store_true", help="do not resume the original prompt after completing a wizard")
 
-    memory_parser = subparsers.add_parser("memory", help="inspect or reset local AI DevKit memory")
+    memory_parser = subparsers.add_parser("memory", help="inspect, backup or reset local AI DevKit memory")
     memory_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
-    memory_parser.add_argument("action", nargs="?", default="show", choices=["show", "path", "reset"])
+    memory_parser.add_argument("action", nargs="?", default="show", choices=["show", "path", "reset", "backup", "share", "shared", "read", "submit", "review", "publish"])
+    memory_parser.add_argument("memory_id", nargs="?")
+    memory_parser.add_argument("submission_id", nargs="?")
     memory_parser.add_argument("--agent", dest="agent_id")
     memory_parser.add_argument("--source", dest="source_id")
+    memory_parser.add_argument("--title")
+    memory_parser.add_argument("--content")
+    memory_parser.add_argument("--key", dest="contributor_key")
+    memory_parser.add_argument("--owner-key", dest="owner_key")
+    memory_parser.add_argument("--encrypted", action="store_true", help="create an encrypted portable memory backup package")
+    memory_parser.add_argument("--passphrase-env", help="environment variable that contains the memory backup passphrase")
+    memory_parser.add_argument("--file", dest="backup_file", help="restore a portable memory backup package")
     memory_parser.add_argument("--all", action="store_true", help="reset all local memory")
     memory_parser.add_argument("--sessions", action="store_true", help="reset local conversation sessions")
     memory_parser.add_argument("--tasks", action="store_true", help="reset local task schedules")
     memory_parser.add_argument("--cache", action="store_true", help="reset local cache")
+    memory_parser.add_argument("--yes", action="store_true")
+
+    shared_memory_parser = subparsers.add_parser("shared-memory", help="manage owner-reviewed shared memories")
+    shared_memory_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
+    shared_memory_parser.add_argument("action", nargs="?", default="list", choices=["create", "list", "status", "read", "submit", "review", "publish"])
+    shared_memory_parser.add_argument("memory_id", nargs="?")
+    shared_memory_parser.add_argument("submission_id", nargs="?")
+    shared_memory_parser.add_argument("--title")
+    shared_memory_parser.add_argument("--content")
+    shared_memory_parser.add_argument("--key", dest="contributor_key")
+    shared_memory_parser.add_argument("--owner-key", dest="owner_key")
+    shared_memory_parser.add_argument("--yes", action="store_true")
 
     personality_parser = subparsers.add_parser("personality", help="inspect or update local Agent DevKit personality")
     personality_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
     personality_parser.add_argument("action", nargs="?", default="show", choices=["show", "edit", "reset"])
     personality_parser.add_argument("--name", dest="agent_name", help="public agent name")
+    personality_parser.add_argument("--rename", dest="agent_name", help="rename the local agent")
     personality_parser.add_argument("--user-name", help="user name")
     personality_parser.add_argument("--language", help="default response language")
     personality_parser.add_argument("--tone", help="response tone")
@@ -182,7 +246,7 @@ def build_parser(prog: str | None = None) -> argparse.ArgumentParser:
     setup_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
     setup_parser.add_argument("--dry-run", action="store_true", help="show setup plan without installing external tools")
     setup_parser.add_argument("--yes", action="store_true", help="confirm setup actions")
-    setup_parser.add_argument("--set-default", action="store_true", help="make the mini-brain Ollama backend the default LLM")
+    setup_parser.add_argument("--set-default", action="store_true", help="make the embedded mini-brain the default LLM")
     setup_parser.add_argument("action", nargs="?", default="plan", choices=["plan", "personality", "mini-brain"])
 
     alias_parser = subparsers.add_parser("alias", help="manage local command aliases for agent")
@@ -310,6 +374,13 @@ def build_parser(prog: str | None = None) -> argparse.ArgumentParser:
     ollama_parser.add_argument("--yes", action="store_true", help="confirm Ollama model or update operation")
     ollama_parser.add_argument("--dry-run", action="store_true", help="show Ollama operation without executing it")
 
+    local_llm_parser = subparsers.add_parser("local-llm", help="inspect and manage local LLM workers")
+    local_llm_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
+    local_llm_parser.add_argument("action", nargs="?", default="list", choices=["list", "doctor", "models", "install", "remove", "benchmark"])
+    local_llm_parser.add_argument("model", nargs="?")
+    local_llm_parser.add_argument("--yes", action="store_true", help="confirm local model operation")
+    local_llm_parser.add_argument("--dry-run", action="store_true", help="show local model operation without executing it")
+
     llm_parser = subparsers.add_parser("llm", help="manage LLM backends")
     llm_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
     llm_parser.add_argument(
@@ -344,8 +415,10 @@ def build_parser(prog: str | None = None) -> argparse.ArgumentParser:
 
     agents_parser = subparsers.add_parser("agents", aliases=["a"], help="list, search or inspect available agents")
     agents_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
-    agents_parser.add_argument("action", nargs="?", default="list", choices=["list", "search", "show"])
+    agents_parser.add_argument("action", nargs="?", default="list", choices=["list", "search", "show", "create", "validate", "local-list"])
     agents_parser.add_argument("query", nargs="?")
+    agents_parser.add_argument("--description")
+    agents_parser.add_argument("--force", action="store_true")
 
     capabilities_parser = subparsers.add_parser(
         "capabilities",
@@ -360,9 +433,34 @@ def build_parser(prog: str | None = None) -> argparse.ArgumentParser:
 
     local_parser = subparsers.add_parser("local", help="manage local Agent DevKit extensions")
     local_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
-    local_parser.add_argument("action", nargs="?", default="list", choices=["list", "add", "disable", "enable", "remove", "validate"])
+    local_parser.add_argument("action", nargs="?", default="list", choices=["list", "add", "disable", "enable", "remove", "validate", "automation", "agents", "agent"])
     local_parser.add_argument("extension_id", nargs="?")
+    local_parser.add_argument("local_item_id", nargs="?")
     local_parser.add_argument("--path")
+    local_parser.add_argument("--title")
+    local_parser.add_argument("--prompt")
+    local_parser.add_argument("--command", dest="local_command")
+    local_parser.add_argument("--every")
+    local_parser.add_argument("--cron")
+    local_parser.add_argument("--force", action="store_true")
+    local_parser.add_argument("--yes", action="store_true")
+
+    skill_parser = subparsers.add_parser("skill", help="create and manage local Agent DevKit skills")
+    skill_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
+    skill_parser.add_argument("action", nargs="?", default="list", choices=["create", "list", "show", "update", "delete"])
+    skill_parser.add_argument("skill_id", nargs="?")
+    skill_parser.add_argument("--description")
+    skill_parser.add_argument("--force", action="store_true")
+    skill_parser.add_argument("--yes", action="store_true")
+
+    script_parser = subparsers.add_parser("script", help="create and run local scripts")
+    script_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
+    script_parser.add_argument("action", nargs="?", default="list", choices=["create", "list", "run"])
+    script_parser.add_argument("script_id", nargs="?")
+    script_parser.add_argument("--command", dest="script_command")
+    script_parser.add_argument("--force", action="store_true")
+    script_parser.add_argument("--dry-run", action="store_true")
+    script_parser.add_argument("--yes", action="store_true")
 
     workflow_parser = subparsers.add_parser("workflow", help="list, install or run installable workflows")
     workflow_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
@@ -371,6 +469,44 @@ def build_parser(prog: str | None = None) -> argparse.ArgumentParser:
     workflow_parser.add_argument("--dry-run", action="store_true")
     workflow_parser.add_argument("--yes", action="store_true")
 
+    team_parser = subparsers.add_parser("team", help="manage project-local team profiles")
+    team_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
+    team_parser.add_argument("action", nargs="?", default="status", choices=["init", "status", "doctor", "onboard", "profile"])
+    team_parser.add_argument("profile_action", nargs="?", choices=["list", "show", "use", "export", "import"])
+    team_parser.add_argument("profile_id", nargs="?")
+    team_parser.add_argument("--path", dest="profile_path")
+    team_parser.add_argument("--force", action="store_true")
+
+    knowledge_parser = subparsers.add_parser("knowledge", help="manage file-first shared knowledge bases")
+    knowledge_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
+    knowledge_parser.add_argument(
+        "action",
+        nargs="?",
+        default="doctor",
+        choices=["init", "doctor", "search", "index", "reindex", "snapshot", "review", "curate", "publish", "sync"],
+    )
+    knowledge_parser.add_argument("target", nargs="?")
+    knowledge_parser.add_argument("snapshot_action", nargs="?")
+    knowledge_parser.add_argument("--title")
+    knowledge_parser.add_argument("--content")
+    knowledge_parser.add_argument("--from-file")
+    knowledge_parser.add_argument("--type", dest="entry_type")
+    knowledge_parser.add_argument("--owner-agent")
+    knowledge_parser.add_argument("--force", action="store_true")
+    knowledge_parser.add_argument("--yes", action="store_true")
+
+    knowledge_base_parser = subparsers.add_parser("knowledge-base", help="manage file-first shared knowledge bases")
+    knowledge_base_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
+    knowledge_base_parser.add_argument(
+        "action",
+        nargs="?",
+        default="status",
+        choices=["create", "join", "status", "tokens", "rotate-token"],
+    )
+    knowledge_base_parser.add_argument("target", nargs="?")
+    knowledge_base_parser.add_argument("--provider", default="local")
+    knowledge_base_parser.add_argument("--force", action="store_true")
+
     for contribution_command in ("contribute", "contribution"):
         contribution_parser = subparsers.add_parser(contribution_command, help="prepare or review local extension contributions")
         contribution_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
@@ -378,9 +514,11 @@ def build_parser(prog: str | None = None) -> argparse.ArgumentParser:
             "action",
             nargs="?",
             default="list" if contribution_command == "contribute" else "checklist",
-            choices=["list", "prepare", "validate", "review", "checklist"],
+            choices=["list", "prepare", "validate", "review", "checklist", "pr"],
         )
         contribution_parser.add_argument("extension_id", nargs="?")
+        contribution_parser.add_argument("--dry-run", action="store_true")
+        contribution_parser.add_argument("--yes", action="store_true")
 
     inspect_parser = subparsers.add_parser(
         "inspect",

package/runtime/cli/aikit/contribution.py

@@ -2,17 +2,21 @@
 
 from __future__ import annotations
 
+import os
 import re
 from pathlib import Path
 from typing import Any
 
 from cli.aikit.extensions import load_extensions
+from cli.aikit.memory import sanitize_segment
 
 
 CONTRIBUTION_SCHEMA_VERSION = "agent-devkit.contribution/v1"
 SECRET_PATTERN = re.compile(r"(token|secret|password|api[_-]?key|pat)\s*[:=]", re.IGNORECASE)
 PRIVATE_URL_PATTERN = re.compile(r"https?://(?:localhost|127\.0\.0\.1|10\.|192\.168\.|172\.(?:1[6-9]|2\d|3[0-1])\.)", re.IGNORECASE)
 LOCAL_PATH_PATTERN = re.compile(r"(/Users/|/home/|C:\\\\Users\\\\)")
+PII_PATTERN = re.compile(r"\b\d{3}\.\d{3}\.\d{3}-\d{2}\b|\b[\w.+-]+@[\w.-]+\.[A-Za-z]{2,}\b")
+CORPORATE_TERMS_ENV = "AGENT_DEVKIT_CORPORATE_TERMS"
 
 
 def contribution_list() -> dict[str, Any]:
@@ -21,7 +25,15 @@ def contribution_list() -> dict[str, Any]:
         "kind": "contributions",
         "schema_version": CONTRIBUTION_SCHEMA_VERSION,
         "status": "ok",
-        "items": [{"id": item.get("id"), "path": item.get("path"), "enabled": item.get("enabled") is True} for item in extensions],
+        "items": [
+            {
+                "id": item.get("id"),
+                "path": sanitize_path_for_report(item.get("path")),
+                "path_sanitized": True,
+                "enabled": item.get("enabled") is True,
+            }
+            for item in extensions
+        ],
     }
 
 
@@ -32,6 +44,7 @@ def contribution_checklist(extension_id: str) -> dict[str, Any]:
             "kind": "contribution-checklist",
             "schema_version": CONTRIBUTION_SCHEMA_VERSION,
             "status": "blocked",
+            "exit_code": 2,
             "extension_id": extension_id,
             "checks": [{"id": "extension-exists", "status": "failed"}],
         }
@@ -40,6 +53,7 @@ def contribution_checklist(extension_id: str) -> dict[str, Any]:
         "kind": "contribution-checklist",
         "schema_version": CONTRIBUTION_SCHEMA_VERSION,
         "status": "passed" if all(check["status"] == "passed" for check in checks) else "blocked",
+        "exit_code": 0 if all(check["status"] == "passed" for check in checks) else 2,
         "extension_id": extension_id,
         "checks": checks,
         "requires_human_confirmation_for_pr": True,
@@ -54,22 +68,79 @@ def contribution_validate(extension_id: str) -> dict[str, Any]:
 
 def contribution_prepare(extension_id: str) -> dict[str, Any]:
     checklist = contribution_checklist(extension_id)
+    status = "planned" if checklist["status"] == "passed" else "blocked"
     return {
         "kind": "contribution-prepare",
         "schema_version": CONTRIBUTION_SCHEMA_VERSION,
-        "status": "planned" if checklist["status"] == "passed" else "blocked",
+        "status": status,
+        "exit_code": 0 if status == "planned" else 2,
         "extension_id": extension_id,
         "checklist": checklist,
         "creates_pr": False,
     }
 
 
+def contribution_pr(extension_id: str, *, dry_run: bool = True, yes: bool = False) -> dict[str, Any]:
+    checklist = contribution_checklist(extension_id)
+    safe_id = sanitize_segment(extension_id)
+    plan = {
+        "external_writes": True,
+        "requires_confirmation": True,
+        "mode": "dry-run" if dry_run or not yes else "apply",
+        "commands": [
+            f"git checkout -b feat/contribution-{safe_id}",
+            "git add <sanitized-extension-files>",
+            f"git commit -m 'Add Agent DevKit contribution {safe_id}'",
+            "gh pr create --fill",
+        ],
+        "stores_secret": False,
+        "local_paths_sanitized": True,
+    }
+    if checklist["status"] != "passed":
+        return {
+            "kind": "contribution-pr",
+            "schema_version": CONTRIBUTION_SCHEMA_VERSION,
+            "status": "blocked",
+            "exit_code": 2,
+            "extension_id": extension_id,
+            "checklist": checklist,
+            "plan": plan,
+            "reason": "contribution_checklist_failed",
+        }
+    if dry_run or not yes:
+        return {
+            "kind": "contribution-pr",
+            "schema_version": CONTRIBUTION_SCHEMA_VERSION,
+            "status": "planned",
+            "exit_code": 0,
+            "extension_id": extension_id,
+            "checklist": checklist,
+            "plan": plan,
+            "message": "PR contribution plan generated in report-only mode.",
+        }
+    return {
+        "kind": "contribution-pr",
+        "schema_version": CONTRIBUTION_SCHEMA_VERSION,
+        "status": "blocked",
+        "exit_code": 2,
+        "extension_id": extension_id,
+        "checklist": checklist,
+        "plan": plan,
+        "reason": "external_write_confirmation_required",
+        "next_steps": [
+            "Review the generated plan and run the git/gh commands manually or through a future confirmed writer.",
+            "Agent DevKit does not open contribution PRs automatically from this runtime path.",
+        ],
+    }
+
+
 def contribution_review(extension_id: str) -> dict[str, Any]:
     checklist = contribution_checklist(extension_id)
     return {
         "kind": "contribution-review",
         "schema_version": CONTRIBUTION_SCHEMA_VERSION,
         "status": checklist["status"],
+        "exit_code": 0 if checklist["status"] == "passed" else 2,
         "extension_id": extension_id,
         "findings": [check for check in checklist["checks"] if check["status"] != "passed"],
     }
@@ -84,11 +155,24 @@ def find_extension(extension_id: str) -> dict[str, Any] | None:
 
 def contribution_checks(path: Path) -> list[dict[str, Any]]:
     text = read_extension_text(path)
+    corporate_terms = configured_corporate_terms()
+    structure = extension_structure_kind(path)
     return [
         {"id": "extension-exists", "status": "passed" if path.exists() else "failed"},
+        {
+            "id": "recognized-extension-structure",
+            "status": "passed" if structure else "failed",
+            "type": structure or "unknown",
+        },
         {"id": "no-secret-literals", "status": "failed" if SECRET_PATTERN.search(text) else "passed"},
         {"id": "no-private-url", "status": "failed" if PRIVATE_URL_PATTERN.search(text) else "passed"},
         {"id": "no-local-path", "status": "failed" if LOCAL_PATH_PATTERN.search(text) else "passed"},
+        {"id": "no-pii", "status": "failed" if PII_PATTERN.search(text) else "passed"},
+        {
+            "id": "no-corporate-name",
+            "status": "failed" if contains_configured_corporate_term(text, corporate_terms) else "passed",
+            "terms_configured": len(corporate_terms),
+        },
         {"id": "human-pr-confirmation", "status": "passed"},
     ]
 
@@ -103,3 +187,49 @@ def read_extension_text(path: Path) -> str:
         if child.is_file() and child.suffix in {".md", ".yaml", ".yml", ".json", ".py", ".sh", ".txt"}:
             chunks.append(child.read_text(encoding="utf-8", errors="ignore")[:50_000])
     return "\n".join(chunks)[:300_000]
+
+
+def extension_structure_kind(path: Path) -> str | None:
+    if not path.exists():
+        return None
+    if path.is_file():
+        if path.suffix in {".py", ".sh"}:
+            return "script"
+        if path.suffix in {".md", ".yaml", ".yml", ".json"}:
+            return "file"
+        return None
+    if (path / "agent.yaml").exists():
+        return "agent"
+    if (path / "SKILL.md").exists() or (path / "skill.md").exists():
+        return "skill"
+    if any((path / name).exists() for name in ("workflow.yaml", "workflow.yml")):
+        return "workflow"
+    if any(path.rglob("agent.yaml")):
+        return "agent"
+    if any(path.rglob("SKILL.md")) or any(path.rglob("skill.md")):
+        return "skill"
+    if any(path.rglob("workflow.yaml")) or any(path.rglob("workflow.yml")):
+        return "workflow"
+    if any(child.is_file() and child.suffix in {".py", ".sh"} for child in path.rglob("*")):
+        return "script"
+    return None
+
+
+def sanitize_path_for_report(value: Any) -> str | None:
+    if not value:
+        return None
+    name = Path(str(value)).name
+    return f"<local-extension-path>/{sanitize_segment(name)}"
+
+
+def configured_corporate_terms() -> list[str]:
+    raw = os.environ.get(CORPORATE_TERMS_ENV, "")
+    terms = [term.strip().lower() for term in re.split(r"[,;\n]+", raw) if len(term.strip()) >= 3]
+    return sorted(set(terms))
+
+
+def contains_configured_corporate_term(text: str, terms: list[str]) -> bool:
+    if not terms:
+        return False
+    lowered = text.lower()
+    return any(term in lowered for term in terms)

package/runtime/cli/aikit/doctor_runtime.py

@@ -7,9 +7,18 @@ from pathlib import Path
 from typing import Any
 
 from cli.aikit.capability_runtime import list_agents, list_all_capabilities
+from cli.aikit.catalog import catalog_list
 from cli.aikit.diagnostics import build_diagnostics
+from cli.aikit.eval import eval_list
+from cli.aikit.extensions import local_extensions_list
+from cli.aikit.knowledge_base import knowledge_doctor
 from cli.aikit.lock import lock_status
+from cli.aikit.local_llm import local_llm_doctor
 from cli.aikit.runtime_paths import AGENTS_DIR, ROOT
+from cli.aikit.secrets import secrets_doctor
+from cli.aikit.specialist_readiness import specialist_readiness
+from cli.aikit.team import team_status
+from cli.aikit.workflows import workflow_list
 
 
 def doctor(project: str | None = None, home: str | None = None, scope: str = "auto") -> dict[str, Any]:
@@ -50,6 +59,7 @@ def doctor(project: str | None = None, home: str | None = None, scope: str = "au
         runtime_status="ok" if not errors else "error",
         locks=locks,
     )
+    operational = operational_diagnostics(project_path)
 
     return {
         "kind": "doctor",
@@ -68,6 +78,7 @@ def doctor(project: str | None = None, home: str | None = None, scope: str = "au
         "warnings": warnings,
         "locks": locks,
         "diagnostics": diagnostics,
+        "operational": operational,
     }
 
 
@@ -77,3 +88,77 @@ def doctor_project_path(project: str | None, scope: str) -> Path | None:
     if scope == "project":
         return Path.cwd()
     return None
+
+
+def operational_diagnostics(project_path: Path | None = None) -> dict[str, Any]:
+    return {
+        "catalog": summarize_call(lambda: catalog_list(ROOT), count_key="count"),
+        "evals": summarize_call(lambda: eval_list(), count_path=("suites",)),
+        "workflows": summarize_call(lambda: workflow_list(ROOT), count_path=("items",)),
+        "secret_refs": summarize_secret_refs(),
+        "local_llm": summarize_local_llm(),
+        "specialists": summarize_specialists(),
+        "extensions": summarize_call(lambda: local_extensions_list(), count_path=("items",)),
+        "team": summarize_call(lambda: team_status(project_path or Path.cwd())),
+        "knowledge": summarize_call(lambda: knowledge_doctor(project_path or Path.cwd())),
+    }
+
+
+def summarize_call(factory, *, count_key: str | None = None, count_path: tuple[str, ...] | None = None) -> dict[str, Any]:
+    try:
+        payload = factory()
+    except Exception as exc:  # noqa: BLE001 - doctor must report subsystem failures.
+        return {"status": "error", "error": type(exc).__name__}
+    count = payload.get(count_key) if count_key else None
+    if count is None and count_path:
+        value: Any = payload
+        for key in count_path:
+            value = value.get(key) if isinstance(value, dict) else None
+        count = len(value) if isinstance(value, list) else None
+    return {"status": payload.get("status", "ok"), "kind": payload.get("kind"), "count": count}
+
+
+def summarize_secret_refs() -> dict[str, Any]:
+    try:
+        payload = secrets_doctor()
+    except Exception as exc:  # noqa: BLE001
+        return {"status": "error", "error": type(exc).__name__}
+    return {
+        "status": payload.get("status"),
+        "kind": payload.get("kind"),
+        "references": len(payload.get("references") or []),
+        "stored_values": payload.get("stored_values") is True,
+    }
+
+
+def summarize_local_llm() -> dict[str, Any]:
+    try:
+        payload = local_llm_doctor()
+    except Exception as exc:  # noqa: BLE001
+        return {"status": "error", "error": type(exc).__name__}
+    mini = payload.get("mini_brain") if isinstance(payload.get("mini_brain"), dict) else {}
+    ollama = payload.get("ollama") if isinstance(payload.get("ollama"), dict) else {}
+    return {
+        "status": payload.get("status"),
+        "kind": payload.get("kind"),
+        "ollama": ollama.get("status"),
+        "mini_brain": mini.get("status"),
+        "enabled": mini.get("enabled") is True,
+    }
+
+
+def summarize_specialists() -> dict[str, Any]:
+    try:
+        payload = specialist_readiness(ROOT)
+    except Exception as exc:  # noqa: BLE001
+        return {"status": "error", "error": type(exc).__name__}
+    return {
+        "status": payload.get("status"),
+        "kind": payload.get("kind"),
+        "agents_total": payload.get("agents_total"),
+        "agents_with_provider_requirements": payload.get("agents_with_provider_requirements"),
+        "ready_agents": payload.get("ready_agents"),
+        "partial_agents": payload.get("partial_agents"),
+        "needs_setup_agents": payload.get("needs_setup_agents"),
+        "missing_providers": payload.get("missing_providers") or [],
+    }