agent-devkit 0.1.6 → 0.2.0

package/runtime/cli/aikit/agent_registry.py

@@ -7,13 +7,17 @@ from typing import Any
 
 import yaml
 
+from cli.aikit.write_policy import normalize_write_policy, write_policy_public_fields
+
 
 def load_agent_registry(root: Path) -> dict[str, Any]:
     agents_dir = root / "agents"
     agents: dict[str, dict[str, Any]] = {}
     capabilities: dict[str, dict[str, Any]] = {}
+    runtime_roles: dict[str, str] = {}
     if not agents_dir.exists():
-        return {"agents": agents, "capabilities": capabilities}
+        return {"agents": agents, "capabilities": capabilities, "runtime_roles": runtime_roles}
+    provider_map = load_provider_capability_map(root)
     for agent_path in sorted(path for path in agents_dir.iterdir() if path.is_dir()):
         manifest_path = agent_path / "agent.yaml"
         if not manifest_path.exists():
@@ -27,13 +31,25 @@ def load_agent_registry(root: Path) -> dict[str, Any]:
             capability = read_yaml(capability_path)
             capability_id = str(capability.get("id") or capability_path.parent.name)
             short_id = capability_id.rsplit(".", 1)[-1]
+            runtime = normalize_runtime(capability.get("runtime"))
+            provider_resolution = resolve_capability_provider(agent_id, short_id, capability, runtime, provider_map)
+            source_contract = normalize_source_contract(capability.get("source"), runtime=runtime)
             public_capability = {
                 "id": capability_id,
                 "short_id": short_id,
                 "agent_id": agent_id,
                 "name": capability.get("name") or short_id,
                 "purpose": compact(str(capability.get("purpose") or "")),
-                "write_policy": capability.get("write_policy"),
+                "routing": normalize_routing(capability.get("routing")),
+                "runtime": runtime,
+                "runner": ((capability.get("entrypoint") or {}).get("runner")),
+                "provider": provider_resolution.get("provider"),
+                "provider_resolution": provider_resolution,
+                "source": source_contract,
+                "source_contract": source_contract,
+                "write_policy": normalize_write_policy(capability.get("write_policy")),
+                "write_policy_raw": capability.get("write_policy"),
+                **write_policy_public_fields(capability.get("write_policy")),
                 "inputs": capability.get("inputs") or {},
                 "outputs": capability.get("outputs") or {},
                 "integration": capability.get("integration") or {},
@@ -43,8 +59,13 @@ def load_agent_registry(root: Path) -> dict[str, Any]:
             }
             agent["capabilities_index"][short_id] = public_capability
             capabilities[f"{agent_id}/{short_id}"] = public_capability
-        agents[agent_id] = public_agent(agent)
-    return {"agents": agents, "capabilities": capabilities}
+        public = public_agent(agent)
+        agents[agent_id] = public
+        runtime_role = public.get("runtime_role") if isinstance(public.get("runtime_role"), dict) else {}
+        role_kind = str(runtime_role.get("kind") or "").strip()
+        if role_kind:
+            runtime_roles.setdefault(role_kind, agent_id)
+    return {"agents": agents, "capabilities": capabilities, "runtime_roles": runtime_roles}
 
 
 def public_agent(agent: dict[str, Any]) -> dict[str, Any]:
@@ -54,12 +75,18 @@ def public_agent(agent: dict[str, Any]) -> dict[str, Any]:
         "name": agent.get("name") or agent.get("id"),
         "kind": agent.get("kind"),
         "status": agent.get("status"),
+        "version": agent.get("version"),
         "purpose": compact(str(agent.get("purpose") or "")),
+        "routing": normalize_routing(agent.get("routing")),
+        "runtime_role": normalize_runtime_role(agent.get("runtime_role")),
+        "agent_mode": normalize_agent_mode(agent.get("agent_mode")),
         "depends_on_agents": list(agent.get("depends_on_agents") or []),
         "orchestrated_agents": list(surface.get("orchestrated_agents") or []),
         "capabilities": list(agent.get("capabilities") or []),
         "capabilities_index": dict(agent.get("capabilities_index") or {}),
-        "write_policy": agent.get("write_policy"),
+        "write_policy": normalize_agent_write_policy(agent.get("write_policy")),
+        "write_policy_raw": agent.get("write_policy"),
+        "write_policy_metadata": normalize_agent_write_policy_metadata(agent.get("write_policy")),
         "path": agent.get("path"),
     }
 
@@ -78,3 +105,215 @@ def compact(value: str, *, limit: int = 240) -> str:
     if len(text) <= limit:
         return text
     return text[: limit - 3].rstrip() + "..."
+
+
+def normalize_agent_write_policy(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {str(key): normalize_write_policy(policy) for key, policy in value.items()}
+    if value:
+        return normalize_write_policy(value)
+    return value
+
+
+def normalize_agent_write_policy_metadata(value: Any) -> Any:
+    if isinstance(value, dict):
+        return {str(key): write_policy_public_fields(policy)["write_policy_metadata"] for key, policy in value.items()}
+    if value:
+        return write_policy_public_fields(value)["write_policy_metadata"]
+    return value
+
+
+def normalize_routing(value: Any) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        return {}
+    return {
+        "aliases": normalize_routing_strings(value.get("aliases")),
+        "anchors": normalize_routing_strings(value.get("anchors")),
+        "domains": normalize_routing_strings(value.get("domains")),
+        "entities": normalize_routing_strings(value.get("entities")),
+        "intents": normalize_routing_strings(value.get("intents")),
+        "keywords": normalize_routing_strings(value.get("keywords")),
+        "examples": normalize_routing_strings(value.get("examples")),
+        "priority": value.get("priority", 0),
+    }
+
+
+def normalize_routing_strings(value: Any) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [item.strip() for item in value if isinstance(item, str) and item.strip()]
+
+
+def normalize_runtime_role(value: Any) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        return {}
+    kind = str(value.get("kind") or "").strip()
+    if not kind:
+        return {}
+    role: dict[str, Any] = {"kind": kind}
+    description = str(value.get("description") or "").strip()
+    if description:
+        role["description"] = compact(description)
+    return role
+
+
+def normalize_agent_mode(value: Any) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        return {}
+    mode_type = str(value.get("type") or "").strip()
+    if not mode_type:
+        return {}
+    can_call_llm = value.get("can_call_llm")
+    normalized_llm: bool | str = False if can_call_llm is False else str(can_call_llm if can_call_llm is not None else "optional")
+    return {
+        "type": mode_type,
+        "max_steps": positive_int(value.get("max_steps"), default=5),
+        "max_specialists": positive_int(value.get("max_specialists"), default=5),
+        "max_llm_calls": positive_int(value.get("max_llm_calls"), default=0, allow_zero=True),
+        "timeout_seconds": positive_int(value.get("timeout_seconds"), default=300),
+        "can_call_capabilities": value.get("can_call_capabilities") is True,
+        "can_call_llm": normalized_llm,
+        "can_request_user_input": value.get("can_request_user_input") is True,
+        "external_writes": value.get("external_writes") is True,
+        "allowed_capabilities": normalize_string_list(value.get("allowed_capabilities")),
+        "stop_conditions": normalize_string_list(value.get("stop_conditions")),
+    }
+
+
+def positive_int(value: Any, *, default: int, allow_zero: bool = False) -> int:
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        return default
+    if allow_zero and parsed == 0:
+        return 0
+    return parsed if parsed > 0 else default
+
+
+def normalize_string_list(value: Any) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [str(item).strip() for item in value if str(item).strip()]
+
+
+def normalize_runtime(value: Any) -> dict[str, Any]:
+    if not isinstance(value, dict):
+        return {}
+    runtime: dict[str, Any] = {}
+    provider = str(value.get("provider") or "").strip()
+    if provider:
+        runtime["provider"] = provider
+    source = value.get("source") if isinstance(value.get("source"), dict) else None
+    if source:
+        normalized_source: dict[str, Any] = {"enabled": source.get("enabled") is True}
+        for key in ("args", "env"):
+            mapping = source.get(key)
+            if isinstance(mapping, dict):
+                normalized_source[key] = {
+                    str(item_key): str(item_value)
+                    for item_key, item_value in mapping.items()
+                    if str(item_key).strip() and str(item_value).strip()
+                }
+        runtime["source"] = normalized_source
+    return runtime
+
+
+def normalize_source_contract(value: Any, *, runtime: dict[str, Any] | None = None) -> dict[str, Any]:
+    if isinstance(value, dict):
+        return normalize_declared_source_contract(value, origin="source")
+    runtime_source = (runtime or {}).get("source") if isinstance(runtime, dict) else None
+    if isinstance(runtime_source, dict):
+        normalized = normalize_declared_source_contract(runtime_source, origin="runtime.source")
+        if "supported" not in normalized and "enabled" in normalized:
+            normalized["supported"] = bool(normalized["enabled"])
+        if "enabled" not in normalized and "supported" in normalized:
+            normalized["enabled"] = bool(normalized["supported"])
+        return normalized
+    return {"enabled": False, "supported": False, "args": {}, "env": {}}
+
+
+def normalize_declared_source_contract(value: dict[str, Any], *, origin: str) -> dict[str, Any]:
+    enabled = value.get("enabled")
+    supported = value.get("supported")
+    is_enabled = enabled is True or supported is True
+    contract: dict[str, Any] = {
+        "enabled": is_enabled,
+        "supported": is_enabled,
+        "args": normalize_string_map(value.get("args")),
+        "env": normalize_string_map(value.get("env")),
+        "origin": origin,
+    }
+    mappings = value.get("mappings")
+    if mappings is None:
+        mappings = value.get("apply")
+    if isinstance(mappings, list):
+        normalized_mappings = []
+        for item in mappings:
+            if not isinstance(item, dict):
+                continue
+            field = str(item.get("field") or item.get("name") or "").strip()
+            if not field:
+                continue
+            arg = str(item.get("arg") or "").strip()
+            env = str(item.get("env") or "").strip()
+            mapping: dict[str, str] = {"field": field}
+            if arg:
+                contract["args"][field] = arg
+                mapping["arg"] = arg
+            if env:
+                contract["env"][field] = env
+                mapping["env"] = env
+            if len(mapping) > 1:
+                normalized_mappings.append(mapping)
+        contract["mappings"] = normalized_mappings
+    return contract
+
+
+def normalize_string_map(value: Any) -> dict[str, str]:
+    if not isinstance(value, dict):
+        return {}
+    return {
+        str(item_key): str(item_value)
+        for item_key, item_value in value.items()
+        if str(item_key).strip() and str(item_value).strip()
+    }
+
+
+def resolve_capability_provider(
+    agent_id: str,
+    short_id: str,
+    capability: dict[str, Any],
+    runtime: dict[str, Any],
+    provider_map: dict[str, str],
+) -> dict[str, Any]:
+    if runtime.get("provider"):
+        return {"provider": str(runtime["provider"]), "source": "runtime", "inferred": False}
+    requires = capability.get("requires") if isinstance(capability.get("requires"), dict) else {}
+    providers = requires.get("providers") if isinstance(requires.get("providers"), list) else []
+    if providers and isinstance(providers[0], dict) and providers[0].get("id"):
+        return {"provider": str(providers[0]["id"]), "source": "requires", "inferred": False}
+    integration = capability.get("integration") if isinstance(capability.get("integration"), dict) else {}
+    if integration.get("provider"):
+        return {"provider": str(integration["provider"]), "source": "integration", "inferred": False}
+    provider = provider_map.get(f"{agent_id}/{short_id}") or provider_map.get(agent_id)
+    if provider:
+        return {"provider": provider, "source": "provider-registry", "inferred": True}
+    return {"provider": None, "source": "none", "inferred": False}
+
+
+def load_provider_capability_map(root: Path) -> dict[str, str]:
+    providers_dir = root / "providers"
+    provider_map: dict[str, str] = {}
+    if not providers_dir.is_dir():
+        return provider_map
+    for provider_path in sorted(providers_dir.glob("*.yaml")):
+        provider = read_yaml(provider_path)
+        provider_id = str(provider.get("id") or "").strip()
+        capabilities = provider.get("capabilities") if isinstance(provider.get("capabilities"), dict) else {}
+        if not provider_id or not capabilities:
+            continue
+        for declared in list(capabilities.get("read") or []) + list(capabilities.get("write") or []):
+            declared_id = str(declared or "").strip()
+            if declared_id:
+                provider_map.setdefault(declared_id, provider_id)
+    return provider_map

package/runtime/cli/aikit/architecture.py

@@ -0,0 +1,84 @@
+"""Public architecture contract for Agent DevKit."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from cli.aikit.acceptance import acceptance_model
+from cli.aikit.agent_registry import load_agent_registry
+from cli.aikit.impact_map import ownership_model
+from cli.aikit.roadmap import implementation_phases, problem_phase_map, recommended_initial_order
+from cli.aikit.runtime_paths import ROOT
+
+
+def architecture_contract(root: Path = ROOT) -> dict[str, Any]:
+    registry = load_agent_registry(root)
+    agents = registry.get("agents") or {}
+    capabilities = registry.get("capabilities") or {}
+    runtime_agents = sorted(
+        agent_id
+        for agent_id, agent in agents.items()
+        if isinstance(agent, dict) and str(agent.get("kind") or "") == "runtime-agent"
+    )
+    specialist_agents = sorted(agent_id for agent_id in agents if agent_id not in set(runtime_agents))
+    executable_capabilities = sum(
+        1
+        for capability in capabilities.values()
+        if isinstance(capability, dict) and capability.get("has_runner")
+    )
+    return {
+        "kind": "architecture",
+        "schema_version": "ai-devkit.architecture/v1",
+        "principal_agent": {
+            "id": "agent-devkit",
+            "name": "Agent DevKit",
+            "role": "runtime-agent",
+            "description": "Agente principal que coordena modulos especialistas, capabilities, automacoes, providers, memoria, guardrails e backends LLM.",
+        },
+        "model": {
+            "agent_devkit": "agente principal",
+            "agents": "modulos especialistas internos versionados em agents/*",
+            "capabilities": "unidades executaveis do sistema",
+            "runners": "automacoes deterministicas para tarefas conhecidas",
+            "providers": "integracoes externas acessadas por contratos controlados",
+            "llms": "cerebros plugaveis para conversa, decisao e revisao quando necessario",
+            "hosts": "interfaces ou consumidores externos, como CLI, MCP, Codex, Claude, OpenClaw e OpenCode",
+        },
+        "core_responsibilities": [
+            "planner_router",
+            "memory_sessions",
+            "permissions_guardrails",
+            "audit",
+            "provider_registry",
+            "llm_backend_selection",
+            "capability_execution",
+            "review_gate",
+        ],
+        "decision_targets": [
+            "deterministic_capability",
+            "local_mini_brain",
+            "external_professional_llm",
+            "human_input",
+            "external_provider",
+            "external_host_via_mcp",
+        ],
+        "interfaces": [
+            "cli",
+            "mcp",
+            "host_adapter",
+        ],
+        "implementation_phases": implementation_phases(),
+        "recommended_initial_order": recommended_initial_order(),
+        "problem_phase_map": problem_phase_map(),
+        "acceptance_model": acceptance_model(),
+        "impact_model": ownership_model(),
+        "counts": {
+            "runtime_agents": len(runtime_agents),
+            "specialist_agents": len(specialist_agents),
+            "capabilities": len(capabilities),
+            "executable_capabilities": executable_capabilities,
+        },
+        "runtime_agents": runtime_agents,
+        "status": "partially-implemented",
+    }

package/runtime/cli/aikit/audit.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import errno
 import getpass
 import json
 import re
@@ -11,12 +12,18 @@ from pathlib import Path
 from typing import Any
 
 from cli.aikit.app_home import audit_home, ensure_app_home
+from cli.aikit.autonomy import summarize_autonomy_contract
 from cli.aikit.memory import normalize_prompt, redact_secrets
+from cli.aikit.mini_brain import summarize_mini_brain
 
 
 AUDIT_VERSION = 1
 
 
+class AuditRedactionError(RuntimeError):
+    """Raised when an audit payload cannot be safely redacted."""
+
+
 def now_utc() -> datetime:
     return datetime.now(timezone.utc)
 
@@ -45,22 +52,30 @@ def record_audit(
     args: dict[str, Any],
     result: dict[str, Any] | None = None,
     error: str | None = None,
+    origin: str = "unknown",
 ) -> dict[str, Any]:
     created_at = now_iso()
     execution_id = f"exec_{now_utc().strftime('%Y%m%d%H%M%S')}_{uuid.uuid4().hex[:8]}"
     prompt = extract_prompt(args)
-    safe_result = redact_value(result or {})
+    try:
+        safe_result = redact_value(result or {})
+        safe_prompt = redact_secrets(prompt) if prompt else None
+        safe_error = redact_secrets(error) if error else None
+    except Exception as exc:  # noqa: BLE001 - never write an unredacted audit fallback.
+        raise AuditRedactionError("audit redaction failed") from exc
     entry = {
         "version": AUDIT_VERSION,
         "id": execution_id,
         "created_at": created_at,
+        "origin": normalize_origin(origin),
         "user": safe_user(),
         "command": command,
-        "prompt": redact_secrets(prompt) if prompt else None,
+        "prompt": safe_prompt,
         "prompt_normalized": normalize_prompt(prompt) if prompt else None,
         "session": extract_session(safe_result),
         "route": safe_result.get("route"),
         "orchestration": extract_orchestration(safe_result),
+        "autonomy": summarize_autonomy_contract(safe_result.get("autonomy_contract")),
         "agent": extract_agent(safe_result, args),
         "providers": extract_providers(safe_result),
         "sources": extract_sources(safe_result),
@@ -70,7 +85,7 @@ def record_audit(
         "token_estimate": extract_token_estimate(safe_result),
         "external_actions": extract_external_actions(safe_result),
         "result": summarize_result(safe_result),
-        "error": redact_secrets(error) if error else None,
+        "error": safe_error,
         "redaction_applied": True,
     }
     day_home = audit_day_home(created_at[:10])
@@ -81,6 +96,64 @@ def record_audit(
     return {"id": execution_id, "json_path": str(json_path), "markdown_path": str(md_path)}
 
 
+def try_record_audit(
+    *,
+    command: str | None,
+    args: dict[str, Any],
+    result: dict[str, Any] | None = None,
+    error: str | None = None,
+    origin: str = "unknown",
+    required: bool = False,
+    recorder: Any | None = None,
+) -> dict[str, Any]:
+    """Record an audit trail and return a safe success or warning envelope."""
+
+    audit_recorder = recorder or record_audit
+    try:
+        audit = audit_recorder(command=command, args=args, result=result, error=error, origin=origin)
+    except TypeError as exc:
+        if recorder is None:
+            return {"audit_warning": audit_warning(exc, required=required)}
+        try:
+            audit = audit_recorder(command=command, args=args, result=result, error=error)
+        except Exception as fallback_exc:  # noqa: BLE001 - audit remains best-effort.
+            return {"audit_warning": audit_warning(fallback_exc, required=required)}
+    except Exception as exc:  # noqa: BLE001 - audit remains best-effort.
+        return {"audit_warning": audit_warning(exc, required=required)}
+    return {"audit": audit}
+
+
+def audit_warning(exc: Exception, *, required: bool = False) -> dict[str, Any]:
+    return {
+        "kind": "audit-warning",
+        "code": "audit_record_failed",
+        "status": "not-recorded",
+        "reason": classify_audit_error(exc),
+        "message": "Audit trail could not be written.",
+        "required": bool(required),
+    }
+
+
+def classify_audit_error(exc: Exception) -> str:
+    if isinstance(exc, AuditRedactionError):
+        return "redaction-error"
+    if isinstance(exc, PermissionError):
+        return "permission-denied"
+    if isinstance(exc, FileNotFoundError):
+        return "path-not-found"
+    if isinstance(exc, OSError) and getattr(exc, "errno", None) == errno.ENOSPC:
+        return "disk-full"
+    if isinstance(exc, (TypeError, ValueError)):
+        return "serialization-error"
+    return "unknown-audit-error"
+
+
+def normalize_origin(origin: str | None) -> str:
+    allowed = {"cli", "mcp", "scheduler", "wizard", "agent-prompt", "plugin", "core", "unknown"}
+    value = str(origin or "unknown").strip()
+    return value if value in allowed else "unknown"
+
+
 def list_audits(limit: int = 20) -> dict[str, Any]:
     items: list[dict[str, Any]] = []
     for path in sorted(ensure_audit_home().glob("*/*.json"), reverse=True):
@@ -232,6 +305,17 @@ def extract_sources(result: dict[str, Any]) -> list[Any]:
     source = result.get("source")
     if source:
         return [source]
+    if result.get("kind") == "source-configure" and result.get("status") == "blocked":
+        return [
+            {
+                "id": result.get("source_id"),
+                "provider": result.get("provider"),
+                "status": result.get("status"),
+                "field": result.get("field"),
+                "reason": result.get("reason"),
+                "stored_secret": False,
+            }
+        ]
     return []
 
 
@@ -294,8 +378,11 @@ def extract_orchestration(result: dict[str, Any]) -> dict[str, Any] | None:
         "domain_agent": (plan.get("domain_agent") or {}).get("id") if isinstance(plan.get("domain_agent"), dict) else None,
         "specialist_tasks": [
             {
+                "task_id": task.get("task_id") or task.get("id"),
                 "agent_id": task.get("agent_id"),
                 "capability_id": task.get("capability_id"),
+                "role": task.get("role"),
+                "depends_on": list(task.get("depends_on") or []),
                 "status": task.get("status"),
             }
             for task in plan.get("specialist_tasks") or []
@@ -303,23 +390,104 @@ def extract_orchestration(result: dict[str, Any]) -> dict[str, Any] | None:
         ],
         "configuration_tasks": [
             {
+                "task_id": task.get("task_id") or task.get("id"),
                 "agent_id": task.get("agent_id"),
                 "provider": task.get("provider"),
+                "role": task.get("role"),
+                "depends_on": list(task.get("depends_on") or []),
                 "status": task.get("status"),
             }
             for task in plan.get("configuration_tasks") or []
             if isinstance(task, dict)
         ],
         "review_task": {
+            "task_id": (plan.get("review_task") or {}).get("task_id") or (plan.get("review_task") or {}).get("id"),
             "agent_id": (plan.get("review_task") or {}).get("agent_id"),
+            "role": (plan.get("review_task") or {}).get("role"),
+            "depends_on": list((plan.get("review_task") or {}).get("depends_on") or []),
             "status": (plan.get("review_task") or {}).get("status"),
         }
         if isinstance(plan.get("review_task"), dict)
         else None,
+        "collaboration_enabled": plan.get("collaboration_enabled") is True,
+        "collaboration_graph": summarize_collaboration_graph(plan.get("collaboration_graph")),
+        "model_plan": summarize_model_plan(plan.get("model_plan")),
+        "execution_model": summarize_execution_model(plan.get("execution_model")),
+        "autonomy_contract": summarize_autonomy_contract(plan.get("autonomy_contract")),
+        "human_escalations": len(plan.get("human_escalations") or []),
+        "shared_context": summarize_shared_context(plan.get("shared_context")),
         "trace": result.get("orchestration_trace") or plan.get("trace") or [],
     }
 
 
+def summarize_collaboration_graph(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    nodes = value.get("nodes") if isinstance(value.get("nodes"), list) else []
+    edges = value.get("edges") if isinstance(value.get("edges"), list) else []
+    return {
+        "schema_version": value.get("schema_version"),
+        "nodes": len(nodes),
+        "edges": len(edges),
+        "parallel_groups": len(value.get("parallel_groups") or []),
+    }
+
+
+def summarize_shared_context(value: Any) -> dict[str, int] | None:
+    if not isinstance(value, dict):
+        return None
+    return {
+        key: len(value.get(key) or [])
+        for key in (
+            "facts",
+            "inferences",
+            "artifacts",
+            "blockers",
+            "decisions",
+            "risks",
+            "questions",
+            "handoffs",
+            "conflicts",
+            "human_escalations",
+        )
+    }
+
+
+def summarize_execution_model(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    return {
+        "schema_version": value.get("schema_version"),
+        "decision_owner": value.get("decision_owner"),
+        "review_required": value.get("review_required"),
+        "model_strategy": value.get("model_strategy"),
+        "model_risk": value.get("model_risk"),
+        "model_confidence": value.get("model_confidence"),
+        "autonomy_level": value.get("autonomy_level"),
+        "autonomy_level_id": value.get("autonomy_level_id"),
+        "autonomy_status": value.get("autonomy_status"),
+        "execution_allowed": value.get("execution_allowed"),
+        "requires_human": value.get("requires_human"),
+        "limits": value.get("limits") if isinstance(value.get("limits"), dict) else {},
+        "stop_conditions": list(value.get("stop_conditions") or []),
+    }
+
+
+def summarize_model_plan(value: Any) -> dict[str, Any] | None:
+    if not isinstance(value, dict):
+        return None
+    return {
+        "strategy": value.get("strategy"),
+        "risk": value.get("risk"),
+        "confidence": value.get("confidence"),
+        "fallback": value.get("fallback"),
+        "local_llm_selected": value.get("local_llm_selected") is True,
+        "local_llm_recommended": value.get("local_llm_recommended") is True,
+        "mini_brain": summarize_mini_brain(value.get("mini_brain")),
+        "max_llm_calls": value.get("max_llm_calls"),
+    }
+
+
 def summarize_result(result: dict[str, Any]) -> dict[str, Any]:
     return {
         "kind": result.get("kind"),
@@ -343,6 +511,7 @@ def render_audit_md(entry: dict[str, Any]) -> str:
         f"# Audit {entry.get('id')}",
         "",
         f"- Created at: `{entry.get('created_at')}`",
+        f"- Origin: `{entry.get('origin') or 'unknown'}`",
         f"- User: `{entry.get('user')}`",
         f"- Command: `{entry.get('command')}`",
         f"- Status: `{(entry.get('result') or {}).get('status')}`",