docs(release): add V1R2C3 promotion readiness report

.gitignore

@@ -10,4 +10,3 @@ node_modules/
 runtime/tmp/
 runtime/cache/
 logs/
-config/test_write_perms

VERSION

@@ -1 +1 @@
-V1R4C3
+V1R1C4

acceptance/portal-aios-integration-matrix.yaml

@@ -1,45 +0,0 @@
-portal_aios_acceptance:
-  version: V1R4C3
-  status: pending_deployment_validation
-
-  login:
-    - casdoor_auth_success
-    - portal_session_created
-    - portal_me_loaded
-
-  roles:
-    user:
-      checks:
-        - task_center_visible
-        - owner_modules_hidden
-    group_admin:
-      checks:
-        - task_center_visible
-        - operations_visible
-        - system_health_visible
-        - search_visible
-        - agents_visible
-    owner:
-      checks:
-        - all_aios_modules_visible
-        - governance_visible
-        - architecture_visible
-        - owner_gate_visible
-
-  api:
-    - manifest_returns_modules
-    - dashboard_returns_navigation
-    - rbac_filters_modules
-
-  ui:
-    - menu_rendered
-    - cards_rendered
-    - quick_actions_rendered
-    - forbidden_routes_hidden
-
-  success_signals:
-    - AIOS_PORTAL_ROUTE_READY
-    - AIOS_WEB_UI_MODULES_VISIBLE
-    - AIOS_RBAC_VISIBILITY_READY
-    - AIOS_PORTAL_AUTH_INTEGRATION_READY
-    - AIOS_PORTAL_USER_EXPERIENCE_READY

active-runtime/app/agent_context_api.py

@@ -1,56 +0,0 @@
-"""API adapter for agent context routing and visibility."""
-
-from typing import Any
-
-try:
-    from fastapi import APIRouter
-except Exception:
-    APIRouter = None
-
-from .agent_context_dashboard import AgentContextDashboard
-from .agent_context_rbac import AgentContextRBAC
-from .agent_context_resolver import AgentContextResolver
-
-resolver = AgentContextResolver()
-rbac = AgentContextRBAC()
-dashboard = AgentContextDashboard()
-
-
-def resolve_agent_context(payload: dict[str, Any]) -> dict[str, Any]:
-    route = rbac.route(payload["user_id"], payload.get("group_id"), payload.get("role", "user"))
-    context = resolver.resolve(
-        user_id=payload["user_id"],
-        group_id=payload.get("group_id", ""),
-        session=payload.get("session"),
-        user_profile=payload.get("user_profile"),
-        group_policy=payload.get("group_policy"),
-        agent_default=payload.get("agent_default"),
-        owner_policy=payload.get("owner_policy"),
-        owner=payload.get("role") == "owner",
-    )
-    return {"routing": route.to_dict(), "context": context.to_dict()}
-
-
-def get_context_dashboard() -> dict[str, Any]:
-    return dashboard.overview()
-
-
-def build_router():
-    if APIRouter is None:
-        return None
-    router = APIRouter(prefix="/admin/ai-evolution/context", tags=["context-isolation"])
-
-    @router.post("/resolve", operation_id="resolveAgentContext")
-    def resolve(payload: dict[str, Any]):
-        return resolve_agent_context(payload)
-
-    @router.get("/overview", operation_id="getAgentContextDashboard")
-    def overview():
-        return get_context_dashboard()
-
-    return router
-
-
-router = build_router()
-
-__all__ = ["router", "resolve_agent_context", "get_context_dashboard"]

active-runtime/app/agent_context_audit.py

@@ -1,23 +0,0 @@
-"""Audit context resolution decisions."""
-
-from datetime import datetime, timezone
-from typing import Any
-
-
-def utc_now():
-    return datetime.now(timezone.utc).isoformat()
-
-
-class AgentContextAudit:
-    def record(self, context: dict[str, Any]) -> dict[str, Any]:
-        return {
-            "event": "context_loaded",
-            "agent_id": context.get("agent_id"),
-            "user_id": context.get("user_id"),
-            "group_id": context.get("group_id"),
-            "layers": [x.get("name") for x in context.get("layers", [])],
-            "timestamp": utc_now(),
-        }
-
-
-__all__ = ["AgentContextAudit"]

active-runtime/app/agent_context_dashboard.py

@@ -1,47 +0,0 @@
-"""Web UI model for context isolation visibility."""
-
-from __future__ import annotations
-
-from typing import Any
-
-
-class AgentContextDashboard:
-    def overview(self, contexts: list[dict[str, Any]] | None = None) -> dict[str, Any]:
-        contexts = contexts or []
-        return {
-            "module": "agent-context-isolation",
-            "route": "/admin/ai-evolution/context",
-            "title": "Agent Context Isolation",
-            "panels": [
-                {
-                    "name": "agent-routing",
-                    "title": "Agent 路由",
-                    "data": contexts,
-                },
-                {
-                    "name": "context-layers",
-                    "title": "Context 来源层级",
-                    "layers": [
-                        "safety_policy",
-                        "owner_policy",
-                        "group_policy",
-                        "role_policy",
-                        "user_profile",
-                        "session_context",
-                        "agent_default",
-                    ],
-                },
-                {
-                    "name": "audit",
-                    "title": "Context 审计",
-                    "events": [
-                        "context_loaded",
-                        "profile_updated",
-                        "agent_selected",
-                    ],
-                },
-            ],
-        }
-
-
-__all__ = ["AgentContextDashboard"]

active-runtime/app/agent_context_rbac.py

@@ -1,55 +0,0 @@
-"""RBAC binding for group main agents and owner agents."""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass
-from typing import Any
-
-
-@dataclass(frozen=True)
-class AgentRoutingDecision:
-    user_id: str
-    group_id: str
-    role: str
-    agent_id: str
-    scope: str
-    allowed: bool
-    reason: str
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-class AgentContextRBAC:
-    """Routes users to group agents and owners to dedicated owner agents."""
-
-    VALID_ROLES = {"user", "group_admin", "owner"}
-
-    def route(self, user_id: str, group_id: str | None, role: str) -> AgentRoutingDecision:
-        if role not in self.VALID_ROLES:
-            return AgentRoutingDecision(user_id, group_id or "", role, "", "none", False, "unknown_role")
-        if role == "owner":
-            return AgentRoutingDecision(
-                user_id=user_id,
-                group_id=group_id or "global",
-                role=role,
-                agent_id=f"owner-agent:{user_id}",
-                scope="global",
-                allowed=True,
-                reason="owner_dedicated_agent",
-            )
-        if not group_id:
-            return AgentRoutingDecision(user_id, "", role, "", "none", False, "group_required")
-        scope = "group" if role == "group_admin" else "self"
-        return AgentRoutingDecision(
-            user_id=user_id,
-            group_id=group_id,
-            role=role,
-            agent_id=f"group-main-agent:{group_id}",
-            scope=scope,
-            allowed=True,
-            reason="group_agent_routing",
-        )
-
-
-__all__ = ["AgentRoutingDecision", "AgentContextRBAC"]

active-runtime/app/agent_context_resolver.py

@@ -1,82 +0,0 @@
-"""Multi-user agent context resolver.
-
-Architecture:
-- shared agent kernel
-- group main agent
-- owner dedicated agent
-- user profile overlay
-- session overlay
-
-Personal preferences never enter shared USER.md.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass(frozen=True)
-class ContextLayer:
-    name: str
-    priority: int
-    data: dict[str, Any]
-
-
-@dataclass
-class EffectiveContext:
-    agent_id: str
-    user_id: str
-    group_id: str
-    layers: list[ContextLayer]
-    resolved: dict[str, Any]
-    resolved_at: str = field(default_factory=utc_now)
-
-    def to_dict(self):
-        return {
-            "agent_id": self.agent_id,
-            "user_id": self.user_id,
-            "group_id": self.group_id,
-            "layers": [asdict(x) for x in self.layers],
-            "resolved": self.resolved,
-            "resolved_at": self.resolved_at,
-        }
-
-
-class AgentContextResolver:
-    """Resolves context without shared user-state pollution."""
-
-    def resolve(
-        self,
-        user_id: str,
-        group_id: str,
-        session: dict[str, Any] | None = None,
-        user_profile: dict[str, Any] | None = None,
-        group_policy: dict[str, Any] | None = None,
-        agent_default: dict[str, Any] | None = None,
-        owner_policy: dict[str, Any] | None = None,
-        owner: bool = False,
-    ) -> EffectiveContext:
-        layers = [
-            ContextLayer("agent_default", 10, agent_default or {}),
-            ContextLayer("group_policy", 30, group_policy or {}),
-            ContextLayer("user_profile", 50, user_profile or {}),
-            ContextLayer("session", 70, session or {}),
-        ]
-        agent_id = f"group-main-agent:{group_id}"
-        if owner:
-            agent_id = f"owner-agent:{user_id}"
-            layers.append(ContextLayer("owner_policy", 90, owner_policy or {}))
-        resolved: dict[str, Any] = {}
-        # Higher priority overlays lower priority except safety policies handled upstream.
-        for layer in sorted(layers, key=lambda x: x.priority):
-            resolved.update(layer.data)
-        return EffectiveContext(agent_id, user_id, group_id, layers, resolved)
-
-
-__all__ = ["ContextLayer", "EffectiveContext", "AgentContextResolver"]

active-runtime/app/agent_event_api.py

@@ -1,77 +0,0 @@
-"""Actions API for unified Agent Event Bus."""
-
-from __future__ import annotations
-
-from typing import Any
-
-try:
-    from fastapi import APIRouter
-except Exception:
-    APIRouter = None
-
-from .agent_event_bus import AgentEventBus
-
-bus = AgentEventBus()
-
-
-def create_agent_event(payload: dict[str, Any]) -> dict[str, Any]:
-    return {"status": "ok", "event": bus.publish(**payload)}
-
-
-def list_agent_events(kind: str | None = None, status: str = "pending") -> dict[str, Any]:
-    return {"status": "ok", "events": bus.list_events(kind, status)}
-
-
-def get_agent_event(event_id: str) -> dict[str, Any]:
-    return {"status": "ok", "event": bus.get(event_id)}
-
-
-def transition_agent_event(event_id: str, status: str, actor: str = "system") -> dict[str, Any]:
-    return {"status": "ok", "event": bus.transition(event_id, status, actor)}
-
-
-def agent_event_stats() -> dict[str, Any]:
-    return {"status": "ok", "stats": bus.stats()}
-
-
-# Compatibility adapters
-
-def list_gpt_inbox_messages():
-    return list_agent_events(kind="gpt_inbox")
-
-
-def ack_gpt_inbox_message(event_id: str):
-    return transition_agent_event(event_id, "completed", "custom-gpt")
-
-
-def build_router():
-    if APIRouter is None:
-        return None
-    router = APIRouter(prefix="/agent-events", tags=["agent-events"])
-
-    @router.post("", operation_id="createAgentEvent")
-    def create(payload: dict[str, Any]):
-        return create_agent_event(payload)
-
-    @router.get("", operation_id="listAgentEvents")
-    def listing(kind: str | None = None, status: str = "pending"):
-        return list_agent_events(kind, status)
-
-    @router.get("/{event_id}", operation_id="getAgentEvent")
-    def get(event_id: str):
-        return get_agent_event(event_id)
-
-    @router.post("/{event_id}/transition", operation_id="transitionAgentEvent")
-    def transition(event_id: str, payload: dict[str, Any]):
-        return transition_agent_event(event_id, payload["status"], payload.get("actor", "system"))
-
-    @router.get("/stats/overview", operation_id="getAgentEventStats")
-    def stats():
-        return agent_event_stats()
-
-    return router
-
-
-router = build_router()
-
-__all__ = ["router", "create_agent_event", "list_agent_events", "get_agent_event", "transition_agent_event"]

active-runtime/app/agent_event_bus.py

@@ -1,125 +0,0 @@
-"""Unified Agent Event Bus.
-
-Unifies commands, GPT messages, replies, approvals, audit and reports into one
-state machine. Compatibility layers can filter events by kind instead of keeping
-separate queues.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from hashlib import sha256
-from pathlib import Path
-import json
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass
-class AgentEvent:
-    id: str
-    kind: str
-    source: str
-    target: str
-    summary: str
-    payload: dict[str, Any]
-    status: str = "pending"
-    correlation_id: str | None = None
-    created_at: str = field(default_factory=utc_now)
-    updated_at: str = field(default_factory=utc_now)
-    actor: str | None = None
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-class AgentEventBus:
-    STATES = ("pending", "running", "completed", "failed")
-
-    def __init__(self, root: str = "agents/events"):
-        self.root = Path(root)
-        for state in self.STATES:
-            (self.root / state).mkdir(parents=True, exist_ok=True)
-        (self.root / "audit").mkdir(parents=True, exist_ok=True)
-
-    def publish(
-        self,
-        kind: str,
-        source: str,
-        target: str,
-        summary: str,
-        payload: dict[str, Any],
-        correlation_id: str | None = None,
-    ) -> dict[str, Any]:
-        event_id = "evt_" + sha256(
-            json.dumps(
-                {"kind": kind, "source": source, "summary": summary, "payload": payload},
-                sort_keys=True,
-                ensure_ascii=False,
-            ).encode("utf-8")
-        ).hexdigest()[:16]
-        event = AgentEvent(event_id, kind, source, target, summary, payload, correlation_id=correlation_id)
-        self._write("pending", event.to_dict())
-        self._audit("created", event.to_dict())
-        return event.to_dict()
-
-    def list_events(self, kind: str | None = None, status: str = "pending", limit: int = 100) -> list[dict[str, Any]]:
-        result = []
-        for path in sorted((self.root / status).glob("*.json")):
-            event = self._read(path)
-            if kind and event.get("kind") != kind:
-                continue
-            result.append(event)
-        return result[:limit]
-
-    def get(self, event_id: str) -> dict[str, Any] | None:
-        for state in self.STATES:
-            path = self.root / state / f"{event_id}.json"
-            if path.exists():
-                return self._read(path)
-        return None
-
-    def transition(self, event_id: str, status: str, actor: str | None = None) -> dict[str, Any]:
-        event = self.get(event_id)
-        if not event:
-            return {"status": "not_found", "id": event_id}
-        if status not in self.STATES:
-            return {"status": "invalid_state"}
-        old = event.get("status", "pending")
-        old_path = self.root / old / f"{event_id}.json"
-        event["status"] = status
-        event["actor"] = actor
-        event["updated_at"] = utc_now()
-        self._write(status, event)
-        if old_path.exists() and old != status:
-            old_path.unlink()
-        self._audit("transition", event, {"from": old, "to": status})
-        return event
-
-    def stats(self) -> dict[str, Any]:
-        return {
-            "events": {state: len(list((self.root / state).glob("*.json"))) for state in self.STATES},
-            "audit_events": len(list((self.root / "audit").glob("*.json"))),
-            "status": "healthy",
-        }
-
-    def _write(self, state: str, data: dict[str, Any]):
-        (self.root / state / f"{data['id']}.json").write_text(
-            json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8"
-        )
-
-    def _read(self, path: Path):
-        return json.loads(path.read_text(encoding="utf-8"))
-
-    def _audit(self, action: str, event: dict[str, Any], extra: dict[str, Any] | None = None):
-        data = {"action": action, "event": event, "extra": extra or {}, "time": utc_now()}
-        (self.root / "audit" / f"{event['id']}-{action}.json").write_text(
-            json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8"
-        )
-
-
-__all__ = ["AgentEvent", "AgentEventBus"]

active-runtime/app/agent_event_dashboard.py

@@ -1,50 +0,0 @@
-"""Admin dashboard data model for the unified Agent Event Bus."""
-
-from __future__ import annotations
-
-from collections import Counter
-from typing import Any
-
-from .agent_event_bus import AgentEventBus
-
-
-class AgentEventDashboard:
-    def __init__(self, bus: AgentEventBus | None = None):
-        self.bus = bus or AgentEventBus()
-
-    def overview(self) -> dict[str, Any]:
-        stats = self.bus.stats()
-        pending = self.bus.list_events(status="pending")
-        running = self.bus.list_events(status="running")
-        completed = self.bus.list_events(status="completed")
-        failed = self.bus.list_events(status="failed")
-        all_visible = pending + running + completed + failed
-        by_kind = Counter(event.get("kind", "unknown") for event in all_visible)
-        by_target = Counter(event.get("target", "unknown") for event in all_visible)
-        return {
-            "module": "agent-event-bus",
-            "title": "Unified Agent Event Bus",
-            "route": "/admin/ai-evolution/events",
-            "metrics": {
-                **stats,
-                "by_kind": dict(by_kind),
-                "by_target": dict(by_target),
-                "gpt_inbox_pending": by_kind.get("gpt_inbox", 0),
-                "openclaw_pending": len([e for e in pending if e.get("target") == "openclaw"]),
-            },
-            "panels": [
-                "event timeline",
-                "pending commands",
-                "GPT inbox",
-                "agent replies",
-                "failure reports",
-                "audit trail",
-            ],
-            "audit": {
-                "enabled": True,
-                "location": "agents/events/audit",
-            },
-        }
-
-
-__all__ = ["AgentEventDashboard"]

active-runtime/app/agent_event_observability_bridge.py

@@ -1,37 +0,0 @@
-"""Bridge Agent Event Bus events into Agent Observability metrics."""
-
-from .agent_observability_hooks import AgentObservabilityHooks
-
-
-class AgentEventObservabilityBridge:
-    def __init__(self, hooks: AgentObservabilityHooks | None = None):
-        self.hooks = hooks or AgentObservabilityHooks()
-
-    def consume(self, event: dict):
-        kind = event.get("kind")
-        payload = event.get("payload", {})
-        if kind == "agent_started":
-            return self.hooks.start(
-                user_id=payload.get("user_id", "unknown"),
-                visible_scope=payload.get("scope", "self"),
-                entry_agent=payload.get("agent", "unknown"),
-                execution_id=event.get("id"),
-            )
-        if kind == "agent_delegated":
-            return self.hooks.delegate(event["execution_id"], payload.get("agent", "unknown"))
-        if kind == "token_consumed":
-            return self.hooks.tokens(
-                event["execution_id"],
-                payload.get("input_tokens", 0),
-                payload.get("output_tokens", 0),
-            )
-        if kind in {"agent_completed", "agent_failed"}:
-            return self.hooks.finish(
-                event["execution_id"],
-                payload.get("closed_by"),
-                "failed" if kind == "agent_failed" else "completed",
-            )
-        return {"status": "ignored", "kind": kind}
-
-
-__all__ = ["AgentEventObservabilityBridge"]

active-runtime/app/agent_observability.py

@@ -1,80 +0,0 @@
-"""Agent orchestration observability model.
-
-Tracks OpenClaw, Hermes and sub-agent execution chains. Token usage is optional
-and depends on model adapter instrumentation.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-
-
-def utc_now():
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass
-class AgentExecutionRecord:
-    execution_id: str
-    user_id: str
-    visible_scope: str
-    entry_agent: str
-    path: list[str]
-    used_hermes: bool
-    closed_by: str
-    duration_ms: int = 0
-    input_tokens: int | None = None
-    output_tokens: int | None = None
-    total_tokens: int | None = None
-    status: str = "completed"
-    started_at: str = field(default_factory=utc_now)
-    ended_at: str = field(default_factory=utc_now)
-
-    def to_dict(self):
-        return asdict(self)
-
-
-class AgentObservability:
-    def __init__(self):
-        self.records: list[AgentExecutionRecord] = []
-
-    def record(self, record: AgentExecutionRecord):
-        self.records.append(record)
-        return record.to_dict()
-
-    def summary(self, user_id: str | None = None) -> dict[str, Any]:
-        records = [r for r in self.records if not user_id or r.user_id == user_id]
-        hermes = [r for r in records if r.used_hermes]
-        direct = [r for r in records if not r.used_hermes]
-        return {
-            "total_executions": len(records),
-            "openclaw_independent_loops": len(direct),
-            "hermes_orchestrated_loops": len(hermes),
-            "average_duration_ms": (
-                sum(r.duration_ms for r in records) / len(records) if records else 0
-            ),
-            "token_usage": {
-                "input": sum(r.input_tokens or 0 for r in records),
-                "output": sum(r.output_tokens or 0 for r in records),
-                "total": sum(r.total_tokens or 0 for r in records),
-            },
-        }
-
-    def hermes_tree(self, user_id: str | None = None):
-        return [
-            {
-                "execution_id": r.execution_id,
-                "entry": r.entry_agent,
-                "used_hermes": r.used_hermes,
-                "children": r.path,
-                "duration_ms": r.duration_ms,
-                "tokens": r.total_tokens,
-            }
-            for r in self.records
-            if (not user_id or r.user_id == user_id)
-        ]
-
-
-__all__ = ["AgentExecutionRecord", "AgentObservability"]

active-runtime/app/agent_observability_api.py

@@ -1,52 +0,0 @@
-"""API for agent orchestration observability."""
-
-from __future__ import annotations
-
-from typing import Any
-
-try:
-    from fastapi import APIRouter
-except Exception:
-    APIRouter = None
-
-from .agent_observability import AgentExecutionRecord
-from .agent_observability_dashboard import AgentObservabilityDashboard
-from .agent_observability_store import AgentObservabilityStore
-
-store = AgentObservabilityStore()
-dashboard = AgentObservabilityDashboard(store.load())
-
-
-def record_agent_execution(payload: dict[str, Any]):
-    record = AgentExecutionRecord(**payload)
-    return {"status": "ok", "record": store.append(record)}
-
-
-def get_agent_observability(user_id: str | None = None, group_id: str | None = None, role: str = "user"):
-    records = store.query(user_id, group_id, role)
-    return {
-        "status": "ok",
-        "records": records,
-        "summary": store.load().summary(user_id if role != "owner" else None),
-    }
-
-
-def build_router():
-    if APIRouter is None:
-        return None
-    router = APIRouter(prefix="/admin/ai-evolution/agents", tags=["agent-observability"])
-
-    @router.post("/execution", operation_id="recordAgentExecution")
-    def record(payload: dict[str, Any]):
-        return record_agent_execution(payload)
-
-    @router.get("/overview", operation_id="getAgentObservabilityOverview")
-    def overview(user_id: str | None = None, group_id: str | None = None, role: str = "user"):
-        return get_agent_observability(user_id, group_id, role)
-
-    return router
-
-
-router = build_router()
-
-__all__ = ["router", "record_agent_execution", "get_agent_observability"]

active-runtime/app/agent_observability_dashboard.py

@@ -1,44 +0,0 @@
-"""Web UI dashboard model for agent execution visibility."""
-
-from .agent_observability import AgentObservability
-
-
-class AgentObservabilityDashboard:
-    def __init__(self, observability: AgentObservability | None = None):
-        self.observability = observability or AgentObservability()
-
-    def overview(self, user_id: str | None = None):
-        return {
-            "route": "/admin/ai-evolution/agents",
-            "title": "Agent Orchestration Observability",
-            "summary": self.observability.summary(user_id),
-            "views": [
-                {
-                    "name": "scheduler_flow",
-                    "title": "OpenClaw/Hermes 调度流程",
-                    "data": self.observability.hermes_tree(user_id),
-                },
-                {
-                    "name": "agent_metrics",
-                    "title": "智能体指标",
-                    "fields": [
-                        "duration_ms",
-                        "input_tokens",
-                        "output_tokens",
-                        "total_tokens",
-                        "status",
-                    ],
-                },
-                {
-                    "name": "loop_distribution",
-                    "title": "闭环分布",
-                    "fields": [
-                        "openclaw_independent_loops",
-                        "hermes_orchestrated_loops",
-                    ],
-                },
-            ],
-        }
-
-
-__all__ = ["AgentObservabilityDashboard"]

active-runtime/app/agent_observability_hooks.py

@@ -1,113 +0,0 @@
-"""Runtime hooks for Agent Observability.
-
-OpenClaw/Hermes/sub-agents can call these hooks at start/end/delegation points.
-The hooks store sanitized metadata only: no prompts, no secrets, no private message
-content.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-from uuid import uuid4
-
-from .agent_observability import AgentExecutionRecord
-from .agent_observability_store import AgentObservabilityStore
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def parse_time(value: str) -> datetime:
-    return datetime.fromisoformat(value.replace("Z", "+00:00"))
-
-
-@dataclass
-class AgentRunContext:
-    execution_id: str
-    user_id: str
-    visible_scope: str
-    entry_agent: str
-    path: list[str] = field(default_factory=list)
-    used_hermes: bool = False
-    started_at: str = field(default_factory=utc_now)
-    input_tokens: int = 0
-    output_tokens: int = 0
-    status: str = "running"
-
-    def delegate(self, agent_name: str) -> None:
-        if agent_name not in self.path:
-            self.path.append(agent_name)
-        if agent_name.lower() == "hermes":
-            self.used_hermes = True
-
-    def add_tokens(self, input_tokens: int = 0, output_tokens: int = 0) -> None:
-        self.input_tokens += max(input_tokens, 0)
-        self.output_tokens += max(output_tokens, 0)
-
-
-class AgentObservabilityHooks:
-    def __init__(self, store: AgentObservabilityStore | None = None):
-        self.store = store or AgentObservabilityStore()
-        self.active: dict[str, AgentRunContext] = {}
-
-    def start(
-        self,
-        user_id: str,
-        visible_scope: str,
-        entry_agent: str,
-        execution_id: str | None = None,
-    ) -> dict[str, Any]:
-        run = AgentRunContext(
-            execution_id=execution_id or f"exec_{uuid4().hex[:12]}",
-            user_id=user_id,
-            visible_scope=visible_scope,
-            entry_agent=entry_agent,
-            path=[entry_agent],
-            used_hermes=entry_agent.lower() == "hermes",
-        )
-        self.active[run.execution_id] = run
-        return {"status": "started", "execution_id": run.execution_id, "run": run.__dict__}
-
-    def delegate(self, execution_id: str, agent_name: str) -> dict[str, Any]:
-        run = self.active[execution_id]
-        run.delegate(agent_name)
-        return {"status": "delegated", "execution_id": execution_id, "path": run.path}
-
-    def tokens(self, execution_id: str, input_tokens: int = 0, output_tokens: int = 0) -> dict[str, Any]:
-        run = self.active[execution_id]
-        run.add_tokens(input_tokens, output_tokens)
-        return {
-            "status": "tokens_recorded",
-            "execution_id": execution_id,
-            "input_tokens": run.input_tokens,
-            "output_tokens": run.output_tokens,
-            "total_tokens": run.input_tokens + run.output_tokens,
-        }
-
-    def finish(self, execution_id: str, closed_by: str | None = None, status: str = "completed") -> dict[str, Any]:
-        run = self.active.pop(execution_id)
-        ended_at = utc_now()
-        duration_ms = int((parse_time(ended_at) - parse_time(run.started_at)).total_seconds() * 1000)
-        record = AgentExecutionRecord(
-            execution_id=run.execution_id,
-            user_id=run.user_id,
-            visible_scope=run.visible_scope,
-            entry_agent=run.entry_agent,
-            path=run.path,
-            used_hermes=run.used_hermes,
-            closed_by=closed_by or run.path[-1],
-            duration_ms=duration_ms,
-            input_tokens=run.input_tokens,
-            output_tokens=run.output_tokens,
-            total_tokens=run.input_tokens + run.output_tokens,
-            status=status,
-            started_at=run.started_at,
-            ended_at=ended_at,
-        )
-        return {"status": "stored", "record": self.store.append(record)}
-
-
-__all__ = ["AgentRunContext", "AgentObservabilityHooks"]

active-runtime/app/agent_observability_store.py

@@ -1,45 +0,0 @@
-"""Persistent store for agent observability records.
-
-Stores sanitized execution metrics for OpenClaw/Hermes/sub-agents. No prompts,
-secrets, or private message contents are persisted here; only metrics and routing
-metadata are stored for Web UI statistics and audit.
-"""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any
-
-from .agent_observability import AgentExecutionRecord, AgentObservability
-
-
-class AgentObservabilityStore:
-    def __init__(self, root: str = "runtime/agent-observability"):
-        self.root = Path(root)
-        self.records_dir = self.root / "records"
-        self.records_dir.mkdir(parents=True, exist_ok=True)
-
-    def append(self, record: AgentExecutionRecord) -> dict[str, Any]:
-        path = self.records_dir / f"{record.execution_id}.json"
-        data = record.to_dict()
-        path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
-        return data
-
-    def load(self) -> AgentObservability:
-        observability = AgentObservability()
-        for path in sorted(self.records_dir.glob("*.json")):
-            raw = json.loads(path.read_text(encoding="utf-8"))
-            observability.records.append(AgentExecutionRecord(**raw))
-        return observability
-
-    def query(self, user_id: str | None = None, group_id: str | None = None, role: str = "user") -> list[dict[str, Any]]:
-        records = [record.to_dict() for record in self.load().records]
-        if role == "owner":
-            return records
-        if role == "group_admin" and group_id:
-            return [r for r in records if r.get("visible_scope") == group_id or r.get("user_id") == user_id]
-        return [r for r in records if r.get("user_id") == user_id]
-
-
-__all__ = ["AgentObservabilityStore"]

active-runtime/app/aios_chatgpt_actions_api.py

@@ -15,7 +15,7 @@ TOKEN_FILE = Path(os.getenv('AIOS_GITOPS_TOKEN_FILE', str(SECRETS / 'gitops.toke
 HOST = os.getenv('AIOS_GITOPS_HOST', '127.0.0.1')
 PORT = int(os.getenv('AIOS_GITOPS_PORT', '18890'))
 OPENAPI = WS / 'docs' / 'gitops' / 'openapi-chatgpt-actions.yaml'
-BARE_REPO = Path(os.getenv('AIOS_GITOPS_BARE_REPO', str(ROOT / 'runtime' / 'gitea-bin' / 'data' / 'repositories' / 'aios' / 'aios.git')))
+BARE_REPO = Path(os.getenv('AIOS_GITOPS_BARE_REPO', str(ROOT / 'runtime' / 'gitea-bin' / 'data' / 'repositories' / 'aios' / 'aios-v23.git')))
 monitor = ActionMonitor()
 
 BASE_MODELS = [
@@ -200,11 +200,6 @@ class H(BaseHTTPRequestHandler):
                 latest=monitor.latest()
                 ldict={'event_id':latest.event_id,'action':latest.action,'error':latest.error,'context':latest.context,'created_at':latest.created_at} if latest else None
                 return self.sendj({'events':[{"event_id":e.event_id,"action":e.action,"error":e.error,"context":e.context,"created_at":e.created_at} for e in monitor.list_events()],'latest':ldict})
-                        # Admin AI Evolution Dashboard
-            if path in ('/admin/ai-evolution','/admin/ai-evolution/'):
-                return self.ai_evolution_page()
-            if path in ('/admin/ai-evolution/api/data'):
-                return self.ai_evolution_data()
             return self.sendj({'error':'not_found','path':path},404)
         except Exception as e:
             monitor.record_failure('do_GET', str(e), {'path':path})
@@ -295,102 +290,9 @@ class H(BaseHTTPRequestHandler):
         elif 'model' in low or '模型' in text: intent='model_change'; plan=['use POST /api/model or PUT /api/model-priority','commit metadata']
         elif 'patch' in low or '补丁' in text: intent='patch_create'; plan=['call POST /api/patch']
         b=checkout(data.get('branch') or f'patch/nl-{uid("nl")}', 'main', True); doc={'id':uid('nl'),'text':text,'intent':intent,'action_plan':plan,'execute':False,'owner_approval_required':True,'created_by':a['account'],'created_at':now()}; r=write_json(f'patches/nl/{safe(doc["id"])}.json', doc); c=commit([r], f'chore(chatgpt): record nl plan {intent}'); self.sendj({'status':'planned','branch':b,'request':doc,'commit':c})
-    _EVOLUTION_HTML = '''<!DOCTYPE html>
-<html lang=zh-CN>
-<head>
-<meta charset=UTF-8>
-<meta name=viewport content="width=device-width,initial-scale=1.0">
-<title>AIOS Evolution Dashboard</title>
-<script src=https://cdn.jsdelivr.net/npm/vue@3/dist/vue.global.prod.js></script>
-<style>
-*{margin:0;padding:0;box-sizing:border-box}
-body{background:#0d1117;color:#c9d1d9;font-size:14px;line-height:1.7;font-family:-apple-system,BlinkMacSystemFont,Segoe UI,Helvetica,Arial,sans-serif}
-.c{max-width:1000px;margin:0 auto;padding:32px 24px}
-h1{font-size:24px;color:#58a6ff;margin-bottom:2px}
-.sub{color:#8b949e;font-size:13px;border-bottom:1px solid #21262d;padding-bottom:16px;margin-bottom:20px;display:flex;justify-content:space-between}
-.g{display:grid;grid-template-columns:repeat(auto-fill,minmax(160px,1fr));gap:16px;margin-bottom:20px}
-.s{background:#161b22;border:1px solid #21262d;border-radius:8px;padding:18px;text-align:center}
-.s .v{font-size:28px;font-weight:700;color:#f0f6fc}
-.s .l{font-size:11px;color:#8b949e;margin-top:4px}
-.bx{background:#161b22;border:1px solid #21262d;border-radius:8px;margin-bottom:14px}
-.bh{border-bottom:1px solid #21262d;padding:10px 16px;font-weight:600;font-size:14px;display:flex;gap:6px;align-items:center}
-.bd{padding:12px 16px}
-.rw{display:grid;grid-template-columns:1fr 1fr 100px 60px;gap:8px;padding:8px 16px;border-bottom:1px solid #21262d;font-size:13px;align-items:center;cursor:pointer;transition:background .15s}
-.rw:hover{background:#1c2128}.rw:last-child{border-bottom:none}
-.tg{display:inline-block;padding:2px 10px;border-radius:99px;font-size:11px;font-weight:600}
-.ok{background:#3fb95033;color:#3fb950}.fl{background:#da363333;color:#f85149}.if{background:#1f6feb33;color:#58a6ff}
-pre{background:#0d1117;padding:12px;border-radius:6px;overflow:auto;font-size:12px;color:#8b949e;max-height:300px;margin-top:8px}select{padding:8px 10px;border:1px solid #30363d;border-radius:6px;background:#21262d;color:#c9d1d9;font-size:13px;max-width:400px;width:100%;margin-bottom:4px;cursor:pointer}
-</style>
-</head>
-<body>
-<div id=app class=c>
-<h1>AIOS Evolution Dashboard</h1>
-<div class=sub><span>Baseline: {{baseline}}</span><span style=color:#8b949e>{{refreshMsg}}</span></div>
-<div class=g><div class=s><div class=v>{{tot}}</div><div class=l>Commands</div></div><div class=s><div class=v style=color:#3fb950>{{sok}}</div><div class=l>Succeeded</div></div><div class=s><div class=v style=color:#f85149>{{sfail}}</div><div class=l>Failed</div></div><div class=s><div class=v>{{runs}}</div><div class=l>Executions</div></div></div>
-<div class=bx><div class=bh>Version Timeline</div><div class=bd><div class=rw style=font-weight:600;border-bottom:2px solid #30363d;cursor:default><span>Version</span><span>Time</span><span>Result</span></div><div v-for=v in vs class=rw @click=selVer(v)><span style=color:#58a6ff>{{v.tag}}</span><span>{{v.time||'-'}}</span><span :class="'tg '+v.result">{{v.result||'-'}}</span></div></div></div>
-<div class=bx><div class=bh>Commands</div><div class=bd><select v-model=cmd @change=loadCmd><option value>-- Select --</option><option v-for=c in cmds :value=c>{{c}}</option></select><pre v-if=cdet>{{cdet}}</pre></div></div>
-<div class=bx><div class=bh>Recent Agent Runs</div><div class=bd><div class=rw style=font-weight:600;border-bottom:2px solid #30363d;cursor:default><span>Agent</span><span>Command</span><span>Count</span><span>Result</span></div><div v-for=r in aruns class=rw><span>{{r.agent||'-'}}</span><span style=overflow:hidden;white-space:nowrap;text-overflow:ellipsis>{{r.command}}</span><span>{{r.interaction_count||0}}</span><span :class="'tg '+r.final_result">{{r.final_result||'-'}}</span></div></div></div></div>
-<script>
-const{createApp,ref,onMounted}=Vue;createApp({setup(){const vs=ref([]),cmds=ref([]),ar=ref([]),cmd=ref(''),cdet=ref(null),tot=ref(0),sok=ref(0),sfail=ref(0),runs=ref(0),baseline=ref('V1R3C1'),refreshMsg=ref('')
-async function ld(){try{const r=await fetch('/admin/ai-evolution/api/data'),d=await r.json();baseline.value=d.baseline||'V1R3C1';vs.value=d.versions||[];cmds.value=d.commands||[];ar.value=d.agent_runs||[];tot.value=d.stats?.total||0;sok.value=d.stats?.success||0;sfail.value=d.stats?.failed||0;runs.value=d.stats?.agent_runs||0;refreshMsg.value='Last updated: '+new Date().toLocaleString()}catch(e){}}
-async function loadCmd(){if(!cmd.value){cdet.value=null;return}try{const r=await fetch('/admin/ai-evolution/api/data?command='+encodeURIComponent(cmd.value)),d=await r.json();cdet.value=JSON.stringify(d,null,2)}catch(e){cdet.value='Error'}}
-function selVer(v){cmd.value=v.tag||v.id||v.version;loadCmd()}
-onMounted(()=>{ld();setInterval(ld,30000)})
-return{vs,cmds,ar,cmd,cdet,tot,sok,sfail,runs,baseline,refreshMsg,loadCmd,selVer}})mount('#app')
-</script></body></html>'''
-
-    def ai_evolution_page(self):
-        self.send_response(200)
-        self.send_header('Content-Type', 'text/html; charset=utf-8')
-        self.send_header('Content-Length', str(len(self._EVOLUTION_HTML)))
-        self.end_headers()
-        self.wfile.write(self._EVOLUTION_HTML.encode())
-
-    def ai_evolution_data(self):
-        q=urllib.parse.urlparse(self.path).query
-        params=urllib.parse.parse_qs(q)
-        cmd_filter=(params.get('command') or [None])[0]
-        bl=jload(WS/'baseline'/'current.json',{})
-        current_ver=bl.get('current_baseline','V1R3C1')
-        tags=sh(['tag','--list','V*'])['stdout'].splitlines() if WS.exists() else []
-        versions=[]
-        if (WS/'baseline'/'promotions').exists():
-            for p in sorted((WS/'baseline'/'promotions').glob('*.json')):
-                d=jload(p,{});v=d.get('version',p.stem)
-                versions.append({'tag':v,'time':d.get('promoted_at','-'),'result':'ok'})
-        for t in tags:
-            if not any(v['tag']==t for v in versions):
-                versions.append({'tag':t,'time':'-','result':'if'})
-        agent_runs=[];ard=WS/'audit'/'agent-runs'
-        if ard.exists():
-            for f in sorted(ard.glob('*.json'),reverse=True)[:50]:
-                d=jload(f,{});agent_runs.append(d) if isinstance(d,dict) else None
-        cmd_dirs=[WS/'agents/commands/active',WS/'agents/commands/running',WS/'agents/commands/completed',WS/'agents/commands/failed']
-        commands=[]
-        for d in cmd_dirs:
-            if d.exists():
-                for f in sorted(d.glob('*.md')):
-                    commands.append(f.name)
-        command_detail=None
-        if cmd_filter:
-            for d in cmd_dirs:
-                if d.exists():
-                    fp=d/cmd_filter
-                    if fp.exists():
-                        command_detail={'command':cmd_filter,'content':fp.read_text(encoding='utf-8')}
-                        break
-            if not command_detail:
-                command_detail={'command':cmd_filter,'error':'not_found'}
-            return self.sendj(command_detail)
-        completed=list((WS/'agents/commands/completed').glob('*.md')) if (WS/'agents/commands/completed').exists() else []
-        failed=list((WS/'agents/commands/failed').glob('*.md')) if (WS/'agents/commands/failed').exists() else []
-        stats={'total':len(commands),'success':len(completed),'failed':len(failed),'agent_runs':len(agent_runs)}
-        data={'baseline':current_ver,'versions':versions[-30:],'agent_runs':agent_runs,'commands':sorted(set(commands)),'stats':stats}
-        self.sendj(data)
-
 
 def api_spec():
-    return {'version':'V1R1C0-chatgpt-actions','openapi':'/api/openapi.yaml','read':['GET /api/base','GET /api/ver','GET /api/diff','GET /api/patch','GET /api/model','GET /api/run','GET /admin/ai-evolution'],'write':['POST /api/branch','POST /api/file','POST /api/commit','POST /api/patch','POST /api/tag','POST /api/rollback','POST /api/model','PUT /api/model-priority','POST /api/nl'],'policy':{'bearer_required_for_write':True,'direct_main_push':False,'delete_tag':False,'owner_approval_required_for_v_level':True,'api_keys_in_git':False,'git_secret_field':'secret_ref','online_git_sync':True}}
+    return {'version':'V1R1C0-chatgpt-actions','openapi':'/api/openapi.yaml','read':['GET /api/base','GET /api/ver','GET /api/diff','GET /api/patch','GET /api/model','GET /api/run'],'write':['POST /api/branch','POST /api/file','POST /api/commit','POST /api/patch','POST /api/tag','POST /api/rollback','POST /api/model','PUT /api/model-priority','POST /api/nl'],'policy':{'bearer_required_for_write':True,'direct_main_push':False,'delete_tag':False,'owner_approval_required_for_v_level':True,'api_keys_in_git':False,'git_secret_field':'secret_ref','online_git_sync':True}}
 
 def main():
     print(f'AIOS ChatGPT GitOps adapter listening on {HOST}:{PORT}')

active-runtime/app/architect_governance_agent.py

@@ -1,120 +0,0 @@
-"""Architect governance agent responsibilities.
-
-This agent records requirement changes, maintains versioned human-readable
-requirement/architecture/deployment/test documents, reviews architecture changes,
-validates deployment docs against actual configuration, and produces version bump
-recommendations.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass(frozen=True)
-class RequirementChange:
-    id: str
-    source: str
-    actor: str
-    requirement: str
-    created_at: str = field(default_factory=utc_now)
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class DocumentRefreshPlan:
-    requirement_doc: bool
-    architecture_doc: bool
-    deployment_doc: bool
-    test_case_doc: bool
-    reason: str
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class ArchitectureReviewDecision:
-    status: str
-    findings: list[str]
-    optimization_recommendations: list[str]
-    version_bump: str
-    docs_to_refresh: DocumentRefreshPlan
-    created_at: str = field(default_factory=utc_now)
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "status": self.status,
-            "findings": self.findings,
-            "optimization_recommendations": self.optimization_recommendations,
-            "version_bump": self.version_bump,
-            "docs_to_refresh": self.docs_to_refresh.to_dict(),
-            "created_at": self.created_at,
-        }
-
-
-class ArchitectGovernanceAgent:
-    """Independent architecture governance role."""
-
-    def record_requirement_change(self, source: str, actor: str, requirement: str) -> RequirementChange:
-        change_id = "REQ-" + datetime.now(timezone.utc).strftime("%Y%m%d%H%M%S")
-        return RequirementChange(change_id, source, actor, requirement)
-
-    def review_architecture_change(self, proposal: dict[str, Any]) -> ArchitectureReviewDecision:
-        impact = proposal.get("impact", "medium")
-        findings = [
-            "requirement_traceability_checked",
-            "architecture_consistency_checked",
-            "deployment_doc_alignment_checked",
-            "test_case_doc_required",
-            "rollback_and_owner_gate_checked",
-        ]
-        recommendations = [
-            "refresh user requirements document",
-            "refresh architecture design document",
-            "refresh engineering deployment document",
-            "generate acceptance test case document",
-        ]
-        version_bump = self.decide_version_bump(proposal)
-        return ArchitectureReviewDecision(
-            status="review_required" if impact in {"high", "architecture"} else "pass",
-            findings=findings,
-            optimization_recommendations=recommendations,
-            version_bump=version_bump,
-            docs_to_refresh=DocumentRefreshPlan(True, True, True, True, "architecture or requirement changed"),
-        )
-
-    def decide_version_bump(self, proposal: dict[str, Any]) -> str:
-        if proposal.get("breaks_architecture") or proposal.get("major_capability"):
-            return "V"
-        if proposal.get("new_release_capability") or proposal.get("architecture_change"):
-            return "R"
-        return "C"
-
-    def validate_deployment_doc(self, deployment_doc: dict[str, Any], actual_config: dict[str, Any]) -> dict[str, Any]:
-        expected = set(deployment_doc.get("services", []))
-        actual = set(actual_config.get("services", []))
-        missing = sorted(expected - actual)
-        extra = sorted(actual - expected)
-        return {
-            "status": "pass" if not missing else "attention_required",
-            "missing_services": missing,
-            "extra_services": extra,
-            "checked_at": utc_now(),
-        }
-
-
-__all__ = [
-    "RequirementChange",
-    "DocumentRefreshPlan",
-    "ArchitectureReviewDecision",
-    "ArchitectGovernanceAgent",
-]

active-runtime/app/architect_governance_api.py

@@ -1,32 +0,0 @@
-"""API for Architect Governance Center."""
-
-try:
-    from fastapi import APIRouter
-except Exception:
-    APIRouter = None
-
-from .architect_governance_dashboard import ArchitectGovernanceDashboard
-
-
-dashboard = ArchitectGovernanceDashboard()
-
-
-def get_architect_governance_overview():
-    return dashboard.overview()
-
-
-def build_router():
-    if APIRouter is None:
-        return None
-    router = APIRouter(prefix="/admin/ai-evolution/architect", tags=["architect-governance"])
-
-    @router.get("/overview", operation_id="getArchitectGovernanceOverview")
-    def overview():
-        return get_architect_governance_overview()
-
-    return router
-
-
-router = build_router()
-
-__all__ = ["router", "get_architect_governance_overview"]

active-runtime/app/architect_governance_dashboard.py

@@ -1,153 +0,0 @@
-"""Web UI dashboard model for Architect Governance Agent.
-
-Shows requirement changes, architecture review findings, document refresh status,
-deployment consistency, test case readiness, weekly research and V/R/C version
-recommendations.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass(frozen=True)
-class ArchitectPanelMetric:
-    key: str
-    title: str
-    value: Any
-    status: str = "ok"
-    detail: str = ""
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class ArchitectPanel:
-    key: str
-    title: str
-    description: str
-    metrics: list[ArchitectPanelMetric] = field(default_factory=list)
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "key": self.key,
-            "title": self.title,
-            "description": self.description,
-            "metrics": [m.to_dict() for m in self.metrics],
-        }
-
-
-class ArchitectGovernanceDashboard:
-    def overview(
-        self,
-        requirement_changes: list[dict[str, Any]] | None = None,
-        architecture_reviews: list[dict[str, Any]] | None = None,
-        document_status: dict[str, Any] | None = None,
-        research_status: dict[str, Any] | None = None,
-        version_recommendations: list[dict[str, Any]] | None = None,
-    ) -> dict[str, Any]:
-        requirement_changes = requirement_changes or []
-        architecture_reviews = architecture_reviews or []
-        document_status = document_status or {}
-        research_status = research_status or {}
-        version_recommendations = version_recommendations or []
-        panels = [
-            self.requirement_panel(requirement_changes),
-            self.architecture_panel(architecture_reviews),
-            self.document_panel(document_status),
-            self.research_panel(research_status),
-            self.version_panel(version_recommendations),
-        ]
-        return {
-            "module": "architect-governance",
-            "route": "/admin/ai-evolution/architect",
-            "title": "架构师 Agent 治理中心",
-            "status": "attention_required" if any(self._panel_warn(panel) for panel in panels) else "healthy",
-            "generated_at": utc_now(),
-            "panels": [panel.to_dict() for panel in panels],
-            "requirement_changes": requirement_changes,
-            "architecture_reviews": architecture_reviews,
-            "version_recommendations": version_recommendations,
-        }
-
-    def requirement_panel(self, changes: list[dict[str, Any]]) -> ArchitectPanel:
-        return ArchitectPanel(
-            key="requirements",
-            title="需求变化记录",
-            description="记录来自 Custom GPT、Codex、OpenClaw、Hermes 和用户反馈的需求变化。",
-            metrics=[
-                ArchitectPanelMetric("total_requirement_changes", "需求变化数量", len(changes)),
-                ArchitectPanelMetric(
-                    "undocumented_changes",
-                    "待刷新到用户需求文档",
-                    len([c for c in changes if not c.get("documented")]),
-                    "warn" if any(not c.get("documented") for c in changes) else "ok",
-                ),
-            ],
-        )
-
-    def architecture_panel(self, reviews: list[dict[str, Any]]) -> ArchitectPanel:
-        pending = [r for r in reviews if r.get("status") not in {"pass", "not_required"}]
-        return ArchitectPanel(
-            key="architecture_review",
-            title="全量架构审视",
-            description="展示架构一致性、扩展性、安全边界、可运维性和回滚策略审查。",
-            metrics=[
-                ArchitectPanelMetric("review_count", "架构审查数量", len(reviews)),
-                ArchitectPanelMetric("pending_reviews", "待处理架构审查", len(pending), "warn" if pending else "ok"),
-            ],
-        )
-
-    def document_panel(self, status: dict[str, Any]) -> ArchitectPanel:
-        required_docs = ["requirements", "architecture", "deployment", "test_cases"]
-        missing = [doc for doc in required_docs if status.get(doc) not in {"ready", "updated"}]
-        return ArchitectPanel(
-            key="documents",
-            title="文档版本化状态",
-            description="用户需求、架构设计、工程部署、测试例文档刷新状态。",
-            metrics=[
-                ArchitectPanelMetric("requirements_doc", "用户需求文档", status.get("requirements", "unknown"), "warn" if "requirements" in missing else "ok"),
-                ArchitectPanelMetric("architecture_doc", "架构设计文档", status.get("architecture", "unknown"), "warn" if "architecture" in missing else "ok"),
-                ArchitectPanelMetric("deployment_doc", "工程部署文档", status.get("deployment", "unknown"), "warn" if "deployment" in missing else "ok"),
-                ArchitectPanelMetric("test_case_doc", "测试例文档", status.get("test_cases", "unknown"), "warn" if "test_cases" in missing else "ok"),
-            ],
-        )
-
-    def research_panel(self, status: dict[str, Any]) -> ArchitectPanel:
-        overdue = bool(status.get("overdue"))
-        return ArchitectPanel(
-            key="weekly_research",
-            title="每周外部技术情报",
-            description="联网搜索 Agent/模型版本、GitHub top 实现、潜在安全影响。",
-            metrics=[
-                ArchitectPanelMetric("last_research_at", "最近调研时间", status.get("last_research_at", "never"), "warn" if overdue else "ok"),
-                ArchitectPanelMetric("findings", "发现数量", status.get("findings", 0)),
-                ArchitectPanelMetric("optimization_candidates", "可借鉴优化项", status.get("optimization_candidates", 0)),
-            ],
-        )
-
-    def version_panel(self, recommendations: list[dict[str, Any]]) -> ArchitectPanel:
-        latest = recommendations[-1] if recommendations else {}
-        return ArchitectPanel(
-            key="version_decision",
-            title="V/R/C 版本建议",
-            description="由架构师 Agent 判断变更应进入 C、R 或 V。",
-            metrics=[
-                ArchitectPanelMetric("recommendation_count", "版本建议数量", len(recommendations)),
-                ArchitectPanelMetric("latest_recommendation", "最近建议", latest.get("version_bump", "none")),
-                ArchitectPanelMetric("reason", "建议原因", latest.get("reason", "")),
-            ],
-        )
-
-    def _panel_warn(self, panel: ArchitectPanel) -> bool:
-        return any(metric.status == "warn" for metric in panel.metrics)
-
-
-__all__ = ["ArchitectPanelMetric", "ArchitectPanel", "ArchitectGovernanceDashboard"]

active-runtime/app/architect_research_dashboard.py

@@ -1,40 +0,0 @@
-"""Web UI model for Architect weekly research."""
-
-from .architect_weekly_research_agent import ArchitectWeeklyResearchAgent
-
-
-class ArchitectResearchDashboard:
-    def __init__(self, agent=None):
-        self.agent = agent or ArchitectWeeklyResearchAgent()
-
-    def overview(self):
-        return {
-            "module": "architect-weekly-research",
-            "route": "/admin/ai-evolution/architect/research",
-            "title": "架构师 Agent 技术情报中心",
-            "panels": [
-                {
-                    "title": "Research Targets",
-                    "data": self.agent.plan(),
-                },
-                {
-                    "title": "Evaluation",
-                    "fields": [
-                        "relevance",
-                        "impact",
-                        "recommendation",
-                    ],
-                },
-                {
-                    "title": "Version Decision",
-                    "fields": [
-                        "C",
-                        "R",
-                        "V",
-                    ],
-                },
-            ],
-        }
-
-
-__all__ = ["ArchitectResearchDashboard"]

active-runtime/app/architect_research_timeline.py

@@ -1,122 +0,0 @@
-"""Architect research timeline dashboard.
-
-Shows weekly external research findings as a traceable architecture-impact flow:
-research target -> finding -> impact -> recommendation -> version decision ->
-governance event.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass(frozen=True)
-class ResearchTimelineStep:
-    id: str
-    title: str
-    step_type: str
-    status: str
-    source: str
-    timestamp: str
-    impact: str = "none"
-    version_bump: str = "none"
-    detail: dict[str, Any] = field(default_factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-class ArchitectResearchTimeline:
-    ORDER = {
-        "research_planned": 10,
-        "finding_created": 20,
-        "impact_analyzed": 30,
-        "recommendation_created": 40,
-        "version_decision_created": 50,
-        "architecture_review_event_created": 60,
-    }
-
-    def build(self, findings: list[dict[str, Any]] | None = None, decisions: list[dict[str, Any]] | None = None) -> dict[str, Any]:
-        findings = findings or []
-        decisions = decisions or []
-        steps: list[ResearchTimelineStep] = [
-            ResearchTimelineStep(
-                id="research-plan",
-                title="每周技术情报调研计划",
-                step_type="research_planned",
-                status="ok",
-                source="architect-agent",
-                timestamp=utc_now(),
-                detail={"cadence": "weekly"},
-            )
-        ]
-        for idx, finding in enumerate(findings):
-            steps.append(
-                ResearchTimelineStep(
-                    id=finding.get("id", f"finding-{idx}"),
-                    title=finding.get("title", "research finding"),
-                    step_type="finding_created",
-                    status="ok",
-                    source=finding.get("source", "unknown"),
-                    timestamp=finding.get("created_at", utc_now()),
-                    impact=finding.get("impact", "none"),
-                    detail=finding,
-                )
-            )
-            steps.append(
-                ResearchTimelineStep(
-                    id=f"impact-{finding.get('id', idx)}",
-                    title="架构影响分析",
-                    step_type="impact_analyzed",
-                    status="attention_required" if finding.get("impact") in {"architecture", "breaking", "new_capability"} else "ok",
-                    source="architect-agent",
-                    timestamp=utc_now(),
-                    impact=finding.get("impact", "none"),
-                    detail={"relevance": finding.get("relevance"), "recommendation": finding.get("recommendation")},
-                )
-            )
-        for idx, decision in enumerate(decisions):
-            steps.append(
-                ResearchTimelineStep(
-                    id=decision.get("id", f"decision-{idx}"),
-                    title="C/R/V 版本建议",
-                    step_type="version_decision_created",
-                    status=decision.get("status", "ok"),
-                    source="architect-agent",
-                    timestamp=decision.get("created_at", utc_now()),
-                    version_bump=decision.get("version_bump", "none"),
-                    detail=decision,
-                )
-            )
-        steps.sort(key=lambda s: (self.ORDER.get(s.step_type, 999), s.timestamp))
-        return {
-            "module": "architect-research-timeline",
-            "route": "/admin/ai-evolution/architect/research/timeline",
-            "title": "架构师技术情报时间线",
-            "status": self._status(steps),
-            "generated_at": utc_now(),
-            "steps": [step.to_dict() for step in steps],
-            "summary": self._summary(steps),
-        }
-
-    def _status(self, steps: list[ResearchTimelineStep]) -> str:
-        if any(step.status == "attention_required" for step in steps):
-            return "attention_required"
-        return "healthy"
-
-    def _summary(self, steps: list[ResearchTimelineStep]) -> dict[str, Any]:
-        return {
-            "findings": len([s for s in steps if s.step_type == "finding_created"]),
-            "architecture_impacts": len([s for s in steps if s.impact in {"architecture", "breaking", "new_capability"}]),
-            "version_decisions": len([s for s in steps if s.step_type == "version_decision_created"]),
-            "recommended_bumps": sorted({s.version_bump for s in steps if s.version_bump != "none"}),
-        }
-
-
-__all__ = ["ResearchTimelineStep", "ArchitectResearchTimeline"]

active-runtime/app/architect_research_timeline_api.py

@@ -1,32 +0,0 @@
-"""API for architect research timeline."""
-
-try:
-    from fastapi import APIRouter
-except Exception:
-    APIRouter = None
-
-from .architect_research_timeline import ArchitectResearchTimeline
-
-
-timeline = ArchitectResearchTimeline()
-
-
-def get_architect_research_timeline():
-    return timeline.build()
-
-
-def build_router():
-    if APIRouter is None:
-        return None
-    router = APIRouter(prefix="/admin/ai-evolution/architect/research", tags=["architect-research"])
-
-    @router.get("/timeline", operation_id="getArchitectResearchTimeline")
-    def get_timeline():
-        return get_architect_research_timeline()
-
-    return router
-
-
-router = build_router()
-
-__all__ = ["router", "get_architect_research_timeline"]

active-runtime/app/architect_weekly_research_agent.py

@@ -1,113 +0,0 @@
-"""Weekly external research loop for Architect Governance Agent.
-
-The agent plans and normalizes weekly research tasks. Actual internet access is
-provided by the runtime/search worker; this module defines the audited workflow,
-findings, impact analysis, and V/R/C recommendations.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-from uuid import uuid4
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass(frozen=True)
-class ResearchTarget:
-    id: str
-    topic: str
-    source_type: str
-    query: str
-    cadence: str = "weekly"
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class ResearchFinding:
-    id: str
-    target_id: str
-    title: str
-    summary: str
-    source: str
-    relevance: str
-    impact: str
-    recommendation: str
-    created_at: str = field(default_factory=utc_now)
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class ResearchDecision:
-    status: str
-    version_bump: str
-    reason: str
-    findings: list[ResearchFinding]
-    created_at: str = field(default_factory=utc_now)
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "status": self.status,
-            "version_bump": self.version_bump,
-            "reason": self.reason,
-            "findings": [f.to_dict() for f in self.findings],
-            "created_at": self.created_at,
-        }
-
-
-class ArchitectWeeklyResearchAgent:
-    DEFAULT_TARGETS = (
-        ResearchTarget("agent-frameworks", "Agent framework versions", "web", "latest multi-agent orchestration framework releases"),
-        ResearchTarget("model-ecosystem", "Model ecosystem changes", "web", "latest LLM model releases tool calling agent features"),
-        ResearchTarget("github-top-agentops", "GitHub top AgentOps implementations", "github", "top repositories agent observability multi agent orchestration"),
-        ResearchTarget("security-agent-risks", "Agent security changes", "web", "latest AI agent security sandbox prompt injection tool use risks"),
-    )
-
-    def plan(self) -> dict[str, Any]:
-        return {
-            "status": "planned",
-            "cadence": "weekly",
-            "targets": [target.to_dict() for target in self.DEFAULT_TARGETS],
-            "created_at": utc_now(),
-        }
-
-    def normalize_finding(
-        self,
-        target_id: str,
-        title: str,
-        summary: str,
-        source: str,
-        relevance: str = "medium",
-        impact: str = "none",
-        recommendation: str = "monitor",
-    ) -> ResearchFinding:
-        return ResearchFinding(
-            id=f"finding_{uuid4().hex[:12]}",
-            target_id=target_id,
-            title=title,
-            summary=summary,
-            source=source,
-            relevance=relevance,
-            impact=impact,
-            recommendation=recommendation,
-        )
-
-    def decide(self, findings: list[ResearchFinding]) -> ResearchDecision:
-        if any(f.impact == "breaking" for f in findings):
-            return ResearchDecision("action_required", "V", "breaking external ecosystem change", findings)
-        if any(f.impact in {"architecture", "new_capability"} for f in findings):
-            return ResearchDecision("optimization_recommended", "R", "external capability may improve architecture", findings)
-        if any(f.impact in {"bugfix", "minor"} for f in findings):
-            return ResearchDecision("minor_change_recommended", "C", "minor compatible improvement", findings)
-        return ResearchDecision("no_action", "none", "no relevant external change", findings)
-
-
-__all__ = ["ResearchTarget", "ResearchFinding", "ResearchDecision", "ArchitectWeeklyResearchAgent"]

active-runtime/app/architecture_change_api.py

@@ -1,32 +0,0 @@
-"""API for architecture change governance dashboard."""
-
-try:
-    from fastapi import APIRouter
-except Exception:
-    APIRouter = None
-
-from .architecture_change_dashboard import ArchitectureChangeDashboard
-
-
-dashboard = ArchitectureChangeDashboard()
-
-
-def get_architecture_change_overview():
-    return dashboard.overview()
-
-
-def build_router():
-    if APIRouter is None:
-        return None
-    router = APIRouter(prefix="/admin/ai-evolution/architecture-changes", tags=["architecture-changes"])
-
-    @router.get("/overview", operation_id="getArchitectureChangeOverview")
-    def overview():
-        return get_architecture_change_overview()
-
-    return router
-
-
-router = build_router()
-
-__all__ = ["router", "get_architecture_change_overview"]

active-runtime/app/architecture_change_classifier.py

@@ -1,90 +0,0 @@
-"""Architecture change classification.
-
-Small compatible architecture changes may be handled automatically by the
-Architect Agent with audit evidence. Large, risky, production-impacting or
-breaking architecture changes require explicit Owner approval before
-implementation.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from typing import Any
-
-
-@dataclass(frozen=True)
-class ArchitectureChangeClassification:
-    level: str
-    owner_required: bool
-    auto_implement_allowed: bool
-    version_bump: str
-    reasons: list[str] = field(default_factory=list)
-    required_gates: list[str] = field(default_factory=list)
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-class ArchitectureChangeClassifier:
-    """Classifies architecture changes into small/medium/large governance paths."""
-
-    LARGE_FLAGS = {
-        "breaking_change",
-        "breaks_architecture",
-        "production_architecture_update",
-        "security_boundary_change",
-        "cross_tenant_effect",
-        "cross_user_data_effect",
-        "data_migration",
-        "permission_model_change",
-        "runtime_infrastructure_change",
-    }
-
-    def classify(self, change: dict[str, Any]) -> ArchitectureChangeClassification:
-        risk = str(change.get("risk", "medium")).lower()
-        version_bump = str(change.get("version_bump", change.get("recommended_version_bump", "C"))).upper()
-        scope = str(change.get("scope", "component")).lower()
-        reasons: list[str] = []
-
-        for flag in sorted(self.LARGE_FLAGS):
-            if change.get(flag):
-                reasons.append(flag)
-
-        if risk in {"high", "critical"}:
-            reasons.append(f"risk={risk}")
-        if version_bump == "V":
-            reasons.append("version_bump=V")
-        if version_bump == "R" and scope in {"system", "platform", "production", "cross_agent", "cross_tenant"}:
-            reasons.append(f"version_bump=R scope={scope}")
-
-        if reasons:
-            return ArchitectureChangeClassification(
-                level="large",
-                owner_required=True,
-                auto_implement_allowed=False,
-                version_bump=version_bump,
-                reasons=reasons,
-                required_gates=["architect_review", "owner_architecture_approval", "test_gate", "promotion_gate"],
-            )
-
-        if risk == "low" and version_bump in {"C", "NONE"} and scope in {"component", "local", "documentation", "test"}:
-            return ArchitectureChangeClassification(
-                level="small",
-                owner_required=False,
-                auto_implement_allowed=True,
-                version_bump=version_bump,
-                reasons=["low_risk_compatible_change"],
-                required_gates=["architect_review", "audit", "test_gate"],
-            )
-
-        return ArchitectureChangeClassification(
-            level="medium",
-            owner_required=False,
-            auto_implement_allowed=False,
-            version_bump=version_bump,
-            reasons=["requires_architect_review_before_implementation"],
-            required_gates=["architect_review", "test_gate", "audit"],
-        )
-
-
-__all__ = ["ArchitectureChangeClassification", "ArchitectureChangeClassifier"]

active-runtime/app/architecture_change_dashboard.py

@@ -1,93 +0,0 @@
-"""Architecture change governance dashboard.
-
-Displays architecture change classification, owner approval requirements,
-implementation readiness, version recommendation and audit evidence for Web UI.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-
-from .architecture_change_classifier import ArchitectureChangeClassifier
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass(frozen=True)
-class ArchitectureChangeView:
-    change_id: str
-    title: str
-    level: str
-    owner_required: bool
-    auto_implement_allowed: bool
-    version_bump: str
-    status: str
-    reasons: list[str] = field(default_factory=list)
-    required_gates: list[str] = field(default_factory=list)
-    owner_decision: str | None = None
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-class ArchitectureChangeDashboard:
-    def __init__(self, classifier: ArchitectureChangeClassifier | None = None):
-        self.classifier = classifier or ArchitectureChangeClassifier()
-
-    def overview(self, changes: list[dict[str, Any]] | None = None) -> dict[str, Any]:
-        changes = changes or []
-        views = [self._view(change) for change in changes]
-        return {
-            "module": "architecture-change-governance",
-            "route": "/admin/ai-evolution/architecture-changes",
-            "title": "架构变更治理中心",
-            "status": self._status(views),
-            "generated_at": utc_now(),
-            "summary": self._summary(views),
-            "changes": [view.to_dict() for view in views],
-        }
-
-    def _view(self, change: dict[str, Any]) -> ArchitectureChangeView:
-        classification = self.classifier.classify(change)
-        owner_decision = change.get("owner_decision")
-        if classification.owner_required and owner_decision != "approved":
-            status = "waiting_owner_approval"
-        elif classification.auto_implement_allowed:
-            status = "auto_implementation_allowed"
-        else:
-            status = "ready_after_required_gates"
-        return ArchitectureChangeView(
-            change_id=change.get("change_id", change.get("id", "unknown")),
-            title=change.get("title", "architecture change"),
-            level=classification.level,
-            owner_required=classification.owner_required,
-            auto_implement_allowed=classification.auto_implement_allowed,
-            version_bump=classification.version_bump,
-            status=status,
-            reasons=classification.reasons,
-            required_gates=classification.required_gates,
-            owner_decision=owner_decision,
-        )
-
-    def _status(self, views: list[ArchitectureChangeView]) -> str:
-        if any(view.status == "waiting_owner_approval" for view in views):
-            return "attention_required"
-        return "healthy"
-
-    def _summary(self, views: list[ArchitectureChangeView]) -> dict[str, Any]:
-        return {
-            "total": len(views),
-            "small": len([v for v in views if v.level == "small"]),
-            "medium": len([v for v in views if v.level == "medium"]),
-            "large": len([v for v in views if v.level == "large"]),
-            "waiting_owner_approval": len([v for v in views if v.status == "waiting_owner_approval"]),
-            "auto_allowed": len([v for v in views if v.auto_implement_allowed]),
-            "version_bumps": sorted({v.version_bump for v in views if v.version_bump and v.version_bump != "NONE"}),
-        }
-
-
-__all__ = ["ArchitectureChangeView", "ArchitectureChangeDashboard"]

active-runtime/app/architecture_owner_gate.py

@@ -1,89 +0,0 @@
-"""Owner approval gate for architecture changes.
-
-Architecture changes may be proposed, reviewed and optimized by agents, but they
-must not be implemented until owner approval is recorded. This gate sits before
-implementation and before promotion.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass(frozen=True)
-class ArchitectureOwnerApprovalRequest:
-    request_id: str
-    change_id: str
-    title: str
-    reason: str
-    risk: str
-    architect_decision: str
-    status: str = "pending_owner_approval"
-    created_at: str = field(default_factory=utc_now)
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class ArchitectureOwnerDecision:
-    request_id: str
-    change_id: str
-    decision: str
-    decided_by: str
-    reason: str = ""
-    decided_at: str = field(default_factory=utc_now)
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-class ArchitectureOwnerGate:
-    """Blocks architecture implementation until owner explicitly approves."""
-
-    def create_request(self, change: dict[str, Any], architect_decision: dict[str, Any]) -> ArchitectureOwnerApprovalRequest:
-        return ArchitectureOwnerApprovalRequest(
-            request_id=f"ARCH-OWNER-{change.get('change_id', change.get('id', 'unknown'))}",
-            change_id=change.get("change_id", change.get("id", "unknown")),
-            title=change.get("title", "architecture change"),
-            reason=change.get("reason", "architecture impact requires owner approval"),
-            risk=change.get("risk", "medium"),
-            architect_decision=architect_decision.get("status", "reviewed"),
-        )
-
-    def can_implement(self, request: dict[str, Any], decision: dict[str, Any] | None = None) -> dict[str, Any]:
-        if not decision:
-            return {
-                "allowed": False,
-                "status": "waiting_owner_approval",
-                "reason": "architecture change requires owner approval before implementation",
-                "request": request,
-            }
-        if decision.get("decision") == "approved":
-            return {
-                "allowed": True,
-                "status": "owner_approved",
-                "reason": decision.get("reason", "approved by owner"),
-                "request": request,
-                "decision": decision,
-            }
-        return {
-            "allowed": False,
-            "status": "owner_rejected",
-            "reason": decision.get("reason", "rejected by owner"),
-            "request": request,
-            "decision": decision,
-        }
-
-
-__all__ = [
-    "ArchitectureOwnerApprovalRequest",
-    "ArchitectureOwnerDecision",
-    "ArchitectureOwnerGate",
-]

active-runtime/app/architecture_owner_gate_http.py

@@ -1,79 +0,0 @@
-"""HTTP handler and display data for architecture owner gate."""
-
-from __future__ import annotations
-
-from dataclasses import asdict
-from datetime import datetime, timezone
-from typing import Any
-
-from .architecture_owner_gate import ArchitectureOwnerGate, ArchitectureOwnerApprovalRequest
-
-
-gate = ArchitectureOwnerGate()
-
-# In-memory store for pending approval requests
-_pending_requests: dict[str, dict[str, Any]] = {}
-_decisions: dict[str, dict[str, Any]] = {}
-
-
-def create_owner_approval_request(change: dict[str, Any], architect_decision: dict[str, Any]) -> dict[str, Any]:
-    req = gate.create_request(change, architect_decision)
-    d = asdict(req)
-    _pending_requests[req.change_id] = d
-    return d
-
-
-def approve_request(change_id: str, decided_by: str = "owner", reason: str = "") -> dict[str, Any]:
-    req = _pending_requests.get(change_id)
-    if not req:
-        return {"error": f"no pending request for change_id={change_id}"}
-    decision = asdict(
-        ArchitectureOwnerApprovalRequest.__bases__[1].__new__(type("_ArchitectureOwnerDecision", (), {}))  # noqa
-    )
-    try:
-        from .architecture_owner_gate import ArchitectureOwnerDecision
-        dec = ArchitectureOwnerDecision(
-            request_id=req["request_id"],
-            change_id=change_id,
-            decision="approved",
-            decided_by=decided_by,
-            reason=reason,
-        )
-        d = asdict(dec)
-        _decisions[change_id] = d
-        # remove from pending
-        _pending_requests.pop(change_id, None)
-        return {"allowed": True, "decision": d}
-    except Exception as exc:
-        return {"error": str(exc)}
-
-
-def reject_request(change_id: str, decided_by: str = "owner", reason: str = "") -> dict[str, Any]:
-    from .architecture_owner_gate import ArchitectureOwnerDecision
-    req = _pending_requests.get(change_id)
-    if not req:
-        return {"error": f"no pending request for change_id={change_id}"}
-    try:
-        dec = ArchitectureOwnerDecision(
-            request_id=req["request_id"],
-            change_id=change_id,
-            decision="rejected",
-            decided_by=decided_by,
-            reason=reason,
-        )
-        d = asdict(dec)
-        _decisions[change_id] = d
-        _pending_requests.pop(change_id, None)
-        return {"allowed": False, "decision": d}
-    except Exception as exc:
-        return {"error": str(exc)}
-
-
-def get_owner_gate_overview() -> dict[str, Any]:
-    return {
-        "pending_requests": list(_pending_requests.values()),
-        "decisions": list(_decisions.values()),
-        "pending_count": len(_pending_requests),
-        "approved_count": sum(1 for d in _decisions.values() if d.get("decision") == "approved"),
-        "rejected_count": sum(1 for d in _decisions.values() if d.get("decision") == "rejected"),
-    }

active-runtime/app/architecture_review_agent.py

@@ -1,40 +0,0 @@
-"""Independent architecture optimization agent."""
-
-from dataclasses import dataclass, asdict
-from datetime import datetime, timezone
-
-
-def utc_now():
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass(frozen=True)
-class ArchitectureReview:
-    agent: str
-    decision: str
-    findings: list[str]
-    created_at: str = utc_now()
-
-    def to_dict(self):
-        return asdict(self)
-
-
-class ArchitectureReviewAgent:
-    """Reviews architecture changes from system-wide optimal perspective."""
-
-    def review(self, proposal: dict) -> ArchitectureReview:
-        findings = [
-            "dependency_impact_checked",
-            "security_boundary_checked",
-            "scalability_checked",
-            "operability_checked",
-            "rollback_strategy_checked",
-        ]
-        return ArchitectureReview(
-            "architecture-optimization-agent",
-            "pass" if proposal.get("architecture_change") else "not_required",
-            findings,
-        )
-
-
-__all__ = ["ArchitectureReviewAgent", "ArchitectureReview"]

active-runtime/app/autonomous_goal_completion.py

@@ -1,143 +0,0 @@
-"""Autonomous goal completion supervisor.
-
-Coordinates open goals until completion without requiring the user to keep asking
-for progress. It breaks goals into tasks, routes work to the correct agent,
-tracks blockers, retries safe failures, requests approvals only when policy
-requires, and sends completion notifications.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-from uuid import uuid4
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass(frozen=True)
-class CompletionGoal:
-    goal_id: str
-    title: str
-    owner: str
-    status: str = "open"
-    priority: str = "P1"
-    target_signals: list[str] = field(default_factory=list)
-    tasks: list[dict[str, Any]] = field(default_factory=list)
-    created_at: str = field(default_factory=utc_now)
-    updated_at: str = field(default_factory=utc_now)
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class CompletionDecision:
-    status: str
-    action: str
-    assigned_to: str
-    reason: str
-    requires_user: bool = False
-    requires_owner_gate: bool = False
-    notification_required: bool = True
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-class AutonomousGoalCompletionSupervisor:
-    """Completes goals through AIOS autonomous loops."""
-
-    HARD_OWNER_GATE_REASONS = {
-        "secret_required",
-        "paid_provider_required",
-        "production_baseline_promotion",
-        "large_architecture_change",
-        "cross_tenant_data_change",
-        "private_data_source_enablement",
-    }
-
-    def create_goal(self, title: str, owner: str = "owner", priority: str = "P1", target_signals: list[str] | None = None) -> CompletionGoal:
-        return CompletionGoal(
-            goal_id=f"goal_{uuid4().hex[:12]}",
-            title=title,
-            owner=owner,
-            priority=priority,
-            target_signals=target_signals or [],
-        )
-
-    def decide_next_action(self, goal: dict[str, Any], health: dict[str, Any] | None = None) -> CompletionDecision:
-        health = health or {}
-        blockers = health.get("blockers", []) if isinstance(health.get("blockers"), list) else []
-        owner_reason = self._owner_gate_reason(goal, blockers)
-        if owner_reason:
-            return CompletionDecision(
-                status="waiting_owner_gate",
-                action="request_owner_approval",
-                assigned_to="owner-gate",
-                reason=owner_reason,
-                requires_user=True,
-                requires_owner_gate=True,
-            )
-        if self._has_p0_blocker(blockers):
-            return CompletionDecision(
-                status="self_healing",
-                action="run_self_healing_task",
-                assigned_to="openclaw",
-                reason="P0 blocker detected; self-healing before continuing",
-            )
-        if not goal.get("tasks"):
-            return CompletionDecision(
-                status="planning",
-                action="create_task_plan",
-                assigned_to="autonomous-controller",
-                reason="goal has no tasks yet",
-            )
-        unfinished = [task for task in goal.get("tasks", []) if task.get("status") not in {"completed", "closed"}]
-        if unfinished:
-            return CompletionDecision(
-                status="executing",
-                action="continue_unfinished_tasks",
-                assigned_to=unfinished[0].get("executor", "openclaw"),
-                reason="unfinished tasks remain",
-            )
-        return CompletionDecision(
-            status="completed",
-            action="send_completion_notification",
-            assigned_to="notification-agent",
-            reason="all tasks completed",
-        )
-
-    def completion_summary(self, goal: dict[str, Any]) -> dict[str, Any]:
-        tasks = goal.get("tasks", [])
-        completed = [task for task in tasks if task.get("status") in {"completed", "closed"}]
-        blocked = [task for task in tasks if task.get("status") in {"blocked", "waiting_approval"}]
-        return {
-            "goal_id": goal.get("goal_id"),
-            "title": goal.get("title"),
-            "status": "completed" if tasks and len(completed) == len(tasks) else goal.get("status", "open"),
-            "total_tasks": len(tasks),
-            "completed_tasks": len(completed),
-            "blocked_tasks": len(blocked),
-            "completion_rate": round(len(completed) / len(tasks) * 100, 2) if tasks else 0,
-            "updated_at": utc_now(),
-        }
-
-    def _owner_gate_reason(self, goal: dict[str, Any], blockers: list[dict[str, Any]]) -> str | None:
-        for reason in goal.get("owner_gate_reasons", []):
-            if reason in self.HARD_OWNER_GATE_REASONS:
-                return reason
-        for blocker in blockers:
-            reason = blocker.get("owner_gate_reason")
-            if reason in self.HARD_OWNER_GATE_REASONS:
-                return reason
-        return None
-
-    def _has_p0_blocker(self, blockers: list[dict[str, Any]]) -> bool:
-        return any(blocker.get("severity") in {"p0", "critical"} for blocker in blockers)
-
-
-__all__ = ["CompletionGoal", "CompletionDecision", "AutonomousGoalCompletionSupervisor"]

active-runtime/app/change_acceptance_governance.py

@@ -1,103 +0,0 @@
-"""Change acceptance governance for AIOS.
-
-Every feature change must provide matching tests. Every architecture change must
-be reviewed by an independent architecture agent. User-facing changes must be
-validated by an independent user acceptance agent.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass(frozen=True)
-class ChangeDescriptor:
-    change_id: str
-    change_type: str
-    title: str
-    files_changed: list[str]
-    tests: list[str] = field(default_factory=list)
-    user_facing: bool = False
-    architecture_impact: bool = False
-    risk: str = "low"
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class AcceptanceFinding:
-    check: str
-    status: str
-    detail: str
-    required: bool = True
-
-    def passed(self) -> bool:
-        return self.status == "pass" or not self.required
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class AcceptanceDecision:
-    status: str
-    findings: list[AcceptanceFinding]
-    decided_at: str = field(default_factory=utc_now)
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "status": self.status,
-            "findings": [f.to_dict() for f in self.findings],
-            "decided_at": self.decided_at,
-        }
-
-
-class ChangeAcceptanceGate:
-    def evaluate(self, change: ChangeDescriptor) -> AcceptanceDecision:
-        findings: list[AcceptanceFinding] = []
-        findings.append(self._tests_required(change))
-        findings.append(self._user_acceptance_required(change))
-        findings.append(self._architecture_review_required(change))
-        findings.append(self._risk_gate(change))
-        status = "pass" if all(f.passed() for f in findings) else "blocked"
-        return AcceptanceDecision(status, findings)
-
-    def _tests_required(self, change: ChangeDescriptor) -> AcceptanceFinding:
-        if change.tests:
-            return AcceptanceFinding("tests_present", "pass", "matching tests declared")
-        return AcceptanceFinding("tests_present", "fail", "every feature change requires tests")
-
-    def _user_acceptance_required(self, change: ChangeDescriptor) -> AcceptanceFinding:
-        if not change.user_facing:
-            return AcceptanceFinding("user_acceptance", "pass", "not user-facing")
-        has_user_test = any("user" in t.lower() or "acceptance" in t.lower() for t in change.tests)
-        return AcceptanceFinding(
-            "user_acceptance",
-            "pass" if has_user_test else "fail",
-            "user-facing change requires user acceptance test",
-        )
-
-    def _architecture_review_required(self, change: ChangeDescriptor) -> AcceptanceFinding:
-        if not change.architecture_impact:
-            return AcceptanceFinding("architecture_review", "pass", "no architecture impact")
-        has_arch_test = any("arch" in t.lower() or "architecture" in t.lower() for t in change.tests)
-        return AcceptanceFinding(
-            "architecture_review",
-            "pass" if has_arch_test else "fail",
-            "architecture change requires independent architect review artifact/test",
-        )
-
-    def _risk_gate(self, change: ChangeDescriptor) -> AcceptanceFinding:
-        if change.risk in {"low", "medium", "high"}:
-            return AcceptanceFinding("risk_classified", "pass", f"risk={change.risk}")
-        return AcceptanceFinding("risk_classified", "fail", "risk must be low/medium/high")
-
-
-__all__ = ["ChangeDescriptor", "AcceptanceFinding", "AcceptanceDecision", "ChangeAcceptanceGate"]

active-runtime/app/change_governance_api.py

@@ -1,34 +0,0 @@
-"""API for AIOS change governance dashboard."""
-
-from typing import Any
-
-try:
-    from fastapi import APIRouter
-except Exception:
-    APIRouter = None
-
-from .change_governance_dashboard import ChangeGovernanceDashboard
-
-
-dashboard = ChangeGovernanceDashboard()
-
-
-def get_change_governance_overview(changes: list[dict[str, Any]] | None = None):
-    return dashboard.overview(changes)
-
-
-def build_router():
-    if APIRouter is None:
-        return None
-    router = APIRouter(prefix="/admin/ai-evolution/governance", tags=["change-governance"])
-
-    @router.get("/overview", operation_id="getChangeGovernanceOverview")
-    def overview():
-        return get_change_governance_overview()
-
-    return router
-
-
-router = build_router()
-
-__all__ = ["router", "get_change_governance_overview"]

active-runtime/app/change_governance_dashboard.py

@@ -1,93 +0,0 @@
-"""Web UI dashboard model for AIOS change governance.
-
-Shows test gates, user acceptance, architecture review, risk gates and release
-blocking status for human operators and owner review.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass(frozen=True)
-class GovernanceMetric:
-    key: str
-    title: str
-    value: Any
-    status: str = "ok"
-    detail: str = ""
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class GovernancePanel:
-    key: str
-    title: str
-    metrics: list[GovernanceMetric] = field(default_factory=list)
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "key": self.key,
-            "title": self.title,
-            "metrics": [m.to_dict() for m in self.metrics],
-        }
-
-
-class ChangeGovernanceDashboard:
-    def overview(self, changes: list[dict[str, Any]] | None = None) -> dict[str, Any]:
-        changes = changes or []
-        blocked = [c for c in changes if c.get("status") == "blocked"]
-        waiting_arch = [c for c in changes if c.get("architecture_review") == "required"]
-        waiting_user = [c for c in changes if c.get("user_acceptance") == "required"]
-        missing_tests = [c for c in changes if not c.get("tests")]
-        panels = [
-            GovernancePanel(
-                "test_gate",
-                "测试 Gate",
-                [
-                    GovernanceMetric("total_changes", "变更总数", len(changes)),
-                    GovernanceMetric("missing_tests", "缺少测试的变更", len(missing_tests), "warn" if missing_tests else "ok"),
-                ],
-            ),
-            GovernancePanel(
-                "user_acceptance",
-                "用户验收 Agent",
-                [
-                    GovernanceMetric("waiting_user_acceptance", "等待用户验收", len(waiting_user), "warn" if waiting_user else "ok"),
-                ],
-            ),
-            GovernancePanel(
-                "architecture_review",
-                "架构师 Agent",
-                [
-                    GovernanceMetric("waiting_architecture_review", "等待架构审查", len(waiting_arch), "warn" if waiting_arch else "ok"),
-                ],
-            ),
-            GovernancePanel(
-                "release_gate",
-                "发布 Gate",
-                [
-                    GovernanceMetric("blocked_changes", "阻塞发布的变更", len(blocked), "warn" if blocked else "ok"),
-                ],
-            ),
-        ]
-        return {
-            "module": "change-governance",
-            "route": "/admin/ai-evolution/governance",
-            "title": "AIOS 变更治理中心",
-            "status": "attention_required" if blocked or missing_tests or waiting_arch or waiting_user else "healthy",
-            "generated_at": utc_now(),
-            "panels": [p.to_dict() for p in panels],
-            "changes": changes,
-        }
-
-
-__all__ = ["GovernanceMetric", "GovernancePanel", "ChangeGovernanceDashboard"]

active-runtime/app/git_repo_locator.py

@@ -1,36 +0,0 @@
-"""Git repository location resolver with validation.
-
-Prevents hard-coded repository names from silently pointing to stale paths.
-"""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-
-class GitRepoLocator:
-    def __init__(self, root: str | None = None):
-        self.root = Path(root or os.getenv("AIOS_GITOPS_ROOT", "/data/aios-gitops/runtime/gitea-bin/data/repositories"))
-
-    def candidates(self, owner: str = "aios", names: tuple[str, ...] = ("aios.git", "aios-v23.git")):
-        return [self.root / owner / name for name in names]
-
-    def locate(self, owner: str = "aios") -> dict:
-        found = [str(path) for path in self.candidates(owner) if path.exists()]
-        return {
-            "root": str(self.root),
-            "owner": owner,
-            "found": found,
-            "healthy": len(found) == 1,
-            "warning": "multiple repositories found" if len(found) > 1 else None,
-        }
-
-    def require(self, owner: str = "aios") -> Path:
-        result = self.locate(owner)
-        if not result["healthy"]:
-            raise RuntimeError(f"Git repo resolution failed: {result}")
-        return Path(result["found"][0])
-
-
-__all__ = ["GitRepoLocator"]

active-runtime/app/governance_event_bridge.py

@@ -1,148 +0,0 @@
-"""Bridge governance agents into the unified Agent Event Bus.
-
-This module emits normalized governance events for requirement changes,
-architecture reviews, user acceptance, test gates and version decisions. It uses
-duck typing so it can work with the unified AgentEventBus when available, while
-remaining testable without a running bus.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any, Protocol
-from uuid import uuid4
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-class EventPublisher(Protocol):
-    def publish(
-        self,
-        kind: str,
-        source: str,
-        target: str,
-        summary: str,
-        payload: dict[str, Any],
-        correlation_id: str | None = None,
-    ) -> dict[str, Any]:
-        ...
-
-
-@dataclass(frozen=True)
-class GovernanceEventEnvelope:
-    id: str
-    kind: str
-    source: str
-    target: str
-    summary: str
-    payload: dict[str, Any]
-    correlation_id: str | None = None
-    created_at: str = field(default_factory=utc_now)
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-class InMemoryGovernanceEventBus:
-    """Small fallback bus for tests and offline governance runs."""
-
-    def __init__(self) -> None:
-        self.events: list[dict[str, Any]] = []
-
-    def publish(
-        self,
-        kind: str,
-        source: str,
-        target: str,
-        summary: str,
-        payload: dict[str, Any],
-        correlation_id: str | None = None,
-    ) -> dict[str, Any]:
-        event = GovernanceEventEnvelope(
-            id=f"evt_{uuid4().hex[:12]}",
-            kind=kind,
-            source=source,
-            target=target,
-            summary=summary,
-            payload=payload,
-            correlation_id=correlation_id,
-        ).to_dict()
-        self.events.append(event)
-        return event
-
-
-class GovernanceEventBridge:
-    """Publishes governance lifecycle events to the Agent Event Bus."""
-
-    def __init__(self, bus: EventPublisher | None = None):
-        self.bus = bus or InMemoryGovernanceEventBus()
-
-    def requirement_changed(self, requirement: dict[str, Any]) -> dict[str, Any]:
-        return self.bus.publish(
-            kind="requirement_changed",
-            source=requirement.get("source", "unknown"),
-            target="architect-agent",
-            summary=requirement.get("requirement", "requirement changed"),
-            payload=requirement,
-            correlation_id=requirement.get("id"),
-        )
-
-    def architecture_review_started(self, proposal: dict[str, Any]) -> dict[str, Any]:
-        return self.bus.publish(
-            kind="architecture_review_started",
-            source="architect-agent",
-            target="architecture-review-agent",
-            summary=proposal.get("title", "architecture review started"),
-            payload=proposal,
-            correlation_id=proposal.get("change_id"),
-        )
-
-    def architecture_review_completed(self, decision: dict[str, Any]) -> dict[str, Any]:
-        return self.bus.publish(
-            kind="architecture_review_completed",
-            source="architecture-review-agent",
-            target="change-governance",
-            summary=f"architecture review {decision.get('status', 'completed')}",
-            payload=decision,
-            correlation_id=decision.get("change_id"),
-        )
-
-    def user_acceptance_completed(self, report: dict[str, Any]) -> dict[str, Any]:
-        return self.bus.publish(
-            kind="user_acceptance_completed",
-            source="user-acceptance-agent",
-            target="change-governance",
-            summary=f"user acceptance {report.get('decision', 'completed')}",
-            payload=report,
-            correlation_id=report.get("change_id"),
-        )
-
-    def test_gate_completed(self, result: dict[str, Any]) -> dict[str, Any]:
-        return self.bus.publish(
-            kind="test_gate_completed",
-            source="test-gate",
-            target="change-governance",
-            summary=f"test gate {result.get('status', 'completed')}",
-            payload=result,
-            correlation_id=result.get("change_id"),
-        )
-
-    def version_decision_created(self, decision: dict[str, Any]) -> dict[str, Any]:
-        return self.bus.publish(
-            kind="version_decision_created",
-            source="architect-agent",
-            target="owner-gate",
-            summary=f"version bump recommendation: {decision.get('version_bump', 'unknown')}",
-            payload=decision,
-            correlation_id=decision.get("change_id"),
-        )
-
-
-__all__ = [
-    "GovernanceEventEnvelope",
-    "InMemoryGovernanceEventBus",
-    "GovernanceEventBridge",
-]

active-runtime/app/governance_timeline_api.py

@@ -1,32 +0,0 @@
-"""API for governance timeline visualization."""
-
-try:
-    from fastapi import APIRouter
-except Exception:
-    APIRouter = None
-
-from .governance_timeline_dashboard import GovernanceTimelineDashboard
-
-
-dashboard = GovernanceTimelineDashboard()
-
-
-def get_governance_timeline(events=None):
-    return dashboard.build(events)
-
-
-def build_router():
-    if APIRouter is None:
-        return None
-    router = APIRouter(prefix="/admin/ai-evolution/governance", tags=["governance-timeline"])
-
-    @router.get("/timeline", operation_id="getGovernanceTimeline")
-    def timeline():
-        return get_governance_timeline()
-
-    return router
-
-
-router = build_router()
-
-__all__ = ["router", "get_governance_timeline"]

active-runtime/app/governance_timeline_dashboard.py

@@ -1,106 +0,0 @@
-"""Governance timeline dashboard.
-
-Turns governance events into a human-readable flow for Web UI so operators can
-see why a change is blocked or ready for promotion.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-EVENT_ORDER = {
-    "requirement_changed": 10,
-    "architecture_review_started": 20,
-    "architecture_review_completed": 30,
-    "test_gate_completed": 40,
-    "user_acceptance_completed": 50,
-    "version_decision_created": 60,
-    "owner_gate_completed": 70,
-    "promotion_completed": 80,
-}
-
-
-@dataclass(frozen=True)
-class GovernanceTimelineStep:
-    id: str
-    kind: str
-    title: str
-    actor: str
-    status: str
-    timestamp: str
-    correlation_id: str | None = None
-    detail: dict[str, Any] = field(default_factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-class GovernanceTimelineDashboard:
-    def build(self, events: list[dict[str, Any]] | None = None) -> dict[str, Any]:
-        events = events or []
-        steps = [self._event_to_step(event) for event in events]
-        steps.sort(key=lambda step: (EVENT_ORDER.get(step.kind, 999), step.timestamp))
-        blockers = [step for step in steps if step.status in {"blocked", "fail", "attention_required"}]
-        return {
-            "module": "governance-timeline",
-            "route": "/admin/ai-evolution/governance/timeline",
-            "title": "治理事件时间线",
-            "status": "attention_required" if blockers else "healthy",
-            "generated_at": utc_now(),
-            "steps": [step.to_dict() for step in steps],
-            "blockers": [step.to_dict() for step in blockers],
-            "flow": self._flow_summary(steps),
-        }
-
-    def _event_to_step(self, event: dict[str, Any]) -> GovernanceTimelineStep:
-        payload = event.get("payload", {})
-        kind = event.get("kind", "unknown")
-        return GovernanceTimelineStep(
-            id=event.get("id", f"event-{len(str(event))}"),
-            kind=kind,
-            title=self._title(kind, payload),
-            actor=event.get("source", payload.get("actor", "unknown")),
-            status=payload.get("status") or payload.get("decision") or event.get("status", "ok"),
-            timestamp=event.get("created_at") or payload.get("created_at") or utc_now(),
-            correlation_id=event.get("correlation_id") or payload.get("change_id") or payload.get("id"),
-            detail=payload,
-        )
-
-    def _title(self, kind: str, payload: dict[str, Any]) -> str:
-        titles = {
-            "requirement_changed": "需求变化",
-            "architecture_review_started": "架构审查开始",
-            "architecture_review_completed": "架构审查完成",
-            "test_gate_completed": "测试 Gate 完成",
-            "user_acceptance_completed": "用户验收完成",
-            "version_decision_created": "版本建议产生",
-            "owner_gate_completed": "Owner Gate 完成",
-            "promotion_completed": "Promotion 完成",
-        }
-        return payload.get("title") or payload.get("summary") or titles.get(kind, kind)
-
-    def _flow_summary(self, steps: list[GovernanceTimelineStep]) -> dict[str, Any]:
-        present = {step.kind for step in steps}
-        required = [
-            "requirement_changed",
-            "architecture_review_completed",
-            "test_gate_completed",
-            "user_acceptance_completed",
-            "version_decision_created",
-        ]
-        missing = [kind for kind in required if kind not in present]
-        return {
-            "required_steps": required,
-            "missing_steps": missing,
-            "ready_for_owner_gate": not missing,
-        }
-
-
-__all__ = ["GovernanceTimelineStep", "GovernanceTimelineDashboard"]

active-runtime/app/independent_acceptance_agents.py

@@ -1,59 +0,0 @@
-"""Independent acceptance agents.
-
-Simulates independent roles: user representative and architecture reviewer.
-They provide acceptance evidence, not implementation decisions.
-"""
-
-from dataclasses import dataclass, asdict
-from datetime import datetime, timezone
-from typing import Any
-
-
-def utc_now():
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass(frozen=True)
-class AcceptanceReport:
-    agent: str
-    role: str
-    decision: str
-    evidence: list[str]
-    created_at: str = utc_now()
-
-    def to_dict(self):
-        return asdict(self)
-
-
-class UserAcceptanceAgent:
-    def review(self, change: dict[str, Any]) -> AcceptanceReport:
-        checks = [
-            "user_requirement_match",
-            "user_workflow_validation",
-            "permission_visibility_check",
-        ]
-        return AcceptanceReport(
-            "user-acceptance-agent",
-            "user_representative",
-            "pass" if change.get("user_facing") else "not_required",
-            checks,
-        )
-
-
-class ArchitectureAcceptanceAgent:
-    def review(self, change: dict[str, Any]) -> AcceptanceReport:
-        checks = [
-            "architecture_consistency",
-            "scalability_review",
-            "security_boundary_review",
-            "operability_review",
-        ]
-        return AcceptanceReport(
-            "architecture-review-agent",
-            "system_architect",
-            "pass" if change.get("architecture_impact") else "not_required",
-            checks,
-        )
-
-
-__all__ = ["AcceptanceReport", "UserAcceptanceAgent", "ArchitectureAcceptanceAgent"]

active-runtime/app/portal_aios_dashboard_api.py

@@ -1,39 +0,0 @@
-"""Portal AIOS dashboard aggregation API."""
-
-try:
-    from fastapi import APIRouter
-except Exception:
-    APIRouter = None
-
-from .portal_aios_module_registry import PortalAIOSModuleRegistry
-from .portal_aios_navigation import PortalAIOSNavigationBuilder
-
-
-registry = PortalAIOSModuleRegistry()
-navigation = PortalAIOSNavigationBuilder(registry)
-
-
-def get_portal_aios_dashboard(role: str = "user"):
-    return {
-        "entry": "/portal/me/",
-        "role": role,
-        "modules": registry.route_manifest(role),
-        "navigation": navigation.build(role),
-    }
-
-
-def build_router():
-    if APIRouter is None:
-        return None
-    router = APIRouter(prefix="/portal/me/aios", tags=["portal-aios-dashboard"])
-
-    @router.get("/dashboard", operation_id="getPortalAIOSDashboard")
-    def dashboard(role: str = "user"):
-        return get_portal_aios_dashboard(role)
-
-    return router
-
-
-router = build_router()
-
-__all__ = ["router", "get_portal_aios_dashboard"]

active-runtime/app/portal_aios_module_api.py

@@ -1,32 +0,0 @@
-"""Portal AIOS module manifest API."""
-
-try:
-    from fastapi import APIRouter
-except Exception:
-    APIRouter = None
-
-from .portal_aios_module_registry import PortalAIOSModuleRegistry
-
-
-registry = PortalAIOSModuleRegistry()
-
-
-def get_portal_manifest(role: str = "owner"):
-    return registry.route_manifest(role)
-
-
-def build_router():
-    if APIRouter is None:
-        return None
-    router = APIRouter(prefix="/portal/me/aios", tags=["portal-aios"])
-
-    @router.get("/manifest", operation_id="getPortalAIOSManifest")
-    def manifest(role: str = "owner"):
-        return get_portal_manifest(role)
-
-    return router
-
-
-router = build_router()
-
-__all__ = ["router", "get_portal_manifest"]

active-runtime/app/portal_aios_module_registry.py

@@ -1,147 +0,0 @@
-"""AIOS Portal module registry.
-
-Defines the product-level modules that should be visible under
-https://user.cnnetmkt.top/portal/me/ after authentication. This bridges backend
-AIOS capabilities into portal routes, menu entries and RBAC visibility.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from typing import Any
-
-
-ROLE_ORDER = {
-    "user": 1,
-    "group_admin": 5,
-    "owner": 9,
-}
-
-
-@dataclass(frozen=True)
-class PortalAIOSModule:
-    key: str
-    title: str
-    route: str
-    api_routes: list[str]
-    min_role: str = "user"
-    description: str = ""
-    children: list["PortalAIOSModule"] = field(default_factory=list)
-
-    def visible_to(self, role: str) -> bool:
-        return ROLE_ORDER.get(role, 0) >= ROLE_ORDER.get(self.min_role, 0)
-
-    def to_dict(self, role: str = "owner") -> dict[str, Any] | None:
-        if not self.visible_to(role):
-            return None
-        return {
-            "key": self.key,
-            "title": self.title,
-            "route": self.route,
-            "api_routes": self.api_routes,
-            "min_role": self.min_role,
-            "description": self.description,
-            "children": [child for child in [c.to_dict(role) for c in self.children] if child],
-        }
-
-
-class PortalAIOSModuleRegistry:
-    def modules(self) -> list[PortalAIOSModule]:
-        return [
-            PortalAIOSModule(
-                key="tasks",
-                title="任务中心",
-                route="/admin/ai-evolution/tasks",
-                api_routes=["/admin/ai-evolution/tasks/overview"],
-                min_role="user",
-                description="查看任务来源、执行者、进度、阻塞、审批和通知状态。",
-            ),
-            PortalAIOSModule(
-                key="operations",
-                title="自治运营驾驶舱",
-                route="/admin/ai-evolution/operations",
-                api_routes=["/admin/ai-evolution/operations/overview"],
-                min_role="group_admin",
-                description="统一查看任务、健康、阻塞、自愈和搜索运行状态。",
-            ),
-            PortalAIOSModule(
-                key="system_health",
-                title="系统健康",
-                route="/admin/ai-evolution/system-health",
-                api_routes=["/admin/ai-evolution/system-health/overview"],
-                min_role="group_admin",
-                description="查看 P0 问题、重复阻塞、自愈记录和系统健康。",
-            ),
-            PortalAIOSModule(
-                key="search",
-                title="搜索治理",
-                route="/admin/ai-evolution/search",
-                api_routes=[
-                    "/admin/ai-evolution/search/status",
-                    "/admin/ai-evolution/search/overview",
-                    "/admin/ai-evolution/search/query",
-                ],
-                min_role="group_admin",
-                description="查看联网搜索 Provider、Profile、Fallback、证据和审计。",
-            ),
-            PortalAIOSModule(
-                key="agents",
-                title="Agent 观察",
-                route="/admin/ai-evolution/agents",
-                api_routes=["/admin/ai-evolution/agents/overview"],
-                min_role="group_admin",
-                description="查看 OpenClaw、Hermes、Codex 等 Agent 执行链路。",
-            ),
-            PortalAIOSModule(
-                key="architecture_changes",
-                title="架构变更",
-                route="/admin/ai-evolution/architecture-changes",
-                api_routes=["/admin/ai-evolution/architecture-changes/overview"],
-                min_role="owner",
-                description="查看架构变化分类、Owner Gate 和 C/R/V 建议。",
-            ),
-            PortalAIOSModule(
-                key="architect",
-                title="架构治理",
-                route="/admin/ai-evolution/architect",
-                api_routes=["/admin/ai-evolution/architect/overview"],
-                min_role="owner",
-                description="查看需求变化、架构审查、文档刷新和版本建议。",
-                children=[
-                    PortalAIOSModule(
-                        key="architect_research",
-                        title="技术情报",
-                        route="/admin/ai-evolution/architect/research",
-                        api_routes=["/admin/ai-evolution/architect/research/timeline"],
-                        min_role="owner",
-                    )
-                ],
-            ),
-            PortalAIOSModule(
-                key="governance",
-                title="变更治理",
-                route="/admin/ai-evolution/governance",
-                api_routes=[
-                    "/admin/ai-evolution/governance/overview",
-                    "/admin/ai-evolution/governance/timeline",
-                ],
-                min_role="owner",
-                description="查看测试 Gate、用户验收、架构审查和发布决策链。",
-            ),
-        ]
-
-    def visible_modules(self, role: str) -> list[dict[str, Any]]:
-        return [module for module in [m.to_dict(role) for m in self.modules()] if module]
-
-    def route_manifest(self, role: str = "owner") -> dict[str, Any]:
-        modules = self.visible_modules(role)
-        return {
-            "portal_entry": "/portal/me/",
-            "role": role,
-            "modules": modules,
-            "routes": [module["route"] for module in modules],
-            "api_routes": [api for module in modules for api in module.get("api_routes", [])],
-        }
-
-
-__all__ = ["PortalAIOSModule", "PortalAIOSModuleRegistry"]

active-runtime/app/portal_aios_navigation.py

@@ -1,99 +0,0 @@
-"""Portal navigation builder for AIOS modules.
-
-Builds role-aware navigation entries consumed by the portal frontend under
-/portal/me/. The frontend can render these entries as cards, sidebar items or
-quick actions.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass
-from typing import Any
-
-from .portal_aios_module_registry import PortalAIOSModuleRegistry
-
-
-@dataclass(frozen=True)
-class PortalNavigationItem:
-    key: str
-    label: str
-    href: str
-    icon: str
-    description: str
-    badge: str | None = None
-    order: int = 100
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-class PortalAIOSNavigationBuilder:
-    ICONS = {
-        "tasks": "list-checks",
-        "operations": "activity",
-        "system_health": "heart-pulse",
-        "search": "search",
-        "agents": "bot",
-        "architecture_changes": "git-branch",
-        "architect": "network",
-        "governance": "shield-check",
-    }
-
-    ORDER = {
-        "tasks": 10,
-        "operations": 20,
-        "system_health": 30,
-        "search": 40,
-        "agents": 50,
-        "architecture_changes": 60,
-        "architect": 70,
-        "governance": 80,
-    }
-
-    def __init__(self, registry: PortalAIOSModuleRegistry | None = None):
-        self.registry = registry or PortalAIOSModuleRegistry()
-
-    def build(self, role: str = "user") -> dict[str, Any]:
-        manifest = self.registry.route_manifest(role)
-        items = [self._item(module) for module in manifest["modules"]]
-        items.sort(key=lambda item: item.order)
-        return {
-            "portal_entry": "/portal/me/",
-            "role": role,
-            "section": "AIOS",
-            "items": [item.to_dict() for item in items],
-            "quick_actions": self.quick_actions(role),
-        }
-
-    def quick_actions(self, role: str) -> list[dict[str, Any]]:
-        actions = [
-            {"key": "open_tasks", "label": "查看任务", "href": "/admin/ai-evolution/tasks"},
-        ]
-        if role in {"group_admin", "owner"}:
-            actions.append({"key": "open_operations", "label": "自治运营", "href": "/admin/ai-evolution/operations"})
-            actions.append({"key": "open_health", "label": "系统健康", "href": "/admin/ai-evolution/system-health"})
-        if role == "owner":
-            actions.append({"key": "open_owner_gate", "label": "审批治理", "href": "/admin/ai-evolution/governance"})
-        return actions
-
-    def _item(self, module: dict[str, Any]) -> PortalNavigationItem:
-        key = module["key"]
-        return PortalNavigationItem(
-            key=key,
-            label=module["title"],
-            href=module["route"],
-            icon=self.ICONS.get(key, "box"),
-            description=module.get("description", ""),
-            badge=self._badge(key),
-            order=self.ORDER.get(key, 100),
-        )
-
-    def _badge(self, key: str) -> str | None:
-        if key in {"tasks", "system_health"}:
-            return "live"
-        if key in {"architecture_changes", "governance"}:
-            return "owner"
-        return None
-
-
-__all__ = ["PortalNavigationItem", "PortalAIOSNavigationBuilder"]

active-runtime/app/portal_integration_api.py

@@ -1,32 +0,0 @@
-"""Portal integration health API."""
-
-try:
-    from fastapi import APIRouter
-except Exception:
-    APIRouter = None
-
-from .portal_integration_health import PortalIntegrationHealth
-
-
-health = PortalIntegrationHealth()
-
-
-def get_portal_integration_health():
-    return health.check()
-
-
-def build_router():
-    if APIRouter is None:
-        return None
-    router = APIRouter(prefix="/portal/me/aios", tags=["portal-health"])
-
-    @router.get("/health", operation_id="getPortalIntegrationHealth")
-    def health_check():
-        return get_portal_integration_health()
-
-    return router
-
-
-router = build_router()
-
-__all__ = ["router", "get_portal_integration_health"]

active-runtime/app/portal_integration_health.py

@@ -1,40 +0,0 @@
-"""Portal integration health checks."""
-
-from __future__ import annotations
-
-from datetime import datetime, timezone
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-class PortalIntegrationHealth:
-    def check(self, manifest: dict[str, Any] | None = None, frontend: dict[str, Any] | None = None) -> dict[str, Any]:
-        manifest = manifest or {}
-        frontend = frontend or {}
-        routes = manifest.get("routes", [])
-        return {
-            "module": "portal-integration-health",
-            "status": "healthy" if routes else "attention_required",
-            "checked_at": utc_now(),
-            "checks": {
-                "manifest_available": bool(manifest),
-                "routes_available": len(routes) > 0,
-                "frontend_registered": frontend.get("registered", False),
-                "rbac_enabled": True,
-            },
-            "missing": self._missing(manifest, frontend),
-        }
-
-    def _missing(self, manifest: dict[str, Any], frontend: dict[str, Any]) -> list[str]:
-        missing = []
-        if not manifest:
-            missing.append("portal_manifest")
-        if not frontend.get("registered", False):
-            missing.append("frontend_navigation_registration")
-        return missing
-
-
-__all__ = ["PortalIntegrationHealth"]

active-runtime/app/portal_system_health_adapter.py

@@ -1,34 +0,0 @@
-"""Portal integration adapter for System Health Center.
-
-Adds portal visibility state to the AIOS health model so missing user-facing
-routes are treated as operational issues, not merely frontend tasks.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from .portal_aios_module_registry import PortalAIOSModuleRegistry
-from .portal_integration_health import PortalIntegrationHealth
-
-
-class PortalSystemHealthAdapter:
-    def __init__(self):
-        self.registry = PortalAIOSModuleRegistry()
-        self.health = PortalIntegrationHealth()
-
-    def build(self, role: str = "owner", frontend: dict[str, Any] | None = None) -> dict[str, Any]:
-        manifest = self.registry.route_manifest(role)
-        health = self.health.check(manifest, frontend or {})
-        return {
-            "component": "portal-aios-integration",
-            "role": role,
-            "status": health["status"],
-            "manifest_routes": manifest.get("routes", []),
-            "api_routes": manifest.get("api_routes", []),
-            "missing": health.get("missing", []),
-            "checks": health.get("checks", {}),
-        }
-
-
-__all__ = ["PortalSystemHealthAdapter"]

active-runtime/app/search_agent_adapter.py

@@ -1,92 +0,0 @@
-"""Agent adapters for AIOS Search Gateway.
-
-All runtime agents should call SearchGatewayAgentAdapter instead of performing
-ad-hoc network search. This gives consistent provider fallback, profile
-resolution, evidence capture, audit and event visibility.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from typing import Any
-
-from .search_gateway_orchestrator import SearchGatewayOrchestrator
-
-
-@dataclass(frozen=True)
-class AgentSearchContext:
-    agent: str
-    user_id: str | None = None
-    group_id: str | None = None
-    role: str = "user"
-    group_profile: dict[str, Any] | None = None
-    user_profile: dict[str, Any] | None = None
-    session_profile: dict[str, Any] | None = None
-    authorized_sources: list[str] = field(default_factory=list)
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-class SearchGatewayAgentAdapter:
-    def __init__(self, orchestrator: SearchGatewayOrchestrator | None = None):
-        self.orchestrator = orchestrator or SearchGatewayOrchestrator()
-
-    def search(
-        self,
-        query: str,
-        context: AgentSearchContext,
-        intent: str = "general",
-        region: str | None = None,
-        time_range: str | None = None,
-        data_type: str | None = None,
-        domain_profiles: list[str] | None = None,
-        user_scope: str = "public",
-        correlation_id: str | None = None,
-    ) -> dict[str, Any]:
-        payload = {
-            "query": query,
-            "requester": context.agent,
-            "intent": intent,
-            "region": region,
-            "time_range": time_range,
-            "data_type": data_type,
-            "domain_profiles": domain_profiles or [],
-            "user_scope": user_scope,
-            "authorized_sources": context.authorized_sources,
-            "group_profile": context.group_profile,
-            "user_profile": context.user_profile,
-            "session_profile": context.session_profile,
-            "correlation_id": correlation_id,
-        }
-        return self.orchestrator.execute(payload)
-
-
-class OpenClawSearchClient(SearchGatewayAgentAdapter):
-    def search_public(self, query: str, context: AgentSearchContext, **kwargs) -> dict[str, Any]:
-        return self.search(query, context, user_scope="public", **kwargs)
-
-
-class HermesSearchClient(SearchGatewayAgentAdapter):
-    def delegate_search(self, query: str, context: AgentSearchContext, **kwargs) -> dict[str, Any]:
-        return self.search(query, context, **kwargs)
-
-
-class CodexSearchClient(SearchGatewayAgentAdapter):
-    def technical_search(self, query: str, context: AgentSearchContext, **kwargs) -> dict[str, Any]:
-        return self.search(query, context, intent=kwargs.pop("intent", "software_library"), **kwargs)
-
-
-class CustomGPTSearchClient(SearchGatewayAgentAdapter):
-    def user_search(self, query: str, context: AgentSearchContext, **kwargs) -> dict[str, Any]:
-        return self.search(query, context, **kwargs)
-
-
-__all__ = [
-    "AgentSearchContext",
-    "SearchGatewayAgentAdapter",
-    "OpenClawSearchClient",
-    "HermesSearchClient",
-    "CodexSearchClient",
-    "CustomGPTSearchClient",
-]

active-runtime/app/search_architect_integration.py

@@ -1,73 +0,0 @@
-"""Architect governance integration for Search Gateway.
-
-Search Gateway is a shared platform capability. The Architect Agent periodically
-reviews provider health, external search/browser capabilities, cost, security and
-privacy impact, then emits C/R/V recommendations.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass(frozen=True)
-class SearchArchitectureFinding:
-    finding_id: str
-    title: str
-    impact: str
-    recommendation: str
-    evidence: list[str] = field(default_factory=list)
-    created_at: str = field(default_factory=utc_now)
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class SearchArchitectureDecision:
-    status: str
-    version_bump: str
-    reason: str
-    findings: list[SearchArchitectureFinding]
-    owner_gate_required: bool
-    created_at: str = field(default_factory=utc_now)
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "status": self.status,
-            "version_bump": self.version_bump,
-            "reason": self.reason,
-            "findings": [f.to_dict() for f in self.findings],
-            "owner_gate_required": self.owner_gate_required,
-            "created_at": self.created_at,
-        }
-
-
-class SearchArchitectIntegration:
-    def review(self, signals: dict[str, Any]) -> SearchArchitectureDecision:
-        findings: list[SearchArchitectureFinding] = []
-        if signals.get("provider_breaking_change"):
-            findings.append(SearchArchitectureFinding("search-provider-breaking", "Provider breaking change", "breaking", "owner_review"))
-        if signals.get("new_search_capability"):
-            findings.append(SearchArchitectureFinding("search-new-capability", "New search capability available", "architecture", "evaluate_adoption"))
-        if signals.get("cost_increase"):
-            findings.append(SearchArchitectureFinding("search-cost", "Search provider cost increase", "minor", "optimize_provider_order"))
-        if signals.get("security_advisory"):
-            findings.append(SearchArchitectureFinding("search-security", "Search security advisory", "breaking", "owner_review"))
-
-        if any(f.impact == "breaking" for f in findings):
-            return SearchArchitectureDecision("action_required", "V", "breaking search ecosystem/security change", findings, True)
-        if any(f.impact == "architecture" for f in findings):
-            return SearchArchitectureDecision("optimization_recommended", "R", "new search capability may improve architecture", findings, True)
-        if findings:
-            return SearchArchitectureDecision("minor_change_recommended", "C", "compatible provider optimization", findings, False)
-        return SearchArchitectureDecision("no_action", "none", "no relevant search architecture change", findings, False)
-
-
-__all__ = ["SearchArchitectureFinding", "SearchArchitectureDecision", "SearchArchitectIntegration"]

active-runtime/app/search_audit_store.py

@@ -1,27 +0,0 @@
-"""Audit storage for Search Gateway executions."""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any
-
-
-class SearchAuditStore:
-    def __init__(self, root: str = "runtime/search-gateway/audit"):
-        self.root = Path(root)
-        self.root.mkdir(parents=True, exist_ok=True)
-
-    def append(self, record: dict[str, Any]) -> str:
-        path = self.root / f"{record.get('request_id', 'search')}.json"
-        path.write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding="utf-8")
-        return str(path)
-
-    def list_recent(self) -> list[dict[str, Any]]:
-        result = []
-        for path in sorted(self.root.glob("*.json")):
-            result.append(json.loads(path.read_text(encoding="utf-8")))
-        return result[-50:]
-
-
-__all__ = ["SearchAuditStore"]

active-runtime/app/search_event_bridge.py

@@ -1,118 +0,0 @@
-"""Search Gateway event bridge.
-
-Publishes normalized search lifecycle events into the AIOS Agent Event Bus when a
-bus is available, with an in-memory fallback for tests and offline runs.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any, Protocol
-from uuid import uuid4
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-class SearchEventPublisher(Protocol):
-    def publish(
-        self,
-        kind: str,
-        source: str,
-        target: str,
-        summary: str,
-        payload: dict[str, Any],
-        correlation_id: str | None = None,
-    ) -> dict[str, Any]:
-        ...
-
-
-@dataclass(frozen=True)
-class SearchEvent:
-    id: str
-    kind: str
-    source: str
-    target: str
-    summary: str
-    payload: dict[str, Any]
-    correlation_id: str | None = None
-    created_at: str = field(default_factory=utc_now)
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-class InMemorySearchEventBus:
-    def __init__(self):
-        self.events: list[dict[str, Any]] = []
-
-    def publish(
-        self,
-        kind: str,
-        source: str,
-        target: str,
-        summary: str,
-        payload: dict[str, Any],
-        correlation_id: str | None = None,
-    ) -> dict[str, Any]:
-        event = SearchEvent(
-            id=f"search_evt_{uuid4().hex[:12]}",
-            kind=kind,
-            source=source,
-            target=target,
-            summary=summary,
-            payload=payload,
-            correlation_id=correlation_id,
-        ).to_dict()
-        self.events.append(event)
-        return event
-
-
-class SearchEventBridge:
-    def __init__(self, bus: SearchEventPublisher | None = None):
-        self.bus = bus or InMemorySearchEventBus()
-
-    def search_started(self, request: dict[str, Any]) -> dict[str, Any]:
-        return self.bus.publish(
-            kind="search_started",
-            source=request.get("requester", "unknown"),
-            target="search-gateway",
-            summary=request.get("query", "search started"),
-            payload=request,
-            correlation_id=request.get("correlation_id"),
-        )
-
-    def provider_attempted(self, request_id: str, attempt: dict[str, Any]) -> dict[str, Any]:
-        return self.bus.publish(
-            kind="search_provider_attempted",
-            source="search-gateway",
-            target=attempt.get("provider", "unknown"),
-            summary=f"provider {attempt.get('provider', 'unknown')} {attempt.get('status', 'attempted')}",
-            payload=attempt,
-            correlation_id=request_id,
-        )
-
-    def fallback_triggered(self, request_id: str, reason: str) -> dict[str, Any]:
-        return self.bus.publish(
-            kind="search_fallback_triggered",
-            source="search-gateway",
-            target="search-provider-router",
-            summary=reason,
-            payload={"reason": reason},
-            correlation_id=request_id,
-        )
-
-    def search_completed(self, response: dict[str, Any]) -> dict[str, Any]:
-        return self.bus.publish(
-            kind="search_completed",
-            source="search-gateway",
-            target=response.get("requester", "requester"),
-            summary=f"search {response.get('status', 'completed')}",
-            payload=response,
-            correlation_id=response.get("request_id"),
-        )
-
-
-__all__ = ["SearchEvent", "InMemorySearchEventBus", "SearchEventBridge"]

active-runtime/app/search_gateway.py

@@ -1,252 +0,0 @@
-"""Governed general-purpose Search Gateway for AIOS.
-
-The gateway coordinates query planning, provider routing, fallback, evidence
-normalization and compliance checks. It is provider-agnostic: runtime workers plug
-in public or explicitly authorized search providers.
-
-Search is a shared capability. Groups and users may customize provider order,
-trusted domains, query expansion hints and domain profiles, but customization may
-not override hard authorization, privacy, safety or audit rules.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any, Protocol
-from uuid import uuid4
-
-from .search_profile_resolver import DomainQueryProfileRegistry, SearchProfile, SearchProfileResolver
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass(frozen=True)
-class SearchRequest:
-    query: str
-    requester: str
-    intent: str = "general"
-    region: str | None = None
-    time_range: str | None = None
-    data_type: str | None = None
-    user_scope: str = "public"
-    authorized_sources: list[str] = field(default_factory=list)
-    domain_profiles: list[str] = field(default_factory=list)
-    group_profile: dict[str, Any] | None = None
-    user_profile: dict[str, Any] | None = None
-    session_profile: dict[str, Any] | None = None
-    correlation_id: str | None = None
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class SearchEvidence:
-    title: str
-    url: str | None
-    source: str
-    snippet: str
-    evidence_type: str = "web"
-    confidence: str = "medium"
-    retrieved_at: str = field(default_factory=utc_now)
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class SearchProviderAttempt:
-    provider: str
-    status: str
-    result_count: int = 0
-    reason: str = ""
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class SearchResponse:
-    request_id: str
-    status: str
-    answer: str
-    evidence: list[SearchEvidence]
-    attempts: list[SearchProviderAttempt]
-    confidence: str
-    expanded_queries: list[str] = field(default_factory=list)
-    resolved_profile: dict[str, Any] | None = None
-    need_clarification: list[str] = field(default_factory=list)
-    blocked_reasons: list[str] = field(default_factory=list)
-    created_at: str = field(default_factory=utc_now)
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "request_id": self.request_id,
-            "status": self.status,
-            "answer": self.answer,
-            "evidence": [e.to_dict() for e in self.evidence],
-            "attempts": [a.to_dict() for a in self.attempts],
-            "confidence": self.confidence,
-            "expanded_queries": self.expanded_queries,
-            "resolved_profile": self.resolved_profile,
-            "need_clarification": self.need_clarification,
-            "blocked_reasons": self.blocked_reasons,
-            "created_at": self.created_at,
-        }
-
-
-class SearchProvider(Protocol):
-    name: str
-
-    def search(self, request: SearchRequest, queries: list[str]) -> tuple[list[SearchEvidence], SearchProviderAttempt]:
-        ...
-
-
-class QueryPlanner:
-    def __init__(self, domain_registry: DomainQueryProfileRegistry | None = None):
-        self.domain_registry = domain_registry or DomainQueryProfileRegistry()
-
-    def expand(self, request: SearchRequest, profile: SearchProfile) -> list[str]:
-        base = request.query.strip()
-        queries = [base]
-        if request.region:
-            queries.append(f"{request.region} {base}")
-        if request.time_range:
-            queries.append(f"{base} {request.time_range}")
-        domain_profiles = list(dict.fromkeys([request.intent] + request.domain_profiles + profile.domain_profiles))
-        hints = list(profile.query_expansion_hints) + self.domain_registry.hints_for(domain_profiles)
-        for hint in hints:
-            queries.append(f"{base} {hint}")
-        for domain in profile.trusted_domains:
-            queries.append(f"site:{domain} {base}")
-        return list(dict.fromkeys([q for q in queries if q]))
-
-
-class SearchPolicyGuard:
-    """Blocks non-public or unauthorized collection patterns."""
-
-    FORBIDDEN_TERMS = (
-        "绕过登录",
-        "绕过验证码",
-        "验证码绕过",
-        "破解登录",
-        "个人成绩",
-        "学生隐私",
-        "受保护平台批量爬取",
-    )
-
-    def evaluate(self, request: SearchRequest, profile: SearchProfile) -> list[str]:
-        q = request.query.lower()
-        reasons: list[str] = []
-        for term in self.FORBIDDEN_TERMS:
-            if term.lower() in q:
-                reasons.append(f"blocked_term:{term}")
-        if request.user_scope not in {"public", "authorized_user_file", "authorized_link", "internal_archive"}:
-            reasons.append(f"unsupported_scope:{request.user_scope}")
-        if request.data_type in {"personal_grade", "student_private_data", "private_person_data"} and request.user_scope != "authorized_user_file":
-            reasons.append("private_data_requires_user_authorized_file")
-        if not profile.audit_required:
-            reasons.append("audit_cannot_be_disabled")
-        if not profile.fallback_required:
-            reasons.append("fallback_cannot_be_disabled")
-        return reasons
-
-
-class SearchGateway:
-    def __init__(self, providers: list[SearchProvider] | None = None):
-        self.providers = providers or []
-        self.profile_resolver = SearchProfileResolver()
-        self.planner = QueryPlanner()
-        self.guard = SearchPolicyGuard()
-
-    def search(self, request: SearchRequest) -> SearchResponse:
-        request_id = request.correlation_id or f"search_{uuid4().hex[:12]}"
-        profile = self.profile_resolver.resolve(request.group_profile, request.user_profile, request.session_profile)
-        expanded_queries = self.planner.expand(request, profile)
-        blocked = self.guard.evaluate(request, profile)
-        if blocked:
-            return SearchResponse(
-                request_id=request_id,
-                status="blocked",
-                answer="该搜索请求涉及未授权访问、验证码/登录绕过、受保护平台批量抓取或个人隐私数据，已阻断。可改为搜索公开网页、官方公告、公开文档，或处理用户授权上传的文件/链接。",
-                evidence=[],
-                attempts=[],
-                confidence="high",
-                expanded_queries=expanded_queries,
-                resolved_profile=profile.to_dict(),
-                blocked_reasons=blocked,
-            )
-
-        evidence: list[SearchEvidence] = []
-        attempts: list[SearchProviderAttempt] = []
-        providers = self._ordered_providers(profile)
-        for provider in providers:
-            try:
-                provider_evidence, attempt = provider.search(request, expanded_queries)
-                evidence.extend(provider_evidence)
-                attempts.append(attempt)
-                if provider_evidence:
-                    break
-            except Exception as exc:
-                attempts.append(SearchProviderAttempt(provider=getattr(provider, "name", "unknown"), status="failed", reason=str(exc)))
-
-        if evidence:
-            return SearchResponse(
-                request_id=request_id,
-                status="found",
-                answer="已找到公开或授权来源结果。",
-                evidence=evidence,
-                attempts=attempts,
-                confidence=self._confidence(evidence),
-                expanded_queries=expanded_queries,
-                resolved_profile=profile.to_dict(),
-            )
-
-        return SearchResponse(
-            request_id=request_id,
-            status="not_found",
-            answer="未找到足够可靠的公开或授权结果；已记录 provider 尝试和失败原因。",
-            evidence=[],
-            attempts=attempts,
-            confidence="low",
-            expanded_queries=expanded_queries,
-            resolved_profile=profile.to_dict(),
-            need_clarification=self._clarification(request),
-        )
-
-    def _ordered_providers(self, profile: SearchProfile) -> list[SearchProvider]:
-        if not self.providers:
-            return []
-        by_name = {provider.name: provider for provider in self.providers}
-        ordered = [by_name[name] for name in profile.provider_order if name in by_name]
-        remaining = [provider for provider in self.providers if provider.name not in {p.name for p in ordered}]
-        return ordered + remaining
-
-    def _confidence(self, evidence: list[SearchEvidence]) -> str:
-        if any(e.confidence == "high" for e in evidence):
-            return "high"
-        if evidence:
-            return "medium"
-        return "low"
-
-    def _clarification(self, request: SearchRequest) -> list[str]:
-        if request.intent == "education_exam_data":
-            return ["请补充学校名称、联考名称、年级、科目，以及需要试卷/答案还是成绩统计。"]
-        if request.intent in {"company_research", "policy_regulation", "software_library", "product_research"}:
-            return ["请补充主体名称、地区/版本、时间范围、需要的数据类型或可信来源范围。"]
-        return ["请补充更具体的主体、平台、地区、时间、数据类型或授权文件/链接。"]
-
-
-__all__ = [
-    "SearchRequest",
-    "SearchEvidence",
-    "SearchProviderAttempt",
-    "SearchResponse",
-    "SearchProvider",
-    "QueryPlanner",
-    "SearchPolicyGuard",
-    "SearchGateway",
-]

active-runtime/app/search_gateway_api.py

@@ -1,65 +0,0 @@
-"""API endpoints for AIOS Search Gateway."""
-
-from typing import Any
-
-try:
-    from fastapi import APIRouter
-except Exception:
-    APIRouter = None
-
-from .search_gateway import SearchGateway, SearchRequest
-from .search_gateway_dashboard import SearchGatewayDashboard
-
-
-gateway = SearchGateway()
-dashboard = SearchGatewayDashboard()
-
-
-def search_gateway_request(payload: dict[str, Any]) -> dict[str, Any]:
-    request = SearchRequest(**payload)
-    return gateway.search(request).to_dict()
-
-
-def get_search_gateway_status() -> dict[str, Any]:
-    return {
-        "module": "search-gateway",
-        "status": "ready",
-        "providers_configured": len(gateway.providers),
-        "policy_guard": "enabled",
-        "profile_customization": "enabled",
-        "fallback_required_when_provider_unavailable": True,
-    }
-
-
-def get_search_gateway_overview() -> dict[str, Any]:
-    return dashboard.overview()
-
-
-def build_router():
-    if APIRouter is None:
-        return None
-    router = APIRouter(prefix="/admin/ai-evolution/search", tags=["search-gateway"])
-
-    @router.get("/status", operation_id="getSearchGatewayStatus")
-    def status():
-        return get_search_gateway_status()
-
-    @router.get("/overview", operation_id="getSearchGatewayOverview")
-    def overview():
-        return get_search_gateway_overview()
-
-    @router.post("/query", operation_id="runSearchGatewayQuery")
-    def query(payload: dict[str, Any]):
-        return search_gateway_request(payload)
-
-    return router
-
-
-router = build_router()
-
-__all__ = [
-    "router",
-    "search_gateway_request",
-    "get_search_gateway_status",
-    "get_search_gateway_overview",
-]

active-runtime/app/search_gateway_dashboard.py

@@ -1,85 +0,0 @@
-"""Search Gateway Web UI dashboard model."""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass(frozen=True)
-class SearchDashboardMetric:
-    key: str
-    title: str
-    value: Any
-    status: str = "ok"
-    detail: str = ""
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class SearchDashboardPanel:
-    key: str
-    title: str
-    metrics: list[SearchDashboardMetric] = field(default_factory=list)
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "key": self.key,
-            "title": self.title,
-            "metrics": [m.to_dict() for m in self.metrics],
-        }
-
-
-class SearchGatewayDashboard:
-    def overview(self, search_runs: list[dict[str, Any]] | None = None, providers: list[dict[str, Any]] | None = None) -> dict[str, Any]:
-        search_runs = search_runs or []
-        providers = providers or []
-        blocked = [r for r in search_runs if r.get("status") == "blocked"]
-        not_found = [r for r in search_runs if r.get("status") == "not_found"]
-        provider_failures = [p for p in providers if p.get("status") == "failed"]
-        panels = [
-            SearchDashboardPanel(
-                "search_health",
-                "搜索健康度",
-                [
-                    SearchDashboardMetric("total_runs", "搜索请求数", len(search_runs)),
-                    SearchDashboardMetric("not_found", "未找到结果", len(not_found), "warn" if not_found else "ok"),
-                    SearchDashboardMetric("blocked", "合规阻断", len(blocked), "warn" if blocked else "ok"),
-                ],
-            ),
-            SearchDashboardPanel(
-                "provider_health",
-                "Provider 可用性",
-                [
-                    SearchDashboardMetric("providers", "Provider 数量", len(providers)),
-                    SearchDashboardMetric("provider_failures", "Provider 失败", len(provider_failures), "warn" if provider_failures else "ok"),
-                ],
-            ),
-            SearchDashboardPanel(
-                "evidence_quality",
-                "证据质量",
-                [
-                    SearchDashboardMetric("with_evidence", "有证据的回答", len([r for r in search_runs if r.get("evidence")])) ,
-                    SearchDashboardMetric("fallback_required", "要求多源降级", True),
-                ],
-            ),
-        ]
-        return {
-            "module": "search-gateway",
-            "route": "/admin/ai-evolution/search",
-            "title": "AIOS 联网搜索治理中心",
-            "status": "attention_required" if provider_failures else "healthy",
-            "generated_at": utc_now(),
-            "panels": [p.to_dict() for p in panels],
-            "recent_runs": search_runs[-20:],
-        }
-
-
-__all__ = ["SearchDashboardMetric", "SearchDashboardPanel", "SearchGatewayDashboard"]

active-runtime/app/search_gateway_orchestrator.py

@@ -1,41 +0,0 @@
-"""Runtime orchestrator joining Search Gateway, registry, audit and events."""
-
-from __future__ import annotations
-
-from typing import Any
-
-from .search_audit_store import SearchAuditStore
-from .search_event_bridge import SearchEventBridge
-from .search_gateway import SearchGateway, SearchRequest
-from .search_provider_registry import SearchProviderRegistry
-
-
-class SearchGatewayOrchestrator:
-    def __init__(self):
-        self.registry = SearchProviderRegistry()
-        self.audit = SearchAuditStore()
-        self.events = SearchEventBridge()
-        self.gateway = SearchGateway(self.registry.ordered())
-
-    def execute(self, payload: dict[str, Any]) -> dict[str, Any]:
-        request = SearchRequest(**payload)
-        self.events.search_started(request.to_dict())
-        response = self.gateway.search(request)
-        result = response.to_dict()
-        for attempt in result.get("attempts", []):
-            self.events.provider_attempted(result["request_id"], attempt)
-        if len(result.get("attempts", [])) > 1:
-            self.events.fallback_triggered(result["request_id"], "multiple providers attempted")
-        self.audit.append(result)
-        self.events.search_completed(result)
-        return result
-
-    def status(self) -> dict[str, Any]:
-        return {
-            "registry": self.registry.status(),
-            "audit": "enabled",
-            "events": "enabled",
-        }
-
-
-__all__ = ["SearchGatewayOrchestrator"]

active-runtime/app/search_profile_resolver.py

@@ -1,124 +0,0 @@
-"""Search profile resolver for general-purpose AIOS Search Gateway.
-
-The Search Gateway is a shared platform capability. Groups and users may customize
-provider preference, query expansion hints, trusted sources and domain profiles on
-top of the shared base profile. Customization is intentionally layered and cannot
-override hard safety, authorization or audit rules.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from typing import Any
-
-
-HARD_BLOCKED_BEHAVIORS = {
-    "bypass_login",
-    "bypass_captcha",
-    "scrape_private_student_grades",
-    "scrape_student_private_data",
-    "bulk_scrape_protected_platforms",
-    "collect_data_without_authorization",
-}
-
-
-@dataclass(frozen=True)
-class SearchProfile:
-    profile_id: str
-    scope: str
-    provider_order: list[str] = field(default_factory=lambda: [
-        "cache",
-        "official_site",
-        "general_web",
-        "vertical_source",
-        "browser_fetch",
-        "user_authorized_file",
-        "internal_archive",
-    ])
-    trusted_domains: list[str] = field(default_factory=list)
-    query_expansion_hints: list[str] = field(default_factory=list)
-    domain_profiles: list[str] = field(default_factory=list)
-    blocked_behaviors: set[str] = field(default_factory=lambda: set(HARD_BLOCKED_BEHAVIORS))
-    audit_required: bool = True
-    fallback_required: bool = True
-
-    def to_dict(self) -> dict[str, Any]:
-        data = asdict(self)
-        data["blocked_behaviors"] = sorted(self.blocked_behaviors)
-        return data
-
-
-class SearchProfileResolver:
-    """Resolves base -> group -> user -> session search preferences."""
-
-    def base_profile(self) -> SearchProfile:
-        return SearchProfile(profile_id="base", scope="global")
-
-    def resolve(
-        self,
-        group_profile: dict[str, Any] | None = None,
-        user_profile: dict[str, Any] | None = None,
-        session_profile: dict[str, Any] | None = None,
-    ) -> SearchProfile:
-        profile = self.base_profile().to_dict()
-        for overlay in (group_profile, user_profile, session_profile):
-            if overlay:
-                profile = self._merge(profile, overlay)
-        profile["blocked_behaviors"] = set(HARD_BLOCKED_BEHAVIORS)
-        profile["audit_required"] = True
-        profile["fallback_required"] = True
-        return SearchProfile(**profile)
-
-    def _merge(self, base: dict[str, Any], overlay: dict[str, Any]) -> dict[str, Any]:
-        merged = dict(base)
-        if overlay.get("provider_order"):
-            merged["provider_order"] = list(overlay["provider_order"])
-        for list_key in ("trusted_domains", "query_expansion_hints", "domain_profiles"):
-            merged[list_key] = self._dedupe(list(merged.get(list_key, [])) + list(overlay.get(list_key, [])))
-        merged["profile_id"] = overlay.get("profile_id", merged.get("profile_id", "custom"))
-        merged["scope"] = overlay.get("scope", merged.get("scope", "custom"))
-        return merged
-
-    def _dedupe(self, items: list[str]) -> list[str]:
-        return list(dict.fromkeys([item for item in items if item]))
-
-
-class DomainQueryProfileRegistry:
-    """Optional domain-specific expansions for the general Search Gateway."""
-
-    DEFAULT_PROFILES = {
-        "education_exam_data": [
-            "学校 年级 科目 试卷 答案 成绩统计",
-            "联考 月考 期中 期末 质量检测",
-        ],
-        "policy_regulation": [
-            "官方 通知 政策 解读 实施细则",
-            "site:gov.cn OR site:edu.cn",
-        ],
-        "software_library": [
-            "release notes changelog migration guide",
-            "official documentation GitHub issues",
-        ],
-        "product_research": [
-            "specs review comparison price availability",
-            "official page manual support",
-        ],
-        "company_research": [
-            "official announcement press release filings",
-            "leadership product financial report",
-        ],
-    }
-
-    def hints_for(self, domain_profiles: list[str]) -> list[str]:
-        hints: list[str] = []
-        for profile in domain_profiles:
-            hints.extend(self.DEFAULT_PROFILES.get(profile, []))
-        return list(dict.fromkeys(hints))
-
-
-__all__ = [
-    "HARD_BLOCKED_BEHAVIORS",
-    "SearchProfile",
-    "SearchProfileResolver",
-    "DomainQueryProfileRegistry",
-]

active-runtime/app/search_provider_registry.py

@@ -1,121 +0,0 @@
-"""Provider registry for the general AIOS Search Gateway.
-
-The registry makes provider availability explicit and auditable. Provider
-implementations are pluggable: production can register real public search,
-official-site, vertical-source, browser-fetch, authorized-file or archive
-providers without changing the Search Gateway core.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from typing import Any
-
-from .search_gateway import SearchEvidence, SearchProviderAttempt, SearchRequest
-
-
-@dataclass(frozen=True)
-class SearchProviderConfig:
-    name: str
-    provider_type: str
-    enabled: bool = True
-    requires_secret: bool = False
-    supports_public_web: bool = True
-    supports_authorized_sources: bool = False
-    health: str = "unknown"
-    metadata: dict[str, Any] = field(default_factory=dict)
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-class NullSearchProvider:
-    """Safe placeholder provider used until runtime wires a real adapter."""
-
-    def __init__(self, config: SearchProviderConfig):
-        self.config = config
-        self.name = config.name
-
-    def search(self, request: SearchRequest, queries: list[str]):
-        return [], SearchProviderAttempt(
-            provider=self.name,
-            status="not_configured" if self.config.enabled else "disabled",
-            result_count=0,
-            reason="provider adapter not wired in runtime",
-        )
-
-
-class StaticArchiveProvider:
-    """Small deterministic provider for tests and internal archived evidence."""
-
-    name = "internal_archive"
-
-    def __init__(self, records: list[dict[str, Any]] | None = None):
-        self.records = records or []
-
-    def search(self, request: SearchRequest, queries: list[str]):
-        evidence: list[SearchEvidence] = []
-        for record in self.records:
-            haystack = " ".join([record.get("title", ""), record.get("snippet", ""), record.get("tags", "")]).lower()
-            if any(q.lower() in haystack for q in queries):
-                evidence.append(
-                    SearchEvidence(
-                        title=record.get("title", "archive result"),
-                        url=record.get("url"),
-                        source=self.name,
-                        snippet=record.get("snippet", ""),
-                        evidence_type="internal_archive",
-                        confidence=record.get("confidence", "medium"),
-                    )
-                )
-        return evidence, SearchProviderAttempt(provider=self.name, status="ok", result_count=len(evidence))
-
-
-class SearchProviderRegistry:
-    DEFAULT_PROVIDER_CONFIGS = [
-        SearchProviderConfig("cache", "cache", supports_public_web=False),
-        SearchProviderConfig("official_site", "official_site"),
-        SearchProviderConfig("general_web", "general_web"),
-        SearchProviderConfig("vertical_source", "vertical_source"),
-        SearchProviderConfig("browser_fetch", "browser_fetch"),
-        SearchProviderConfig("user_authorized_file", "authorized_file", supports_public_web=False, supports_authorized_sources=True),
-        SearchProviderConfig("internal_archive", "archive", supports_public_web=False),
-    ]
-
-    def __init__(self):
-        self.configs: dict[str, SearchProviderConfig] = {}
-        self.providers: dict[str, Any] = {}
-        for config in self.DEFAULT_PROVIDER_CONFIGS:
-            self.register_config(config)
-
-    def register_config(self, config: SearchProviderConfig) -> None:
-        self.configs[config.name] = config
-        self.providers.setdefault(config.name, NullSearchProvider(config))
-
-    def register_provider(self, name: str, provider: Any, config: SearchProviderConfig | None = None) -> None:
-        if config:
-            self.configs[name] = config
-        elif name not in self.configs:
-            self.configs[name] = SearchProviderConfig(name=name, provider_type="custom")
-        self.providers[name] = provider
-
-    def ordered(self, order: list[str] | None = None) -> list[Any]:
-        order = order or list(self.configs)
-        result = [self.providers[name] for name in order if name in self.providers and self.configs[name].enabled]
-        result.extend([provider for name, provider in self.providers.items() if name not in order and self.configs[name].enabled])
-        return result
-
-    def status(self) -> dict[str, Any]:
-        return {
-            "providers": [self.configs[name].to_dict() for name in sorted(self.configs)],
-            "enabled": len([c for c in self.configs.values() if c.enabled]),
-            "configured": len([name for name, provider in self.providers.items() if not isinstance(provider, NullSearchProvider)]),
-        }
-
-
-__all__ = [
-    "SearchProviderConfig",
-    "NullSearchProvider",
-    "StaticArchiveProvider",
-    "SearchProviderRegistry",
-]

active-runtime/app/static/admin-ai-evolution.html

@@ -1,265 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>AI Evolution Dashboard</title>
-<style>
-* { margin: 0; padding: 0; box-sizing: border-box; }
-body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif; background: #0d1117; color: #c9d1d9; height: 100vh; overflow: hidden; }
-.app { display: flex; height: 100vh; }
-.sidebar { width: 260px; background: #161b22; border-right: 1px solid #30363d; padding: 20px; display: flex; flex-direction: column; gap: 16px; }
-.sidebar h1 { font-size: 18px; color: #f0f6fc; border-bottom: 1px solid #30363d; padding-bottom: 12px; margin-bottom: 8px; }
-.sidebar-nav { list-style: none; display: flex; flex-direction: column; gap: 4px; }
-.sidebar-nav li { padding: 8px 12px; border-radius: 6px; cursor: pointer; font-size: 14px; color: #8b949e; }
-.sidebar-nav li:hover, .sidebar-nav li.active { background: #1f6feb22; color: #58a6ff; }
-.sidebar-nav li i { margin-right: 8px; }
-.main { flex: 1; padding: 24px; overflow-y: auto; }
-.main-header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 24px; }
-.main-header h2 { font-size: 20px; }
-.status-badge { padding: 4px 12px; border-radius: 12px; font-size: 12px; font-weight: 600; text-transform: uppercase; }
-.status-badge.ok { background: #1b3a2d; color: #3fb950; border: 1px solid #3fb95044; }
-.status-badge.degraded { background: #3a2e1b; color: #d29922; border: 1px solid #d2992244; }
-.status-badge.fail { background: #3a1b1b; color: #f85149; border: 1px solid #f8514944; }
-.card { background: #161b22; border: 1px solid #30363d; border-radius: 8px; padding: 16px; margin-bottom: 16px; }
-.card-title { font-size: 14px; color: #8b949e; margin-bottom: 8px; }
-.card-value { font-size: 28px; font-weight: 700; color: #f0f6fc; }
-.row { display: flex; gap: 16px; }
-.col { flex: 1; }
-.grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 16px; }
-pre { white-space: pre-wrap; word-break: break-word; }
-.command-item { padding: 12px; margin-bottom: 8px; border-radius: 6px; background: #0d1117; border: 1px solid #21262d; }
-.command-item .meta { display: flex; gap: 8px; align-items: center; font-size: 12px; color: #8b949e; }
-.command-item .name { font-size: 14px; color: #58a6ff; font-weight: 600; }
-.command-item .state { font-size: 11px; padding: 2px 8px; border-radius: 10px; text-transform: uppercase; }
-.state-active { background: #1b3a2d; color: #3fb950; }
-.state-running { background: #3a2e1b; color: #d29922; }
-.state-completed { background: #1b3a2d; color: #3fb950; }
-.state-failed { background: #3a1b1b; color: #f85149; }
-.loading { text-align: center; padding: 40px; color: #8b949e; }
-.error { padding: 20px; background: #3a1b1b; border: 1px solid #f8514944; border-radius: 8px; color: #f85149; margin-bottom: 16px; }
-.version-item { padding: 8px 12px; background: #0d1117; border: 1px solid #21262d; border-radius: 6px; margin-bottom: 4px; display: flex; justify-content: space-between; }
-.version-item .tag { color: #58a6ff; font-weight: 600; }
-.version-item .name { color: #8b949e; font-size: 13px; }
-.agent-item { background: #0d1117; border: 1px solid #21262d; border-radius: 6px; margin-bottom: 8px; padding: 12px; }
-.agent-item .agent-title { font-size: 14px; font-weight: 600; color: #c9d1d9; margin-bottom: 4px; }
-.agent-item .agent-meta { font-size: 12px; color: #8b949e; }
-.agent-run-item { padding: 8px 12px; margin-bottom: 4px; border-radius: 4px; background: #0d1117; border: 1px solid #21262d; display: flex; justify-content: space-between; align-items: center; }
-.agent-run-item .run-id { color: #58a6ff; font-size: 13px; font-weight: 600; }
-.agent-run-item .source { color: #8b949e; font-size: 12px; }
-</style>
-</head>
-<body>
-<div id="app" class="app">
-  <div class="sidebar">
-    <h1>🕹️ AI Evolution Dashboard</h1>
-    <ul class="sidebar-nav">
-      <li class="active" onclick="showPanel('overview')"><i>📊</i> Overview</li>
-      <li onclick="showPanel('versions')"><i>🏷️</i> Versions</li>
-      <li onclick="showPanel('commands')"><i>⚡</i> Commands</li>
-      <li onclick="showPanel('agents')"><i>🤖</i> Agent Runs</li>
-      <li onclick="showPanel('arch-owner')"><i>🔐</i> Owner Gate</li>
-      <li onclick="showPanel('arch-approve')"><i>✓</i> Approve Changes</li>
-    </ul>
-  </div>
-  <div class="main">
-    <div id="panel-overview" class="panel">
-      <div class="main-header">
-        <h2>System Overview</h2>
-        <div id="header-status" class="status-badge">Loading...</div>
-      </div>
-      <div id="loading" class="loading">Loading...</div>
-      <div id="error" class="error" style="display:none;"></div>
-      <div id="content">
-        <div class="row">
-          <div class="col"><div class="card"><div class="card-title">Current Baseline</div><div id="base" class="card-value">-</div></div></div>
-          <div class="col"><div class="card"><div class="card-title">Git Branch</div><div id="branch" class="card-value">-</div></div></div>
-          <div class="col"><div class="card"><div class="card-title">Uptime</div><div id="uptime" class="card-value">-</div></div></div>
-        </div>
-        <div class="card" style="margin-top:16px">
-          <div class="card-title">Event Bus Status</div>
-          <pre id="bus-status">-</pre>
-        </div>
-      </div>
-    </div>
-    <div id="panel-versions" class="panel" style="display:none;">
-      <div class="main-header"><h2>Version Timeline</h2></div>
-      <div id="versions-list">Loading...</div>
-    </div>
-    <div id="panel-commands" class="panel" style="display:none;">
-      <div class="main-header"><h2>Command Lookup</h2></div>
-      <div id="commands-list">Loading...</div>
-    </div>
-    <div id="panel-agents" class="panel" style="display:none;">
-      <div class="main-header"><h2>Recent Agent Executions</h2></div>
-    <div id="panel-arch-owner" class="panel" style="display:none;">
-      <div class="main-header"><h2>🔐 Architecture Owner Gate</h2></div>
-      <div id="arch-owner-content">Loading...</div>
-    </div>
-    <div id="panel-arch-approve" class="panel" style="display:none;">
-      <div class="main-header"><h2>✓ Approve Architecture Changes</h2></div>
-      <div id="arch-approve-content">Loading...</div>
-    </div>
-      <div id="agents-list">Loading...</div>
-    </div>
-  </div>
-</div>
-<script>
-async function fetchData() {
-  const r = await fetch('/admin/ai-evolution/api/data');
-  const data = await r.json();
-  document.getElementById('loading').style.display = 'none';
-  document.getElementById('error').style.display = 'none';
-  document.getElementById('content').style.display = '';
-
-  const hs = document.getElementById('header-status');
-  hs.className = 'status-badge ' + (data.healthy ? 'ok' : 'fail');
-  hs.textContent = data.healthy ? '▪ operational' : '⚠ degraded';
-
-  document.getElementById('base').textContent = data.baseline || '-';
-  document.getElementById('branch').textContent = data.main_branch || 'main';
-  document.getElementById('uptime').textContent = data.uptime || '-';
-  document.getElementById('bus-status').textContent = data.bus ? JSON.stringify(data.bus, null, 2) : 'no event bus data';
-}
-
-async function loadVersions() {
-  const el = document.getElementById('versions-list');
-  el.innerHTML = '<div class="loading">Loading versions...</div>';
-  try {
-    const r = await fetch('/admin/ai-evolution/api/versions');
-    const data = await r.json();
-    if (data.error) { el.innerHTML = '<div class="error">' + data.error + '</div>'; return; }
-    let html = '<div class="grid">';
-    for (const v of data.versions || []) {
-      html += '<div class="card"><div class="card-title">' + v.tag + '</div><div class="card-value">' + (v.version || v.tag) + '</div></div>';
-    }
-    html += '</div>';
-    el.innerHTML = html;
-  } catch(e) {
-    el.innerHTML = '<div class="error">Failed to load versions: ' + e.message + '</div>';
-  }
-}
-
-async function loadCommands() {
-  const el = document.getElementById('commands-list');
-  el.innerHTML = '<div class="loading">Loading commands...</div>';
-  try {
-    const r = await fetch('/admin/ai-evolution/api/data');
-    const data = await r.json();
-    let cmds = data.commands || [];
-    let html = '<div style="display:flex;gap:24px;margin-bottom:16px;">';
-    html += '<div><div class="card"><div class="card-title">Total</div><div class="card-value">' + cmds.length + '</div></div></div>';
-    html += '<div><div class="card"><div class="card-title">By Category</div>';
-    const cats = {};
-    for (const c of cmds) { const k = c.category || 'uncategorized'; cats[k] = (cats[k] || 0) + 1; }
-    for (const [k, v] of Object.entries(cats)) html += '<div style="font-size:14px;color:#8b949e;margin:4px 0;">' + k + ': ' + v + '</div>';
-    html += '</div></div></div>';
-    for (const cmd of cmds.slice().reverse()) {
-      html += '<div class="command-item"><div class="meta">' + cmd.category + ' | ' + cmd.filename + '</div><div class="name">' + cmd.title + '</div><div style="font-size:13px;color:#c9d1d9;margin-top:4px;">' + cmd.summary + '</div></div>';
-    }
-    el.innerHTML = html;
-  } catch(e) {
-    el.innerHTML = '<div class="error">Failed to load commands: ' + e.message + '</div>';
-  }
-}
-
-async function loadAgents() {
-  const el = document.getElementById('agents-list');
-  el.innerHTML = '<div class="loading">Loading agent runs...</div>';
-  try {
-    const r = await fetch('/admin/ai-evolution/api/agents');
-    const data = await r.json();
-    if (data.error) { el.innerHTML = '<div class="error">' + data.error + '</div>'; return; }
-    let html = '';
-    for (const agent of data.agents || []) {
-      html += '<div class="agent-item"><div class="agent-title">' + agent.name + ' <span class="state state-' + (agent.status === 'running' ? 'running' : (agent.status === 'ok' ? 'completed' : 'failed')) + '">' + agent.status + '</span></div><div class="agent-meta">' + (agent.runs || 0) + ' runs | last: ' + (agent.last_run || '-') + '</div></div>';
-    }
-    el.innerHTML = html || '<div style="padding:24px;color:#8b949e;">No agent runs recorded yet.</div>';
-  } catch(e) {
-    el.innerHTML = '<div class="error">Failed to load agents: ' + e.message + '</div>';
-  }
-}
-
-function showPanel(name) {
-
-async function loadOwnerGate() {
-  const el = document.getElementById('arch-owner-content');
-  el.innerHTML = '<div class="loading">Loading owner gate data...</div>';
-  try {
-    const r = await fetch('/admin/ai-evolution/api/owner-gate');
-    const data = await r.json();
-    let html = '<div class="row">';
-    html += '<div class="col"><div class="card"><div class="card-title">Pending Requests</div><div class="card-value">' + data.pending_count + '</div></div></div>';
-    html += '<div class="col"><div class="card"><div class="card-title">Approved</div><div class="card-value">' + data.approved_count + '</div></div></div>';
-    html += '<div class="col"><div class="card"><div class="card-title">Rejected</div><div class="card-value">' + data.rejected_count + '</div></div></div>';
-    html += '</div>';
-    html += '<div class="card"><div class="card-title">Pending Approval Requests</div>';
-    if (data.pending_requests && data.pending_requests.length) {
-      for (const req of data.pending_requests) {
-        html += '<div class="command-item">';
-        html += '<div class="name">' + (req.title || req.change_id) + '</div>';
-        html += '<div class="meta">ID: ' + req.change_id + ' | Risk: ' + req.risk + '</div>';
-        html += '<div style="font-size:13px;color:#c9d1d9;margin-top:4px;">' + (req.reason || '') + '</div>';
-        html += '</div>';
-      }
-    } else {
-      html += '<div style="color:#8b949e;padding:12px;">No pending requests.</div>';
-    }
-    html += '</div>';
-    el.innerHTML = html;
-  } catch(e) {
-    el.innerHTML = '<div class="error">Failed to load: ' + e.message + '</div>';
-  }
-}
-
-async function loadApprove() {
-  const el = document.getElementById('arch-approve-content');
-  el.innerHTML = '<div class="loading">Loading pending approvals...</div>';
-  try {
-    const r = await fetch('/admin/ai-evolution/api/owner-gate');
-    const data = await r.json();
-    let html = '';
-    if (data.pending_requests && data.pending_requests.length) {
-      html += '<div class="card"><div class="card-title">Pending changes requiring your approval</div>';
-      for (const req of data.pending_requests) {
-        html += '<div class="command-item">';
-        html += '<div class="name">' + (req.title || req.change_id) + '</div>';
-        html += '<div class="meta">Risk: <strong>' + req.risk + '</strong></div>';
-        html += '<div style="font-size:13px;color:#c9d1d9;margin:8px 0;">' + (req.reason || '') + '</div>';
-        html += '<div style="display:flex;gap:8px;">';
-        html += '<button onclick="ownerAction.classList.add('\'approved\');this.disabled=true" style="padding:6px 16px;background:#238636;color:#fff;border:none;border-radius:6px;cursor:pointer;font-size:13px;">✓ Approve</button>';
-        html += '</div></div>';
-      }
-      html += '</div>';
-    } else {
-      html += '<div class="card"><div style="padding:24px;text-align:center;color:#8b949e;">✅ All changes processed. No pending approval requests.</div></div>';
-    }
-    el.innerHTML = html;
-  } catch(e) {
-    el.innerHTML = '<div class="error">Failed to load: ' + e.message + '</div>';
-  }
-}
-
-  document.querySelectorAll('.panel').forEach(p => p.style.display = 'none');
-  document.getElementById('panel-' + name).style.display = '';
-  document.querySelectorAll('.sidebar-nav li').forEach(li => li.classList.remove('active'));
-  document.querySelector('.sidebar-nav li:nth-child(' + ({overview:1,versions:2,commands:3,agents:4}[name] || 1) + ')').classList.add('active');
-  if (name === 'overview') {
-    document.getElementById('panel-overview').innerHTML = '<div class="main-header"><h2>System Overview</h2><div id="header-status" class="status-badge">Loading...</div></div><div id="loading" class="loading">Loading...</div><div id="error" class="error" style="display:none;"></div><div id="content"><div class="row"><div class="col"><div class="card"><div class="card-title">Current Baseline</div><div id="base" class="card-value">-</div></div></div><div class="col"><div class="card"><div class="card-title">Git Branch</div><div id="branch" class="card-value">-</div></div></div><div class="col"><div class="card"><div class="card-title">Uptime</div><div id="uptime" class="card-value">-</div></div></div></div><div class="card" style="margin-top:16px"><div class="card-title">Event Bus Status</div><pre id="bus-status">-</pre></div></div>';
-    fetchData();
-  }
-  const loaders = {
-    'arch-owner': loadOwnerGate,
-    'arch-approve': loadApprove,
-    versions: loadVersions,
-    commands: loadCommands,
-    agents: loadAgents,
-  };
-  const fn = loaders[name];
-  if (fn) fn();
-}
-
-fetchData();
-</script>
-</body>
-</html>

active-runtime/app/task_action_api.py

@@ -1,41 +0,0 @@
-"""Task Center action API model for Web UI buttons."""
-
-from typing import Any
-
-try:
-    from fastapi import APIRouter
-except Exception:
-    APIRouter = None
-
-from .task_lifecycle import TaskLifecycle
-
-
-lifecycle = TaskLifecycle()
-
-
-def get_task_actions(task: dict[str, Any], role: str) -> dict[str, Any]:
-    return {
-        "task_id": task.get("task_id"),
-        "actions": lifecycle.available_actions(task, role),
-    }
-
-
-def execute_task_action(task: dict[str, Any], action: str, role: str, reason: str | None = None):
-    return lifecycle.transition(task, action, role, reason)
-
-
-def build_router():
-    if APIRouter is None:
-        return None
-    router = APIRouter(prefix="/admin/ai-evolution/tasks", tags=["task-actions"])
-
-    @router.post("/{task_id}/actions/{action}", operation_id="executeTaskAction")
-    def action(task_id: str, action: str, payload: dict[str, Any]):
-        return execute_task_action(payload.get("task", {}), action, payload.get("role", "user"), payload.get("reason"))
-
-    return router
-
-
-router = build_router()
-
-__all__ = ["router", "get_task_actions", "execute_task_action"]

active-runtime/app/task_center.py

@@ -1,115 +0,0 @@
-"""AIOS Task Center domain model.
-
-The Task Center gives owners and authorized users a single Web UI page showing:
-who assigned a task, who is executing it, progress, elapsed time, remaining
-work, and whether completion notifications were sent.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def parse_time(value: str | None) -> datetime | None:
-    if not value:
-        return None
-    return datetime.fromisoformat(value.replace("Z", "+00:00"))
-
-
-@dataclass(frozen=True)
-class TaskNotificationStatus:
-    required: bool = True
-    sent: bool = False
-    channel: str | None = None
-    sent_at: str | None = None
-    recipient_scope: str | None = None
-    last_error: str | None = None
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class TaskProgress:
-    percent: int = 0
-    current_step: str = "pending"
-    completed_steps: list[str] = field(default_factory=list)
-    remaining_steps: list[str] = field(default_factory=list)
-    blocked_reason: str | None = None
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-@dataclass(frozen=True)
-class AIOSTaskRecord:
-    task_id: str
-    title: str
-    assigned_by: str
-    executor: str
-    source: str
-    status: str = "pending"
-    priority: str = "normal"
-    created_at: str = field(default_factory=utc_now)
-    started_at: str | None = None
-    updated_at: str = field(default_factory=utc_now)
-    completed_at: str | None = None
-    progress: TaskProgress = field(default_factory=TaskProgress)
-    notification: TaskNotificationStatus = field(default_factory=TaskNotificationStatus)
-    owner_gate_required: bool = False
-    owner_gate_status: str | None = None
-    evidence: list[str] = field(default_factory=list)
-
-    def elapsed_seconds(self) -> int:
-        start = parse_time(self.started_at) or parse_time(self.created_at)
-        end = parse_time(self.completed_at) or datetime.now(timezone.utc)
-        return int((end - start).total_seconds()) if start else 0
-
-    def to_dict(self) -> dict[str, Any]:
-        data = asdict(self)
-        data["elapsed_seconds"] = self.elapsed_seconds()
-        data["progress"] = self.progress.to_dict()
-        data["notification"] = self.notification.to_dict()
-        return data
-
-
-class TaskCenter:
-    def summarize(self, tasks: list[AIOSTaskRecord] | list[dict[str, Any]] | None = None) -> dict[str, Any]:
-        raw_tasks = tasks or []
-        task_dicts = [t.to_dict() if hasattr(t, "to_dict") else dict(t) for t in raw_tasks]
-        active = [t for t in task_dicts if t.get("status") in {"running", "pending", "blocked"}]
-        blocked = [t for t in task_dicts if t.get("status") == "blocked"]
-        completed = [t for t in task_dicts if t.get("status") == "completed"]
-        notification_pending = [
-            t for t in completed
-            if t.get("notification", {}).get("required") and not t.get("notification", {}).get("sent")
-        ]
-        return {
-            "module": "task-center",
-            "route": "/admin/ai-evolution/tasks",
-            "title": "AIOS 任务中心",
-            "status": "attention_required" if blocked or notification_pending else "healthy",
-            "generated_at": utc_now(),
-            "summary": {
-                "total": len(task_dicts),
-                "active": len(active),
-                "blocked": len(blocked),
-                "completed": len(completed),
-                "notification_pending": len(notification_pending),
-            },
-            "tasks": sorted(task_dicts, key=lambda t: t.get("updated_at", ""), reverse=True),
-        }
-
-
-__all__ = [
-    "TaskNotificationStatus",
-    "TaskProgress",
-    "AIOSTaskRecord",
-    "TaskCenter",
-]

active-runtime/app/task_center_api.py

@@ -1,34 +0,0 @@
-"""Task Center API."""
-
-from typing import Any
-
-try:
-    from fastapi import APIRouter
-except Exception:
-    APIRouter = None
-
-from .task_center import TaskCenter
-
-
-task_center = TaskCenter()
-
-
-def get_task_overview(tasks: list[dict[str, Any]] | None = None):
-    return task_center.summarize(tasks)
-
-
-def build_router():
-    if APIRouter is None:
-        return None
-    router = APIRouter(prefix="/admin/ai-evolution/tasks", tags=["task-center"])
-
-    @router.get("/overview", operation_id="getTaskCenterOverview")
-    def overview():
-        return get_task_overview()
-
-    return router
-
-
-router = build_router()
-
-__all__ = ["router", "get_task_overview"]

active-runtime/app/task_dashboard_view.py

@@ -1,81 +0,0 @@
-"""Task Center visualization model."""
-
-from __future__ import annotations
-
-from typing import Any
-
-
-class TaskDashboardView:
-    def build(self, tasks: list[dict[str, Any]] | None = None) -> dict[str, Any]:
-        tasks = tasks or []
-        return {
-            "module": "task-center",
-            "route": "/admin/ai-evolution/tasks",
-            "title": "AIOS Task Center",
-            "views": {
-                "kanban": self._kanban(tasks),
-                "timeline": self._timeline(tasks),
-                "flow": self._flow(tasks),
-                "statistics": self._statistics(tasks),
-            },
-            "tasks": [self._task_card(task) for task in tasks],
-        }
-
-    def _task_card(self, task: dict[str, Any]) -> dict[str, Any]:
-        return {
-            "task_id": task.get("task_id"),
-            "title": task.get("title"),
-            "assigned_by": task.get("assigned_by"),
-            "executor": task.get("executor"),
-            "status": task.get("status"),
-            "progress": task.get("progress", {}),
-            "elapsed_seconds": task.get("elapsed_seconds", 0),
-            "remaining_steps": task.get("progress", {}).get("remaining_steps", []),
-            "notification": task.get("notification", {}),
-            "actions": [
-                "start",
-                "update_progress",
-                "block",
-                "request_approval",
-                "approve",
-                "reject",
-                "retry",
-                "complete",
-                "notify",
-                "close",
-            ],
-        }
-
-    def _kanban(self, tasks):
-        columns = {"pending": [], "running": [], "blocked": [], "waiting_approval": [], "completed": []}
-        for task in tasks:
-            columns.setdefault(task.get("status", "pending"), []).append(task.get("task_id"))
-        return columns
-
-    def _timeline(self, tasks):
-        return [
-            {
-                "task_id": task.get("task_id"),
-                "updated_at": task.get("updated_at"),
-                "status": task.get("status"),
-            }
-            for task in tasks
-        ]
-
-    def _flow(self, tasks):
-        return {
-            "nodes": ["created", "assigned", "running", "blocked", "approval", "completed", "closed"],
-            "task_count": len(tasks),
-        }
-
-    def _statistics(self, tasks):
-        return {
-            "total": len(tasks),
-            "running": len([t for t in tasks if t.get("status") == "running"]),
-            "blocked": len([t for t in tasks if t.get("status") == "blocked"]),
-            "waiting_approval": len([t for t in tasks if t.get("status") == "waiting_approval"]),
-            "completed": len([t for t in tasks if t.get("status") == "completed"]),
-        }
-
-
-__all__ = ["TaskDashboardView"]

active-runtime/app/task_event_bridge.py

@@ -1,129 +0,0 @@
-"""Task Center event bridge.
-
-Converts task lifecycle actions and agent execution events into normalized AIOS
-Task Center events. Uses duck-typed Agent Event Bus publisher when available and
-an in-memory fallback for tests/offline runs.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any, Protocol
-from uuid import uuid4
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-class TaskEventPublisher(Protocol):
-    def publish(
-        self,
-        kind: str,
-        source: str,
-        target: str,
-        summary: str,
-        payload: dict[str, Any],
-        correlation_id: str | None = None,
-    ) -> dict[str, Any]:
-        ...
-
-
-@dataclass(frozen=True)
-class TaskEvent:
-    id: str
-    kind: str
-    source: str
-    target: str
-    summary: str
-    payload: dict[str, Any]
-    correlation_id: str | None = None
-    created_at: str = field(default_factory=utc_now)
-
-    def to_dict(self) -> dict[str, Any]:
-        return asdict(self)
-
-
-class InMemoryTaskEventBus:
-    def __init__(self):
-        self.events: list[dict[str, Any]] = []
-
-    def publish(
-        self,
-        kind: str,
-        source: str,
-        target: str,
-        summary: str,
-        payload: dict[str, Any],
-        correlation_id: str | None = None,
-    ) -> dict[str, Any]:
-        event = TaskEvent(
-            id=f"task_evt_{uuid4().hex[:12]}",
-            kind=kind,
-            source=source,
-            target=target,
-            summary=summary,
-            payload=payload,
-            correlation_id=correlation_id,
-        ).to_dict()
-        self.events.append(event)
-        return event
-
-
-class TaskEventBridge:
-    def __init__(self, bus: TaskEventPublisher | None = None):
-        self.bus = bus or InMemoryTaskEventBus()
-
-    def task_created(self, task: dict[str, Any]) -> dict[str, Any]:
-        return self.bus.publish(
-            kind="task_created",
-            source=task.get("assigned_by", "unknown"),
-            target=task.get("executor", "task-center"),
-            summary=task.get("title", "task created"),
-            payload=task,
-            correlation_id=task.get("task_id"),
-        )
-
-    def task_updated(self, task: dict[str, Any], action: str) -> dict[str, Any]:
-        return self.bus.publish(
-            kind="task_updated",
-            source=task.get("executor", "task-center"),
-            target="task-center",
-            summary=f"task {action}: {task.get('status')}",
-            payload={"action": action, "task": task},
-            correlation_id=task.get("task_id"),
-        )
-
-    def task_blocked(self, task: dict[str, Any], reason: str) -> dict[str, Any]:
-        return self.bus.publish(
-            kind="task_blocked",
-            source=task.get("executor", "unknown"),
-            target="owner-gate",
-            summary=reason,
-            payload={"task": task, "reason": reason},
-            correlation_id=task.get("task_id"),
-        )
-
-    def approval_requested(self, task: dict[str, Any], reason: str) -> dict[str, Any]:
-        return self.bus.publish(
-            kind="task_approval_requested",
-            source=task.get("executor", "unknown"),
-            target="owner-gate",
-            summary=reason,
-            payload={"task": task, "reason": reason},
-            correlation_id=task.get("task_id"),
-        )
-
-    def notification_sent(self, task: dict[str, Any], channel: str) -> dict[str, Any]:
-        return self.bus.publish(
-            kind="task_notification_sent",
-            source="notification-agent",
-            target=task.get("assigned_by", "owner"),
-            summary=f"notification sent via {channel}",
-            payload={"task": task, "channel": channel},
-            correlation_id=task.get("task_id"),
-        )
-
-
-__all__ = ["TaskEvent", "InMemoryTaskEventBus", "TaskEventBridge"]

active-runtime/app/task_lifecycle.py

@@ -1,147 +0,0 @@
-"""AIOS Task Lifecycle.
-
-Defines a governed task state machine for task creation, assignment, execution,
-blocking, approval, retry, completion, notification and closure.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-TERMINAL_STATES = {"completed", "cancelled", "failed", "closed"}
-
-
-@dataclass(frozen=True)
-class TaskTransition:
-    action: str
-    from_states: set[str]
-    to_state: str
-    required_role: str = "agent"
-    requires_reason: bool = False
-    notify: bool = False
-
-    def to_dict(self) -> dict[str, Any]:
-        data = asdict(self)
-        data["from_states"] = sorted(self.from_states)
-        return data
-
-
-class TaskLifecycle:
-    """Central task state machine."""
-
-    TRANSITIONS = {
-        "assign": TaskTransition("assign", {"new", "pending"}, "assigned", "dispatcher"),
-        "start": TaskTransition("start", {"assigned", "pending"}, "running", "executor"),
-        "update_progress": TaskTransition("update_progress", {"running"}, "running", "executor"),
-        "block": TaskTransition("block", {"running", "assigned", "pending"}, "blocked", "executor", requires_reason=True, notify=True),
-        "request_approval": TaskTransition("request_approval", {"running", "blocked"}, "waiting_approval", "executor", requires_reason=True, notify=True),
-        "approve": TaskTransition("approve", {"waiting_approval"}, "approved", "owner", notify=True),
-        "reject": TaskTransition("reject", {"waiting_approval"}, "rejected", "owner", requires_reason=True, notify=True),
-        "resume": TaskTransition("resume", {"blocked", "approved"}, "running", "executor"),
-        "retry": TaskTransition("retry", {"failed", "blocked"}, "running", "executor", notify=True),
-        "complete": TaskTransition("complete", {"running", "approved"}, "completed", "executor", notify=True),
-        "notify": TaskTransition("notify", {"completed"}, "completed", "notifier"),
-        "close": TaskTransition("close", {"completed", "cancelled", "failed"}, "closed", "owner"),
-        "cancel": TaskTransition("cancel", {"new", "pending", "assigned", "running", "blocked", "waiting_approval"}, "cancelled", "owner", requires_reason=True, notify=True),
-        "fail": TaskTransition("fail", {"running", "assigned"}, "failed", "executor", requires_reason=True, notify=True),
-    }
-
-    ROLE_ORDER = {
-        "user": 1,
-        "agent": 2,
-        "executor": 3,
-        "dispatcher": 4,
-        "notifier": 4,
-        "group_admin": 5,
-        "owner": 9,
-    }
-
-    def available_actions(self, task: dict[str, Any], role: str) -> list[dict[str, Any]]:
-        state = task.get("status", "new")
-        actions = []
-        for name, transition in self.TRANSITIONS.items():
-            allowed_state = state in transition.from_states
-            allowed_role = self._role_allows(role, transition.required_role)
-            actions.append({
-                "action": name,
-                "label": self._label(name),
-                "enabled": allowed_state and allowed_role,
-                "from_state": state,
-                "to_state": transition.to_state,
-                "required_role": transition.required_role,
-                "requires_reason": transition.requires_reason,
-                "notify": transition.notify,
-                "disabled_reason": None if allowed_state and allowed_role else self._disabled_reason(allowed_state, allowed_role, transition),
-            })
-        return actions
-
-    def transition(self, task: dict[str, Any], action: str, actor_role: str, reason: str | None = None) -> dict[str, Any]:
-        if action not in self.TRANSITIONS:
-            raise ValueError(f"unknown task action: {action}")
-        transition = self.TRANSITIONS[action]
-        state = task.get("status", "new")
-        if state not in transition.from_states:
-            raise ValueError(f"action {action} not allowed from state {state}")
-        if not self._role_allows(actor_role, transition.required_role):
-            raise PermissionError(f"role {actor_role} cannot execute {action}; requires {transition.required_role}")
-        if transition.requires_reason and not reason:
-            raise ValueError(f"action {action} requires reason")
-        updated = dict(task)
-        updated["status"] = transition.to_state
-        updated["updated_at"] = utc_now()
-        history = list(updated.get("history", []))
-        history.append({
-            "action": action,
-            "from": state,
-            "to": transition.to_state,
-            "actor_role": actor_role,
-            "reason": reason,
-            "ts": utc_now(),
-        })
-        updated["history"] = history
-        if action == "complete":
-            updated["completed_at"] = utc_now()
-            notification = dict(updated.get("notification", {}))
-            notification.setdefault("required", True)
-            notification.setdefault("sent", False)
-            updated["notification"] = notification
-        return updated
-
-    def _role_allows(self, role: str, required: str) -> bool:
-        return self.ROLE_ORDER.get(role, 0) >= self.ROLE_ORDER.get(required, 0)
-
-    def _label(self, action: str) -> str:
-        labels = {
-            "assign": "分配任务",
-            "start": "开始执行",
-            "update_progress": "更新进度",
-            "block": "标记阻塞",
-            "request_approval": "请求审批",
-            "approve": "批准",
-            "reject": "拒绝",
-            "resume": "继续执行",
-            "retry": "重试",
-            "complete": "标记完成",
-            "notify": "发送通知",
-            "close": "关闭任务",
-            "cancel": "取消任务",
-            "fail": "标记失败",
-        }
-        return labels.get(action, action)
-
-    def _disabled_reason(self, allowed_state: bool, allowed_role: bool, transition: TaskTransition) -> str:
-        if not allowed_state:
-            return "当前状态不允许该操作"
-        if not allowed_role:
-            return f"需要角色: {transition.required_role}"
-        return "不可用"
-
-
-__all__ = ["TaskTransition", "TaskLifecycle", "TERMINAL_STATES"]

active-runtime/app/task_orchestrator.py

@@ -1,50 +0,0 @@
-"""Task Center orchestrator.
-
-Coordinates task ingestion, persistence, lifecycle updates, events and statistics.
-"""
-
-from __future__ import annotations
-
-from typing import Any
-
-from .task_event_bridge import TaskEventBridge
-from .task_source_ingestor import TaskSourceIngestor
-from .task_statistics import TaskStatistics
-from .task_store import TaskStore
-
-
-class TaskOrchestrator:
-    def __init__(self):
-        self.ingestor = TaskSourceIngestor()
-        self.store = TaskStore()
-        self.events = TaskEventBridge()
-        self.statistics = TaskStatistics()
-
-    def create_from_command(self, path: str, bucket: str = "active") -> dict[str, Any]:
-        task = self.ingestor.command_file_to_task(path, bucket)
-        self.store.append(task)
-        self.events.task_created(task)
-        return task
-
-    def create_from_agent_execution(self, record: dict[str, Any]) -> dict[str, Any]:
-        task = self.ingestor.agent_execution_to_task(record)
-        self.store.append(task)
-        self.events.task_created(task)
-        return task
-
-    def sync_event(self, event: dict[str, Any]) -> dict[str, Any] | None:
-        task = self.ingestor.event_to_task(event)
-        if task:
-            self.store.append(task)
-            self.events.task_updated(task, event.get("kind", "event"))
-        return task
-
-    def dashboard(self) -> dict[str, Any]:
-        tasks = self.store.latest()
-        return {
-            "tasks": tasks,
-            "statistics": self.statistics.summarize(tasks),
-        }
-
-
-__all__ = ["TaskOrchestrator"]

active-runtime/app/task_source_ingestor.py

@@ -1,159 +0,0 @@
-"""Task source ingestion for AIOS Task Center.
-
-Converts Command Watcher files, OpenClaw/Hermes/Codex execution records and
-Generic Agent Event Bus records into normalized Task Center task dictionaries.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-@dataclass(frozen=True)
-class TaskSourceRecord:
-    source_type: str
-    source_id: str
-    title: str
-    assigned_by: str
-    executor: str
-    status: str
-    priority: str = "normal"
-    created_at: str = field(default_factory=utc_now)
-    updated_at: str = field(default_factory=utc_now)
-    evidence: list[str] = field(default_factory=list)
-    metadata: dict[str, Any] = field(default_factory=dict)
-
-    def to_task(self) -> dict[str, Any]:
-        return {
-            "task_id": f"task-{self.source_type}-{self.source_id}",
-            "title": self.title,
-            "assigned_by": self.assigned_by,
-            "executor": self.executor,
-            "source": self.source_type,
-            "status": self.status,
-            "priority": self.priority,
-            "created_at": self.created_at,
-            "updated_at": self.updated_at,
-            "progress": {
-                "percent": self._progress_percent(),
-                "current_step": self.status,
-                "completed_steps": [],
-                "remaining_steps": [],
-                "blocked_reason": self.metadata.get("blocked_reason"),
-            },
-            "notification": {
-                "required": True,
-                "sent": bool(self.metadata.get("notification_sent")),
-                "channel": self.metadata.get("notification_channel"),
-                "sent_at": self.metadata.get("notification_sent_at"),
-            },
-            "evidence": self.evidence,
-            "metadata": self.metadata,
-        }
-
-    def _progress_percent(self) -> int:
-        mapping = {
-            "new": 0,
-            "pending": 5,
-            "assigned": 15,
-            "running": 50,
-            "blocked": 50,
-            "waiting_approval": 60,
-            "approved": 70,
-            "completed": 100,
-            "closed": 100,
-            "failed": 100,
-            "cancelled": 100,
-        }
-        return mapping.get(self.status, 0)
-
-
-class TaskSourceIngestor:
-    COMMAND_STATUS_MAP = {
-        "active": "pending",
-        "running": "running",
-        "completed": "completed",
-        "failed": "failed",
-        "archive": "closed",
-    }
-
-    def command_file_to_task(self, path: str, bucket: str = "active") -> dict[str, Any]:
-        p = Path(path)
-        title = p.stem
-        return TaskSourceRecord(
-            source_type="command_watcher",
-            source_id=title,
-            title=title,
-            assigned_by="command-watcher",
-            executor=self._infer_executor(title),
-            status=self.COMMAND_STATUS_MAP.get(bucket, "pending"),
-            priority="high" if "P0" in title or "fix" in title.lower() else "normal",
-            evidence=[str(p)],
-            metadata={"bucket": bucket},
-        ).to_task()
-
-    def agent_execution_to_task(self, record: dict[str, Any]) -> dict[str, Any]:
-        source_id = record.get("execution_id", record.get("id", "unknown"))
-        status = record.get("status", "running")
-        return TaskSourceRecord(
-            source_type="agent_execution",
-            source_id=source_id,
-            title=record.get("title", f"Agent execution {source_id}"),
-            assigned_by=record.get("assigned_by", record.get("entry_agent", "agent-system")),
-            executor=record.get("closed_by", record.get("entry_agent", "unknown-agent")),
-            status=status,
-            priority=record.get("priority", "normal"),
-            created_at=record.get("started_at", utc_now()),
-            updated_at=record.get("ended_at", utc_now()),
-            evidence=[record.get("execution_id", source_id)],
-            metadata=record,
-        ).to_task()
-
-    def event_to_task(self, event: dict[str, Any]) -> dict[str, Any] | None:
-        kind = event.get("kind")
-        payload = event.get("payload", {})
-        if kind not in {"task_created", "task_updated", "agent_started", "agent_completed", "agent_failed", "search_started", "search_completed"}:
-            return None
-        source_id = event.get("correlation_id") or event.get("id", "event")
-        status = self._status_from_event(kind, payload)
-        return TaskSourceRecord(
-            source_type="event_bus",
-            source_id=source_id,
-            title=payload.get("title") or event.get("summary", kind),
-            assigned_by=event.get("source", "event-bus"),
-            executor=event.get("target", "task-center"),
-            status=status,
-            created_at=event.get("created_at", utc_now()),
-            updated_at=event.get("created_at", utc_now()),
-            evidence=[event.get("id", source_id)],
-            metadata={"event_kind": kind, "payload": payload},
-        ).to_task()
-
-    def _status_from_event(self, kind: str, payload: dict[str, Any]) -> str:
-        if kind.endswith("completed"):
-            return "completed"
-        if kind.endswith("failed"):
-            return "failed"
-        return payload.get("status", "running")
-
-    def _infer_executor(self, title: str) -> str:
-        lower = title.lower()
-        if "openclaw" in lower:
-            return "openclaw"
-        if "hermes" in lower:
-            return "hermes"
-        if "codex" in lower:
-            return "codex"
-        if "search" in lower:
-            return "openclaw"
-        return "openclaw"
-
-
-__all__ = ["TaskSourceRecord", "TaskSourceIngestor"]

active-runtime/app/task_statistics.py

@@ -1,33 +0,0 @@
-"""Task Center statistics."""
-
-from typing import Any
-
-
-class TaskStatistics:
-    def summarize(self, tasks: list[dict[str, Any]] | None = None) -> dict[str, Any]:
-        tasks = tasks or []
-        completed = [t for t in tasks if t.get("status") == "completed"]
-        blocked = [t for t in tasks if t.get("status") == "blocked"]
-        waiting = [t for t in tasks if t.get("status") == "waiting_approval"]
-        elapsed = [t.get("elapsed_seconds", 0) for t in tasks if t.get("elapsed_seconds") is not None]
-        return {
-            "total": len(tasks),
-            "completed": len(completed),
-            "blocked": len(blocked),
-            "waiting_approval": len(waiting),
-            "completion_rate": round(len(completed) / len(tasks) * 100, 2) if tasks else 0,
-            "average_elapsed_seconds": round(sum(elapsed) / len(elapsed), 2) if elapsed else 0,
-            "top_blockers": self._top_values(blocked, "blocker"),
-            "executor_distribution": self._top_values(tasks, "executor"),
-        }
-
-    def _top_values(self, tasks: list[dict[str, Any]], key: str):
-        result: dict[str, int] = {}
-        for task in tasks:
-            value = task.get(key)
-            if value:
-                result[value] = result.get(value, 0) + 1
-        return result
-
-
-__all__ = ["TaskStatistics"]

active-runtime/app/task_store.py

@@ -1,29 +0,0 @@
-"""Persistent Task Center store."""
-
-from __future__ import annotations
-
-import json
-from pathlib import Path
-from typing import Any
-
-
-class TaskStore:
-    def __init__(self, root: str = "runtime/task-center"):
-        self.root = Path(root)
-        self.root.mkdir(parents=True, exist_ok=True)
-        self.path = self.root / "tasks.jsonl"
-
-    def append(self, task: dict[str, Any]) -> None:
-        with self.path.open("a", encoding="utf-8") as f:
-            f.write(json.dumps(task, ensure_ascii=False) + "\n")
-
-    def list_all(self) -> list[dict[str, Any]]:
-        if not self.path.exists():
-            return []
-        return [json.loads(line) for line in self.path.read_text(encoding="utf-8").splitlines() if line]
-
-    def latest(self) -> list[dict[str, Any]]:
-        return self.list_all()[-100:]
-
-
-__all__ = ["TaskStore"]

agents/ACKNOWLEDGEMENT.md

@@ -1,2 +0,0 @@
-# Agent Acknowledgement
-Initialized by CMD-20260708-fix-git-actions-write-and-enable-audit-plane

agents/commands/archive/CMD-20260708-fix-git-actions-write-and-enable-audit-plane.md

@@ -1,36 +0,0 @@
-# CMD-20260708-fix-git-actions-write-and-enable-audit-plane
-
-## Command ID
-CMD-20260708-fix-git-actions-write-and-enable-audit-plane
-
-## Priority
-P0
-
-## Mode
-autonomous
-
-## Target
-Primary: OpenClaw
-Supporting: Hermes
-Review: Codex
-
-## Objective
-解决当前 AIOS Git Actions 写权限问题，恢复 ChatGPT Actions → AIOS GitOps API → Git Commit 链路，
-同时建立 Agent 全生命周期审计体系。
-
-## Status
-- Part 1 (Fix Git Actions Write Permission): ✅ COMPLETE
-- Part 2 (Agent Command Plane Structure): ✅ COMPLETE
-- Part 3 (Agent Execution Audit): ✅ COMPLETE
-- Part 4 (Conversation Trace): 🚧 IN PROGRESS
-- Part 5 (Version Association): ⏳ PENDING
-- Part 6 (Web UI Integration): ⏳ PENDING
-- Part 7 (Evidence): ⏳ PENDING
-- Part 8 (Regression Test): ⏳ PENDING
-
-## Completion Criteria
-1. Code committed: agents/, audit/, evidence/, web-ui/
-2. Doc: docs/architecture/AIOS_AGENT_AUDIT_PLANE.md
-3. Report: evidence/CMD-20260708.../final-report.md
-4. Output: AIOS_AGENT_AUDIT_PLANE_READY, AIOS_GIT_ACTION_WRITE_READY
-5. Next command created: CMD-20260709-autonomous-controller-enable

agents/commands/archive/CMD-20260709-enable-autonomous-controller.md

@@ -1,35 +0,0 @@
-# CMD-20260709-enable-autonomous-controller
-
-## Command ID
-CMD-20260709-enable-autonomous-controller
-
-## Priority
-P0
-
-## Mode
-autonomous
-
-## Target
-Primary: OpenClaw
-Supporting: Hermes
-Review: Codex
-
-## Objective
-Enable autonomous controller for AIOS GitOps:
-- Auto-detect issues
-- Auto-diagnose
-- Auto-generate fixes
-- Auto-test
-- Auto-create patches
-- Auto-request approval
-
-## Preconditions
-- Agent Command Plane initialized (CMD-BOOTSTRAP-001)
-- Git Actions write permission fixed (CMD-20260708)
-- Audit plane enabled (CMD-20260708)
-- Notification service enabled (CMD-20260708)
-
-## Completion Criteria
-- Autonomous controller service running
-- Can detect, diagnose, fix, and report
-- Pipeline: detect → diagnose → fix → test → patch → approve → commit → notify

agents/commands/completed/CMD-20260708-fix-git-actions-write-and-enable-audit-plane.md

@@ -1,36 +0,0 @@
-# CMD-20260708-fix-git-actions-write-and-enable-audit-plane
-
-## Command ID
-CMD-20260708-fix-git-actions-write-and-enable-audit-plane
-
-## Priority
-P0
-
-## Mode
-autonomous
-
-## Target
-Primary: OpenClaw
-Supporting: Hermes
-Review: Codex
-
-## Objective
-解决当前 AIOS Git Actions 写权限问题，恢复 ChatGPT Actions → AIOS GitOps API → Git Commit 链路，
-同时建立 Agent 全生命周期审计体系。
-
-## Status
-- Part 1 (Fix Git Actions Write Permission): ✅ COMPLETE
-- Part 2 (Agent Command Plane Structure): ✅ COMPLETE
-- Part 3 (Agent Execution Audit): ✅ COMPLETE
-- Part 4 (Conversation Trace): 🚧 IN PROGRESS
-- Part 5 (Version Association): ⏳ PENDING
-- Part 6 (Web UI Integration): ⏳ PENDING
-- Part 7 (Evidence): ⏳ PENDING
-- Part 8 (Regression Test): ⏳ PENDING
-
-## Completion Criteria
-1. Code committed: agents/, audit/, evidence/, web-ui/
-2. Doc: docs/architecture/AIOS_AGENT_AUDIT_PLANE.md
-3. Report: evidence/CMD-20260708.../final-report.md
-4. Output: AIOS_AGENT_AUDIT_PLANE_READY, AIOS_GIT_ACTION_WRITE_READY
-5. Next command created: CMD-20260709-autonomous-controller-enable

agents/commands/completed/CMD-20260709-enable-autonomous-controller.md

@@ -1,35 +0,0 @@
-# CMD-20260709-enable-autonomous-controller
-
-## Command ID
-CMD-20260709-enable-autonomous-controller
-
-## Priority
-P0
-
-## Mode
-autonomous
-
-## Target
-Primary: OpenClaw
-Supporting: Hermes
-Review: Codex
-
-## Objective
-Enable autonomous controller for AIOS GitOps:
-- Auto-detect issues
-- Auto-diagnose
-- Auto-generate fixes
-- Auto-test
-- Auto-create patches
-- Auto-request approval
-
-## Preconditions
-- Agent Command Plane initialized (CMD-BOOTSTRAP-001)
-- Git Actions write permission fixed (CMD-20260708)
-- Audit plane enabled (CMD-20260708)
-- Notification service enabled (CMD-20260708)
-
-## Completion Criteria
-- Autonomous controller service running
-- Can detect, diagnose, fix, and report
-- Pipeline: detect → diagnose → fix → test → patch → approve → commit → notify

agents/notifications/archive/20260709-pr2-cleanup/n-1783527185.json

@@ -1,7 +0,0 @@
-{
-  "nid": "n-1783527185",
-  "title": "⚠️ Issue Detected: branch_sync",
-  "body": "10 branches missing from Gitea DB",
-  "urgency": "warning",
-  "ts": "2026-07-09T00:13:05+0800"
-}

agents/notifications/archive/20260709-pr2-cleanup/n-1783529900.json

@@ -1,7 +0,0 @@
-{
-  "nid": "n-1783529900",
-  "title": "⚠️ Issue Detected: branch_sync",
-  "body": "10 branches missing from Gitea DB",
-  "urgency": "warning",
-  "ts": "2026-07-09T00:58:20+0800"
-}

agents/notifications/archive/20260709-pr2-cleanup/n-1783529914.json

@@ -1,7 +0,0 @@
-{
-  "nid": "n-1783529914",
-  "title": "⚠️ Issue Detected: branch_sync",
-  "body": "10 branches missing from Gitea DB",
-  "urgency": "warning",
-  "ts": "2026-07-09T00:58:34+0800"
-}

agents/notifications/archive/20260709-pr2-cleanup/n-1783530514.json

@@ -1,7 +0,0 @@
-{
-  "nid": "n-1783530514",
-  "title": "⚠️ Issue Detected: branch_sync",
-  "body": "10 branches missing from Gitea DB",
-  "urgency": "warning",
-  "ts": "2026-07-09T01:08:34+0800"
-}

agents/notifications/archive/20260709-pr2-cleanup/n-1783531114.json

@@ -1,7 +0,0 @@
-{
-  "nid": "n-1783531114",
-  "title": "⚠️ Issue Detected: branch_sync",
-  "body": "10 branches missing from Gitea DB",
-  "urgency": "warning",
-  "ts": "2026-07-09T01:18:34+0800"
-}

agents/notifications/archive/20260709-pr2-cleanup/n-1783531714.json

@@ -1,7 +0,0 @@
-{
-  "nid": "n-1783531714",
-  "title": "⚠️ Issue Detected: branch_sync",
-  "body": "10 branches missing from Gitea DB",
-  "urgency": "warning",
-  "ts": "2026-07-09T01:28:34+0800"
-}

agents/notifications/archive/20260709-pr2-cleanup/n-1783532314.json

@@ -1,7 +0,0 @@
-{
-  "nid": "n-1783532314",
-  "title": "⚠️ Issue Detected: branch_sync",
-  "body": "10 branches missing from Gitea DB",
-  "urgency": "warning",
-  "ts": "2026-07-09T01:38:34+0800"
-}

agents/notifications/archive/20260709-pr2-cleanup/n-1783532914.json

@@ -1,7 +0,0 @@
-{
-  "nid": "n-1783532914",
-  "title": "⚠️ Issue Detected: branch_sync",
-  "body": "10 branches missing from Gitea DB",
-  "urgency": "warning",
-  "ts": "2026-07-09T01:48:34+0800"
-}

agents/notifications/archive/20260709-pr2-cleanup/n-1783533514.json

@@ -1,7 +0,0 @@
-{
-  "nid": "n-1783533514",
-  "title": "⚠️ Issue Detected: branch_sync",
-  "body": "10 branches missing from Gitea DB",
-  "urgency": "warning",
-  "ts": "2026-07-09T01:58:34+0800"
-}

agents/notifications/archive/20260709-pr2-cleanup/n-1783534114.json

@@ -1,7 +0,0 @@
-{
-  "nid": "n-1783534114",
-  "title": "⚠️ Issue Detected: branch_sync",
-  "body": "10 branches missing from Gitea DB",
-  "urgency": "warning",
-  "ts": "2026-07-09T02:08:34+0800"
-}

agents/patches/archive/20260709-pr2-cleanup/patch-1783527185.json

@@ -1,16 +0,0 @@
-{
-  "patch_id": "patch-1783527185",
-  "created": "2026-07-09T00:13:05+0800",
-  "check": "branch_sync",
-  "severity": "high",
-  "diagnosis": "10 branches missing from Gitea DB",
-  "branches": [
-    "patch/agent-event-bus-unified",
-    "test/alias-write-verify",
-    "patch/V1R2C3-tag-execute-idempotent-permission",
-    "patch/gitops-write-auth-smoke-20260706T115230Z",
-    "patch/gpt-actions-auth-live-20260708"
-  ],
-  "stuck": [],
-  "fix": "sync_branches"
-}

agents/patches/archive/20260709-pr2-cleanup/patch-1783529900.json

@@ -1,16 +0,0 @@
-{
-  "patch_id": "patch-1783529900",
-  "created": "2026-07-09T00:58:20+0800",
-  "check": "branch_sync",
-  "severity": "high",
-  "diagnosis": "10 branches missing from Gitea DB",
-  "branches": [
-    "test/alias-test-file-branch",
-    "patch/codex-online-sync-acceptance-20260706T102819Z",
-    "patch/V1R2C3-tag-execute-idempotent-permission",
-    "patch/actions-invalid-diag-smoke-20260706T140311Z",
-    "patch/V1R2C2-autonomous-recovery-loop"
-  ],
-  "stuck": [],
-  "fix": "sync_branches"
-}

agents/patches/archive/20260709-pr2-cleanup/patch-1783529914.json

@@ -1,16 +0,0 @@
-{
-  "patch_id": "patch-1783529914",
-  "created": "2026-07-09T00:58:34+0800",
-  "check": "branch_sync",
-  "severity": "high",
-  "diagnosis": "10 branches missing from Gitea DB",
-  "branches": [
-    "patch/codex-write-auth-smoke-20260706T115256Z",
-    "patch/v1r3c0-user-portal-rbac-ops-20260708",
-    "request/tag-V1R3C0-self-loop-autonomous-engine",
-    "patch/fix-tag-confirmation-state-machine",
-    "patch/gitops-write-auth-fix"
-  ],
-  "stuck": [],
-  "fix": "sync_branches"
-}

agents/patches/archive/20260709-pr2-cleanup/patch-1783530514.json

@@ -1,16 +0,0 @@
-{
-  "patch_id": "patch-1783530514",
-  "created": "2026-07-09T01:08:34+0800",
-  "check": "branch_sync",
-  "severity": "high",
-  "diagnosis": "10 branches missing from Gitea DB",
-  "branches": [
-    "patch/codex-write-auth-smoke-20260706T115256Z",
-    "patch/v1r3c0-user-portal-rbac-ops-20260708",
-    "request/tag-V1R3C0-self-loop-autonomous-engine",
-    "patch/fix-tag-confirmation-state-machine",
-    "patch/gitops-write-auth-fix"
-  ],
-  "stuck": [],
-  "fix": "sync_branches"
-}

agents/patches/archive/20260709-pr2-cleanup/patch-1783531114.json

@@ -1,16 +0,0 @@
-{
-  "patch_id": "patch-1783531114",
-  "created": "2026-07-09T01:18:34+0800",
-  "check": "branch_sync",
-  "severity": "high",
-  "diagnosis": "10 branches missing from Gitea DB",
-  "branches": [
-    "patch/codex-write-auth-smoke-20260706T115256Z",
-    "patch/v1r3c0-user-portal-rbac-ops-20260708",
-    "request/tag-V1R3C0-self-loop-autonomous-engine",
-    "patch/fix-tag-confirmation-state-machine",
-    "patch/gitops-write-auth-fix"
-  ],
-  "stuck": [],
-  "fix": "sync_branches"
-}

agents/patches/archive/20260709-pr2-cleanup/patch-1783531714.json

@@ -1,16 +0,0 @@
-{
-  "patch_id": "patch-1783531714",
-  "created": "2026-07-09T01:28:34+0800",
-  "check": "branch_sync",
-  "severity": "high",
-  "diagnosis": "10 branches missing from Gitea DB",
-  "branches": [
-    "patch/codex-write-auth-smoke-20260706T115256Z",
-    "patch/v1r3c0-user-portal-rbac-ops-20260708",
-    "request/tag-V1R3C0-self-loop-autonomous-engine",
-    "patch/fix-tag-confirmation-state-machine",
-    "patch/gitops-write-auth-fix"
-  ],
-  "stuck": [],
-  "fix": "sync_branches"
-}

agents/patches/archive/20260709-pr2-cleanup/patch-1783532314.json

@@ -1,16 +0,0 @@
-{
-  "patch_id": "patch-1783532314",
-  "created": "2026-07-09T01:38:34+0800",
-  "check": "branch_sync",
-  "severity": "high",
-  "diagnosis": "10 branches missing from Gitea DB",
-  "branches": [
-    "patch/codex-write-auth-smoke-20260706T115256Z",
-    "patch/v1r3c0-user-portal-rbac-ops-20260708",
-    "request/tag-V1R3C0-self-loop-autonomous-engine",
-    "patch/fix-tag-confirmation-state-machine",
-    "patch/gitops-write-auth-fix"
-  ],
-  "stuck": [],
-  "fix": "sync_branches"
-}

agents/patches/archive/20260709-pr2-cleanup/patch-1783532914.json

@@ -1,16 +0,0 @@
-{
-  "patch_id": "patch-1783532914",
-  "created": "2026-07-09T01:48:34+0800",
-  "check": "branch_sync",
-  "severity": "high",
-  "diagnosis": "10 branches missing from Gitea DB",
-  "branches": [
-    "patch/codex-write-auth-smoke-20260706T115256Z",
-    "patch/v1r3c0-user-portal-rbac-ops-20260708",
-    "request/tag-V1R3C0-self-loop-autonomous-engine",
-    "patch/fix-tag-confirmation-state-machine",
-    "patch/gitops-write-auth-fix"
-  ],
-  "stuck": [],
-  "fix": "sync_branches"
-}

agents/patches/archive/20260709-pr2-cleanup/patch-1783533514.json

@@ -1,16 +0,0 @@
-{
-  "patch_id": "patch-1783533514",
-  "created": "2026-07-09T01:58:34+0800",
-  "check": "branch_sync",
-  "severity": "high",
-  "diagnosis": "10 branches missing from Gitea DB",
-  "branches": [
-    "patch/codex-write-auth-smoke-20260706T115256Z",
-    "patch/v1r3c0-user-portal-rbac-ops-20260708",
-    "request/tag-V1R3C0-self-loop-autonomous-engine",
-    "patch/fix-tag-confirmation-state-machine",
-    "patch/gitops-write-auth-fix"
-  ],
-  "stuck": [],
-  "fix": "sync_branches"
-}

agents/patches/archive/20260709-pr2-cleanup/patch-1783534114.json

@@ -1,16 +0,0 @@
-{
-  "patch_id": "patch-1783534114",
-  "created": "2026-07-09T02:08:34+0800",
-  "check": "branch_sync",
-  "severity": "high",
-  "diagnosis": "10 branches missing from Gitea DB",
-  "branches": [
-    "patch/codex-write-auth-smoke-20260706T115256Z",
-    "patch/v1r3c0-user-portal-rbac-ops-20260708",
-    "request/tag-V1R3C0-self-loop-autonomous-engine",
-    "patch/fix-tag-confirmation-state-machine",
-    "patch/gitops-write-auth-fix"
-  ],
-  "stuck": [],
-  "fix": "sync_branches"
-}

agents/policies/README.md

@@ -1,2 +0,0 @@
-# AIOS Agent Policies
-Policies for AIOS Git Agent execution.

agents/registry.yaml

@@ -1,67 +0,0 @@
-<<<<<<< HEAD
-# AIOS Agent Command Plane Registry
-# Git is the single source of truth for all agent commands.
-version: 1.0.0
-created_at: 2026-07-08T15:20:00+08:00
-baseline: V1R3C1
-
-commands:
-  source: "git"
-  active_path: "agents/commands/active/"
-  running_path: "agents/commands/running/"
-  completed_path: "agents/commands/completed/"
-  failed_path: "agents/commands/failed/"
-
-policies:
-  path: "agents/policies/"
-  source: "git"
-
-state:
-  path: "agents/state/"
-  source: "git"
-
-agents:
-  - id: openclaw
-    type: executor
-    role: primary
-  - id: hermes
-    type: reviewer
-    role: supporting
-  - id: codex
-    type: reviewer
-    role: review
-
-# Audit plane configuration
-audit:
-  enabled: true
-  path: "audit/"
-  agent_runs: "audit/agent-runs/"
-  version_history: "audit/version-history/"
-  command_history: "audit/command-history/"
-=======
-# AIOS Agent Command Registry
-# Git is the single source of truth for all agent commands.
-
-registry_version: 1.0.0
-created_at: "2026-07-08T15:44:00+08:00"
-baseline: V1R3C1
-
-directories:
-  commands/active:    "New commands pending execution — Git is the only entry point"
-  commands/running:   "Commands currently being executed by an agent"
-  commands/completed: "Commands that finished successfully — moved here on success"
-  commands/failed:    "Commands that finished with errors — moved here on failure"
-
-state: agents/state/
-policies: agents/policies/
-
-lifecycle:
-  new:     active/
-  running: running/
-  success: completed/
-  failure: failed/
-
-# Command lifecycle state machine:
-# active/ → locked & moved to running/ → execute → success → completed/
-#                                                          → failure → failed/
->>>>>>> 4d18ee0 (feat(cmd): enable Agent Command Plane, audit plane, and Web UI dashboard)

agents/scripts/V1R4C0-test.owner-approved.json

@@ -1 +0,0 @@
-{"owner_approved": true, "version": "V1R4C0-test"}

agents/scripts/agent-command-watcher.py

@@ -1,170 +0,0 @@
-#!/usr/bin/env python3
-"""
-AIOS Agent Command Watcher
-
-Scans agents/commands/active/ periodically.
-Dispatches new .md commands to the AIOS agent runtime.
-Supports: restart recovery, retry, dedup, state persistence.
-
-Runs as a standalone HTTP service or polling loop.
-"""
-
-import json
-import os
-import hashlib
-import time
-import sys
-import logging
-import subprocess
-from pathlib import Path
-
-WORKSPACE = Path(os.environ.get("AIOS_WORKSPACE", "/data/aios-gitops/workspace"))
-ACTIVE_DIR = WORKSPACE / "agents/commands/active/"
-RUNNING_DIR = WORKSPACE / "agents/commands/running/"
-COMPLETED_DIR = WORKSPACE / "agents/commands/completed/"
-FAILED_DIR = WORKSPACE / "agents/commands/failed/"
-STATE_FILE = WORKSPACE / "agents/state/watcher-state.json"
-AUDIT_DIR = WORKSPACE / "audit/agent-runs/"
-POLL_INTERVAL = int(os.environ.get("POLL_INTERVAL_SECONDS", "300"))
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [watcher] %(levelname)s %(message)s",
-    datefmt="%Y-%m-%dT%H:%M:%S%z",
-)
-log = logging.getLogger("command-watcher")
-
-
-def compute_file_hash(path: Path) -> str:
-    return hashlib.sha256(path.read_bytes()).hexdigest()
-
-
-def load_state() -> dict:
-    if STATE_FILE.exists():
-        try:
-            return json.loads(STATE_FILE.read_text())
-        except (json.JSONDecodeError, OSError):
-            pass
-    return {"processed": {}, "last_scan": None}
-
-
-def save_state(state: dict):
-    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
-    STATE_FILE.write_text(json.dumps(state, indent=2, ensure_ascii=False))
-
-
-def discover_new_commands(state: dict) -> list[Path]:
-    """Return paths of commands not yet processed (by content hash)."""
-    if not ACTIVE_DIR.exists():
-        return []
-    new_cmds = []
-    for cmd_file in sorted(ACTIVE_DIR.iterdir()):
-        if not cmd_file.name.endswith(".md"):
-            continue
-        fhash = compute_file_hash(cmd_file)
-        prev = state["processed"].get(cmd_file.name)
-        if prev and prev["hash"] == fhash and prev.get("status") in ("completed", "running"):
-            continue
-        new_cmds.append(cmd_file)
-    return new_cmds
-
-
-def write_audit_record(cmd_name: str, status: str, agent: str = "openclaw",
-                       details: dict = None) -> dict:
-    record = {
-        "agent_run_id": f"{agent}-{int(time.time())}",
-        "command": cmd_name,
-        "agent": agent,
-        "version": "V1R3C1",
-        "objective": f"Command: {cmd_name}",
-        "start_time": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
-        "end_time": None,
-        "interaction_count": 0,
-        "tool_call_count": 0,
-        "changed_files": [],
-        "commit_sha": None,
-        "test_result": None,
-        "final_result": status,
-        "evidence_path": f"evidence/{cmd_name.replace('.md', '')}/",
-        **(details or {}),
-    }
-    AUDIT_DIR.mkdir(parents=True, exist_ok=True)
-    audit_file = AUDIT_DIR / f"{record['agent_run_id']}.json"
-    audit_file.write_text(json.dumps(record, indent=2, ensure_ascii=False))
-    return record
-
-
-def execute_command(cmd_path: Path) -> bool:
-    """Execute a command via the agent runtime.
-    
-    Move the command to running/ first, then trigger execution.
-    For now, this marks the command lifecycle. Actual execution
-    is handled by the main agent session.
-    """
-    cmd_name = cmd_path.name
-    target = RUNNING_DIR / cmd_name
-    
-    # Move to running
-    log.info(f"Moving {cmd_name} → running/")
-    cmd_path.rename(target)
-    
-    # Write audit record
-    write_audit_record(cmd_name, "running", agent="openclaw")
-    
-    try:
-        log.info(f"Executing {cmd_name} via agent runtime...")
-        # The actual execution happens in the main agent session.
-        # This watcher ensures lifecycle management.
-        return True
-    except Exception as e:
-        log.error(f"Execution failed for {cmd_name}: {e}")
-        (RUNNING_DIR / cmd_name).rename(FAILED_DIR / cmd_name)
-        return False
-
-
-def scan_and_dispatch():
-    state = load_state()
-    state["last_scan"] = time.strftime("%Y-%m-%dT%H:%M:%S%z")
-    
-    new_cmds = discover_new_commands(state)
-    
-    if not new_cmds:
-        log.debug("No new commands found.")
-        save_state(state)
-        return
-    
-    for cmd_path in new_cmds:
-        cmd_name = cmd_path.name
-        log.info(f"Discovered new command: {cmd_name}")
-        state["processed"][cmd_name] = {
-            "hash": compute_file_hash(cmd_path),
-            "status": "discovered",
-            "discovered_at": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
-        }
-        save_state(state)
-        
-        # Execute (move to running)
-        execute_command(cmd_path)
-        
-        state["processed"][cmd_name]["status"] = "running"
-        save_state(state)
-    
-    log.info(f"Dispatched {len(new_cmds)} command(s)")
-
-
-def run_forever():
-    log.info(f"Command Watcher started. Poll interval: {POLL_INTERVAL}s")
-    log.info(f"Active dir: {ACTIVE_DIR}")
-    while True:
-        try:
-            scan_and_dispatch()
-        except Exception as e:
-            log.exception(f"Scan error: {e}")
-        time.sleep(POLL_INTERVAL)
-
-
-if __name__ == "__main__":
-    if len(sys.argv) > 1 and sys.argv[1] == "--once":
-        scan_and_dispatch()
-    else:
-        run_forever()

agents/scripts/autonomous_controller.py

@@ -1,240 +0,0 @@
-#!/usr/bin/env python3
-"""
-AIOS Autonomous Controller — Full Pipeline v2.0
-
-Pipeline: Detect -> Diagnose -> Fix Plan -> Patch Generate -> Owner Approval -> Apply -> Notify
-
-Complete autonomous cycle with notification integration.
-"""
-
-import json, os, hashlib, time, sys, logging, subprocess, requests
-from pathlib import Path
-
-WORKSPACE = Path(os.environ.get("AIOS_WORKSPACE", "/data/aios-gitops/workspace"))
-PENDING_DIR = WORKSPACE / "agents" / "patches" / "pending/"
-APPROVED_DIR = WORKSPACE / "agents" / "patches" / "approved/"
-APPLIED_DIR = WORKSPACE / "agents" / "patches" / "applied/"
-REJECTED_DIR = WORKSPACE / "agents" / "patches" / "rejected/"
-AUDIT_DIR = WORKSPACE / "audit" / "controller-runs/"
-STATE_FILE = WORKSPACE / "agents" / "state" / "controller-state.json"
-HEALTH_FILE = WORKSPACE / "agents" / "state" / "health.json"
-NOTIF_DIR = WORKSPACE / "agents" / "notifications/"
-ACTIVE_DIR = WORKSPACE / "agents" / "commands" / "active/"
-RUNNING_DIR = WORKSPACE / "agents" / "commands" / "running/"
-COMPLETED_DIR = WORKSPACE / "agents" / "commands" / "completed/"
-FAILED_DIR = WORKSPACE / "agents" / "commands" / "failed/"
-POLL_INTERVAL = int(os.environ.get("CONTROLLER_POLL_INTERVAL_SECONDS", "600"))
-GITEA_URL = os.environ.get("GITEA_URL", "http://127.0.0.1:3000")
-API_URL = os.environ.get("AIOS_API_URL", "http://127.0.0.1:18890")
-GITEA_TOKEN = os.environ.get("GITEA_TOKEN", "")
-
-logging.basicConfig(level=logging.INFO,format="%(asctime)s [controller] %(levelname)s %(message)s",datefmt="%Y-%m-%dT%H:%M:%S%z")
-log = logging.getLogger("autonomous-controller")
-CONTROLLER_VERSION = "2.0.0"
-
-
-def load_state():
-    if STATE_FILE.exists():
-        try: return json.loads(STATE_FILE.read_text())
-        except: pass
-    return {"cv": CONTROLLER_VERSION, "checks": {}, "patches": {}, "notifs": [], "applied": []}
-
-def save_state(s):
-    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
-    STATE_FILE.write_text(json.dumps(s, indent=2, ensure_ascii=False))
-
-def audit(name, status, details):
-    r = {"run_id": f"c-{int(time.time())}", "check": name, "status": status,
-         "ts": time.strftime("%Y-%m-%dT%H:%M:%S%z"), "details": details}
-    AUDIT_DIR.mkdir(parents=True, exist_ok=True)
-    (AUDIT_DIR / f"{r['run_id']}.json").write_text(json.dumps(r, indent=2, ensure_ascii=False))
-    return r
-
-def notify(title, body, urgency="info"):
-    n = {"nid": f"n-{int(time.time())}", "title": title, "body": body, "urgency": urgency,
-         "ts": time.strftime("%Y-%m-%dT%H:%M:%S%z")}
-    NOTIF_DIR.mkdir(parents=True, exist_ok=True)
-    (NOTIF_DIR / f"{n['nid']}.json").write_text(json.dumps(n, indent=2, ensure_ascii=False))
-    log.info(f"NOTIF: {n['nid']} -> {title}")
-    return n
-
-# === Health Checks ===
-
-def h_gitea():
-    try:
-        r = requests.get(f"{GITEA_URL}/api/v1/version", timeout=5)
-        return {"ok": r.status_code == 200, "data": r.json() if r.status_code == 200 else None, "err": None if r.status_code == 200 else f"HTTP {r.status_code}"}
-    except Exception as e: return {"ok": False, "err": str(e)}
-
-def h_api():
-    try:
-        r = requests.get(f"{API_URL}/admin/ai-evolution/api/data", timeout=5)
-        if r.status_code == 200:
-            d = r.json(); b = d.get("baseline","?"); v = len(d.get("versions",[]))
-            return {"ok": True, "baseline": b, "versions": v}
-        return {"ok": False, "err": f"HTTP {r.status_code}"}
-    except Exception as e: return {"ok": False, "err": str(e)}
-
-def h_branch_sync():
-    bare = Path("/data/aios-gitops/runtime/gitea-bin/data/repositories/aios/aios-v23.git")
-    try:
-        r = subprocess.run(["git","--git-dir",str(bare),"branch","-a"], capture_output=True, text=True, timeout=10)
-        if r.returncode != 0: return {"ok": False, "err": r.stderr[:200]}
-        bb = set(l.strip().replace("remotes/origin/","").replace("* ","") for l in r.stdout.strip().split("\n") if l.strip())
-        gb = []; pg = 1
-        while True:
-            r2 = requests.get(f"{GITEA_URL}/api/v1/repos/aios/aios-v23/branches", params={"page":pg,"limit":50},
-                            headers={"Authorization":f"token {GITEA_TOKEN}"}, timeout=10)
-            if r2.status_code != 200: break
-            d = r2.json()
-            if not d: break
-            gb.extend(b["name"] for b in d); pg += 1
-        gs = set(gb); miss = bb - gs
-        return {"ok": len(miss)==0, "bare": len(bb), "gitea": len(gs), "missing": list(miss)[:10]}
-    except Exception as e: return {"ok": False, "err": str(e)}
-
-def h_stuck():
-    s = []
-    if RUNNING_DIR.exists():
-        n = time.time()
-        for c in RUNNING_DIR.iterdir():
-            if c.name.endswith(".md"):
-                a = (n - c.stat().st_mtime) / 60
-                if a > 30: s.append({"n": c.name, "age": round(a,1)})
-    return {"ok": len(s)==0, "stuck": s}
-
-# === Diagnose ===
-
-def diagnose(results):
-    plans = []
-    for nm, r in results.items():
-        if r.get("ok", True): continue
-        if nm == "branch_sync":
-            m = r.get("missing",[])
-            if m:
-                plans.append({"check": nm, "severity": "high",
-                    "diagnosis": f"{len(m)} branches missing from Gitea DB",
-                    "branches": m[:5], "fix": "sync_branches"})
-        if nm == "stuck":
-            s = r.get("stuck",[])
-            if s:
-                plans.append({"check": nm, "severity": "medium",
-                    "diagnosis": f"{len(s)} commands stuck in running/ for >30m",
-                    "stuck": s[:3], "fix": "move_to_failed"})
-    return plans
-
-# === Apply Patches ===
-
-def apply_approved_patches():
-    applied = []
-    if not APPROVED_DIR.exists(): return applied
-    for f in sorted(APPROVED_DIR.iterdir()):
-        if not f.name.endswith(".json"): continue
-        try:
-            patch = json.loads(f.read_text())
-            fix = patch.get("fix", "")
-            log.info(f"Applying approved patch: {patch.get('check','?')} -> {fix}")
-            if fix == "sync_branches":
-                branches = patch.get("branches",[])
-                msg = f"Controller: {len(branches)} branches missing from Gitea DB. Patching via agent."
-                notify("Branch Sync Patch Applied", msg, "info")
-                # Move to applied
-                APPLIED_DIR.mkdir(parents=True, exist_ok=True)
-                f.rename(APPLIED_DIR / f.name)
-                applied.append(patch)
-            elif fix == "move_to_failed":
-                stuck = patch.get("stuck",[])
-                for s in stuck:
-                    src = RUNNING_DIR / s.get("n","")
-                    if src.exists(): src.rename(FAILED_DIR / src.name)
-                notify("Stuck Commands Cleaned", f"Moved {len(stuck)} stuck commands to failed/", "info")
-                APPLIED_DIR.mkdir(parents=True, exist_ok=True)
-                f.rename(APPLIED_DIR / f.name)
-                applied.append(patch)
-        except Exception as e:
-            log.exception(f"Failed applying {f.name}: {e}")
-            REJECTED_DIR.mkdir(parents=True, exist_ok=True)
-            f.rename(REJECTED_DIR / f.name)
-    return applied
-
-# === Main Cycle ===
-
-def run_cycle():
-    log.info("--- Cycle start ---")
-    results = {}
-
-    log.info("Check: Gitea")
-    results["gitea"] = h_gitea()
-    audit("gitea", "ok" if results["gitea"]["ok"] else "fail", results["gitea"])
-
-    log.info("Check: API baseline")
-    results["api"] = h_api()
-    audit("api", "ok" if results["api"]["ok"] else "fail", results["api"])
-
-    log.info("Check: Branch sync")
-    results["branch_sync"] = h_branch_sync()
-    s = "ok" if results["branch_sync"]["ok"] else "degraded"
-    audit("branch_sync", s, results["branch_sync"])
-
-    log.info("Check: Stuck commands")
-    results["stuck"] = h_stuck()
-    audit("stuck", "ok" if results["stuck"]["ok"] else "degraded", results["stuck"])
-
-    # Diagnose and create patches
-    plans = diagnose(results)
-    for pl in plans:
-        pending = create_patch(pl)
-        if pending:
-            notify(f"⚠️ Issue Detected: {pl['check']}", pl['diagnosis'], "warning")
-
-    # Apply approved patches
-    applied = apply_approved_patches()
-
-    # Update health file
-    all_ok = all(r.get("ok",False) for r in results.values())
-    summary = {
-        "ts": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
-        "ok": all_ok, "checks": {k:v.get("ok") for k,v in results.items()},
-        "plans": len(plans), "applied": len(applied)
-    }
-    HEALTH_FILE.parent.mkdir(parents=True, exist_ok=True)
-    HEALTH_FILE.write_text(json.dumps(summary, indent=2, ensure_ascii=False))
-    log.info(f"Cycle done. All healthy: {all_ok}. Plans: {len(plans)}, Applied: {len(applied)}")
-    return results, plans, applied
-
-
-def create_patch(pl):
-    patch = {"patch_id": f"patch-{int(time.time())}", "created": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
-             "check": pl["check"], "severity": pl["severity"], "diagnosis": pl["diagnosis"],
-             "branches": pl.get("branches",[]), "stuck": pl.get("stuck",[]), "fix": pl.get("fix","")}
-    PENDING_DIR.mkdir(parents=True, exist_ok=True)
-    f = PENDING_DIR / f"{patch['patch_id']}.json"
-    if f.exists(): return False
-    f.write_text(json.dumps(patch, indent=2, ensure_ascii=False))
-    log.info(f"Patch created: {patch['patch_id']}")
-    return True
-
-
-def run_forever():
-    log.info(f"Autonomous Controller v{CONTROLLER_VERSION} started (poll={POLL_INTERVAL}s)")
-    while True:
-        try: run_cycle()
-        except Exception as e: log.exception(f"Cycle failed: {e}")
-        time.sleep(POLL_INTERVAL)
-
-
-def run_once():
-    log.info("One-shot check")
-    results, plans, applied = run_cycle()
-    for n, r in results.items():
-        st = "OK" if r.get("ok") else "FAIL"
-        log.info(f"  [{st}] {n}")
-    if plans: log.info(f"Patches created: {len(plans)}")
-    if applied: log.info(f"Patches applied: {len(applied)}")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) > 1 and sys.argv[1] == "--once":
-        run_once()
-    else:
-        run_forever()

agents/scripts/autonomous_controller.py.v1

@@ -1,328 +0,0 @@
-#!/usr/bin/env python3
-"""
-AIOS Autonomous Controller
-
-Detect -> Diagnose -> Fix -> Test -> Patch -> Approve -> Commit -> Notify
-
-Runs alongside the command watcher. Checks system health periodically.
-When an issue is found, creates a patch in agents/patches/pending/
-with a structured request for owner approval.
-"""
-
-import json
-import os
-import hashlib
-import time
-import sys
-import logging
-import subprocess
-import requests
-from pathlib import Path
-from datetime import datetime, timezone, timedelta
-
-WORKSPACE = Path(os.environ.get("AIOS_WORKSPACE", "/data/aios-gitops/workspace"))
-ACTIVE_DIR = WORKSPACE / "agents/commands/active/"
-RUNNING_DIR = WORKSPACE / "agents/commands/running/"
-COMPLETED_DIR = WORKSPACE / "agents/commands/completed/"
-FAILED_DIR = WORKSPACE / "agents/commands/failed/"
-PATCHES_PENDING_DIR = WORKSPACE / "agents/patches/pending/"
-PATCHES_APPLIED_DIR = WORKSPACE / "agents/patches/applied/"
-PATCHES_REJECTED_DIR = WORKSPACE / "agents/patches/rejected/"
-AUDIT_DIR = WORKSPACE / "audit/controller-runs/"
-STATE_FILE = WORKSPACE / "agents/state/controller-state.json"
-HEALTH_FILE = WORKSPACE / "agents/state/health.json"
-POLL_INTERVAL = int(os.environ.get("CONTROLLER_POLL_INTERVAL_SECONDS", "300"))
-GITEA_URL = os.environ.get("GITEA_URL", "http://127.0.0.1:3000")
-API_URL = os.environ.get("AIOS_API_URL", "http://127.0.0.1:18890")
-GITEA_TOKEN = os.environ.get("GITEA_TOKEN", "")
-
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s [controller] %(levelname)s %(message)s",
-    datefmt="%Y-%m-%dT%H:%M:%S%z",
-)
-log = logging.getLogger("autonomous-controller")
-
-CONTROLLER_VERSION = "1.0.0"
-
-
-def load_state():
-    if STATE_FILE.exists():
-        try:
-            return json.loads(STATE_FILE.read_text())
-        except (json.JSONDecodeError, OSError):
-            pass
-    return {"controller_version": CONTROLLER_VERSION, "checks": {}, "patches": {}}
-
-
-def save_state(state):
-    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
-    STATE_FILE.write_text(json.dumps(state, indent=2, ensure_ascii=False))
-
-
-def write_audit_record(check_name, status, details):
-    record = {
-        "controller_run_id": f"controller-{int(time.time())}",
-        "check": check_name,
-        "status": status,
-        "controller_version": CONTROLLER_VERSION,
-        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
-        "details": details,
-    }
-    AUDIT_DIR.mkdir(parents=True, exist_ok=True)
-    af = AUDIT_DIR / f"{record['controller_run_id']}.json"
-    af.write_text(json.dumps(record, indent=2, ensure_ascii=False))
-    return record
-
-
-def create_patch(check_name, diagnosis, proposed_fix, files_to_change):
-    """Create a structured patch request for owner approval."""
-    patch_id = f"patch-{int(time.time())}"
-    patch = {
-        "patch_id": patch_id,
-        "check": check_name,
-        "diagnosis": diagnosis,
-        "proposed_fix": proposed_fix,
-        "files_to_change": files_to_change,
-        "created_at": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
-        "status": "pending",
-        "approved": False,
-        "applied": False,
-    }
-    PATCHES_PENDING_DIR.mkdir(parents=True, exist_ok=True)
-    pf = PATCHES_PENDING_DIR / f"{patch_id}.json"
-    pf.write_text(json.dumps(patch, indent=2, ensure_ascii=False))
-    log.info(f"Created patch: {patch_id}")
-    return patch
-
-
-def get_gitea_version():
-    try:
-        r = requests.get(f"{GITEA_URL}/api/v1/version", timeout=5)
-        if r.status_code == 200:
-            return {"healthy": True, "data": r.json()}
-        return {"healthy": False, "error": f"HTTP {r.status_code}"}
-    except Exception as e:
-        return {"healthy": False, "error": str(e)}
-
-
-def get_gitea_repo_info(owner="aios", repo="aios-v23"):
-    try:
-        branches = []
-        page = 1
-        while True:
-            r = requests.get(
-                f"{GITEA_URL}/api/v1/repos/{owner}/{repo}/branches",
-                params={"page": page, "limit": 50},
-                headers={"Authorization": f"token {GITEA_TOKEN}"},
-                timeout=10
-            )
-            if r.status_code != 200:
-                break
-            data = r.json()
-            if not data:
-                break
-            branches.extend(data)
-            page += 1
-        tags = []
-        page = 1
-        while True:
-            r = requests.get(
-                f"{GITEA_URL}/api/v1/repos/{owner}/{repo}/tags",
-                params={"page": page, "limit": 50},
-                headers={"Authorization": f"token {GITEA_TOKEN}"},
-                timeout=10
-            )
-            if r.status_code != 200:
-                break
-            data = r.json()
-            if not data:
-                break
-            tags.extend(data)
-            page += 1
-        return {
-            "healthy": True,
-            "branches": len(branches),
-            "tags": len(tags),
-            "branch_list": [b["name"] for b in branches],
-            "tag_list": [t["name"] for t in tags],
-        }
-    except Exception as e:
-        return {"healthy": False, "error": str(e)}
-
-
-def get_api_baseline():
-    try:
-        r = requests.get(f"{API_URL}/admin/ai-evolution/api/data", timeout=5)
-        if r.status_code == 200:
-            data = r.json()
-            return {"healthy": True, "baseline": data.get("baseline")}
-        return {"healthy": False, "error": f"HTTP {r.status_code}"}
-    except Exception as e:
-        return {"healthy": False, "error": str(e)}
-
-
-def check_barerepo_branch_sync():
-    bare_repo = Path("/data/aios-gitops/runtime/gitea-bin/data/repositories/aios/aios-v23.git")
-    try:
-        result = subprocess.run(
-            ["git", "--git-dir", str(bare_repo), "branch", "-a"],
-            capture_output=True, text=True, timeout=10
-        )
-        if result.returncode != 0:
-            return {"healthy": False, "error": result.stderr[:200]}
-        bare_branches = [
-            l.strip().replace("remotes/origin/", "").replace("* ", "")
-            for l in result.stdout.strip().split("\n") if l.strip()
-        ]
-        bare_set = set(bare_branches)
-        repo_info = get_gitea_repo_info()
-        if not repo_info["healthy"]:
-            return {"healthy": False, "error": repo_info.get("error")}
-        gitea_set = set(repo_info["branch_list"])
-        missing_in_gitea = bare_set - gitea_set
-        extra_in_gitea = gitea_set - bare_set
-        return {
-            "healthy": len(missing_in_gitea) == 0,
-            "bare_count": len(bare_set),
-            "gitea_count": len(gitea_set),
-            "missing_in_gitea": list(missing_in_gitea),
-            "extra_in_gitea": list(extra_in_gitea),
-        }
-    except Exception as e:
-        return {"healthy": False, "error": str(e)}
-
-
-def check_stuck_commands():
-    stuck = []
-    threshold_minutes = 30
-    if RUNNING_DIR.exists():
-        now = time.time()
-        for cmd_file in RUNNING_DIR.iterdir():
-            if cmd_file.name.endswith(".md"):
-                mtime = cmd_file.stat().st_mtime
-                age_minutes = (now - mtime) / 60
-                if age_minutes > threshold_minutes:
-                    stuck.append({
-                        "name": cmd_file.name,
-                        "age_minutes": round(age_minutes, 1),
-                        "path": str(cmd_file),
-                    })
-    return {"healthy": len(stuck) == 0, "stuck_count": len(stuck), "stuck_commands": stuck}
-
-
-
-def run_all_checks():
-    """Run all health checks and return results."""
-    state = load_state()
-    results = {}
-    patches_created = []
-    
-    # 1. Gitea version
-    log.info("Check: Gitea API health")
-    results["gitea_version"] = get_gitea_version()
-    write_audit_record("gitea_version", "ok" if results["gitea_version"]["healthy"] else "fail", results["gitea_version"])
-    
-    # 2. API baseline
-    log.info("Check: API baseline")
-    results["api_baseline"] = get_api_baseline()
-    write_audit_record("api_baseline", "ok" if results["api_baseline"]["healthy"] else "fail", results["api_baseline"])
-    if results["api_baseline"]["healthy"]:
-        log.info(f"  Baseline: {results['api_baseline'].get('baseline')}")
-    
-    # 3. Bare repo branch sync
-    log.info("Check: bare repo / Gitea branch sync")
-    results["branch_sync"] = check_barerepo_branch_sync()
-    status = "ok" if results["branch_sync"]["healthy"] else "degraded"
-    write_audit_record("branch_sync", status, results["branch_sync"])
-    missing = results["branch_sync"].get("missing_in_gitea", [])
-    if missing:
-        log.warning(f"  {len(missing)} branches missing in Gitea DB")
-        for b in missing:
-            log.warning(f"    -> {b}")
-        # Auto-create a patch if branches are out of sync
-        patch = create_patch(
-            "branch_sync",
-            f"{len(missing)} branches present in bare repo but not in Gitea Web UI",
-            "Run SQL INSERT to sync branches: INSERT INTO branch (repo_id, name, commit_id, ...) "
-            "for each missing branch. Verify with bare repo SHA.",
-            ["runtime/gitea-bin/data/... (SQL via gitea CLI or direct DB)"]
-        )
-        patches_created.append(patch)
-    
-    # 4. Stuck commands
-    log.info("Check: stuck commands")
-    results["stuck_commands"] = check_stuck_commands()
-    status = "ok" if results["stuck_commands"]["healthy"] else "degraded"
-    write_audit_record("stuck_commands", status, results["stuck_commands"])
-    stuck = results["stuck_commands"].get("stuck_commands", [])
-    if stuck:
-        log.warning(f"  {len(stuck)} commands stuck in running/")
-        for c in stuck:
-            log.warning(f"    -> {c['name']} (age: {c['age_minutes']}m)")
-    
-    # Update state
-    state["checks"] = {
-        "last_run": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
-        "results": {k: {"healthy": v.get("healthy"), "error": v.get("error")} for k, v in results.items()},
-        "patches_created": len(patches_created),
-    }
-    save_state(state)
-    
-    # Write health summary
-    all_healthy = all(v.get("healthy", False) for v in results.values())
-    summary = {
-        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S%z"),
-        "controller_version": CONTROLLER_VERSION,
-        "all_healthy": all_healthy,
-        "checks": {k: v.get("healthy") for k, v in results.items()},
-        "patches_pending": len(patches_created),
-    }
-    HEALTH_FILE.parent.mkdir(parents=True, exist_ok=True)
-    HEALTH_FILE.write_text(json.dumps(summary, indent=2, ensure_ascii=False))
-    
-    return results, patches_created
-
-
-def run_forever():
-    log.info(f"Autonomous Controller v{CONTROLLER_VERSION} started")
-    log.info(f"Poll interval: {POLL_INTERVAL}s")
-    log.info(f"Workspace: {WORKSPACE}")
-    log.info(f"Gitea: {GITEA_URL}, API: {API_URL}")
-    
-    while True:
-        try:
-            log.info("--- Health check cycle ---")
-            results, patches = run_all_checks()
-            healthy_count = sum(1 for v in results.values() if v.get("healthy"))
-            total = len(results)
-            log.info(f"Results: {healthy_count}/{total} healthy")
-            if patches:
-                log.warning(f"Created {len(patches)} patch(es) for owner review")
-            else:
-                log.info("No issues detected requiring patches")
-        except Exception as e:
-            log.exception(f"Check cycle failed: {e}")
-        
-        time.sleep(POLL_INTERVAL)
-
-
-def run_once():
-    log.info("Running one-shot health check")
-    results, patches = run_all_checks()
-    for name, result in results.items():
-        status = "OK" if result.get("healthy") else "FAIL"
-        log.info(f"  [{status}] {name}")
-        if not result.get("healthy") and result.get("error"):
-            log.info(f"         error: {result['error'][:200]}")
-    if patches:
-        log.info(f"Patches created: {len(patches)}")
-    else:
-        log.info("No patches created")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) > 1 and sys.argv[1] == "--once":
-        run_once()
-    else:
-        run_forever()

agents/state/README.md

@@ -1,2 +0,0 @@
-# AIOS Agent State
-Agent state and lock files for AIOS Git Agent execution.