Add V1R4C2 Search Gateway acceptance matrix

- Group-owner-agent-context-isolation
- Agent Observability complete loop
- Agent Event Bus unified platform
- Agent Command Plane and Audit Plane
- OpenAPI workspace permission fix

VERSION

@@ -1 +1 @@
-V1R1C4
+V1R4C2

acceptance/V1R4C2-search-gateway-acceptance-matrix.yaml

@@ -0,0 +1,90 @@
+version: V1R4C2
+capability: general_search_gateway
+status: pending_runtime_validation
+
+scope:
+  - general Search Gateway
+  - provider registry
+  - group user session profile customization
+  - audit store
+  - event bridge
+  - agent adapters
+  - task center integration
+  - web ui
+
+required_tests:
+  unit:
+    - tests/test_search_gateway_general_capability.py
+    - tests/test_search_provider_registry.py
+    - tests/test_search_gateway_orchestrator.py
+    - tests/test_search_agent_adapter.py
+    - tests/test_search_architect_integration.py
+  task_center:
+    - tests/test_task_center.py
+    - tests/test_task_lifecycle.py
+    - tests/test_task_orchestrator.py
+    - tests/test_task_event_and_statistics.py
+    - tests/test_task_dashboard_view.py
+    - tests/test_task_policy_acceptance.py
+
+acceptance_cases:
+  - id: SG-001
+    name: public general search request
+    expected:
+      - provider_attempts_recorded
+      - evidence_or_clarification_returned
+      - audit_record_created
+  - id: SG-002
+    name: single provider failure fallback
+    expected:
+      - first_provider_failure_not_terminal
+      - fallback_attempt_recorded
+  - id: SG-003
+    name: group user session customization
+    expected:
+      - profile_overlay_resolved
+      - hard_guardrails_not_overridden
+  - id: SG-004
+    name: agent adapter integration
+    expected:
+      - openclaw_uses_search_gateway
+      - hermes_uses_search_gateway
+      - codex_uses_search_gateway
+      - custom_gpt_bridge_uses_search_gateway
+  - id: SG-005
+    name: task center visibility
+    expected:
+      - search_deployment_task_visible
+      - executor_visible
+      - progress_visible
+      - notification_state_visible
+  - id: SG-006
+    name: blocked unauthorized request
+    expected:
+      - status_blocked
+      - blocked_reasons_recorded
+      - audit_record_created
+
+owner_gate:
+  required_for:
+    - paid_provider
+    - provider_secret
+    - private_data_source
+    - production_baseline_promotion
+  not_required_for:
+    - local_code_tests
+    - public_provider_framework
+    - task_center_dashboard_model
+
+success_signals:
+  - AIOS_GENERAL_SEARCH_GATEWAY_READY
+  - AIOS_SEARCH_PROFILE_CUSTOMIZATION_READY
+  - AIOS_SEARCH_PROVIDER_REGISTRY_READY
+  - AIOS_SEARCH_PROVIDER_FALLBACK_READY
+  - AIOS_SEARCH_AUDIT_READY
+  - AIOS_SEARCH_EVENT_LOOP_READY
+  - AIOS_SEARCH_RUNTIME_LOOP_READY
+  - AIOS_SEARCH_WEB_UI_READY
+  - AIOS_SEARCH_AGENT_ADAPTERS_READY
+  - AIOS_TASK_OPERATION_CENTER_READY
+  - AIOS_SEARCH_WECHAT_NOTIFICATION_SENT

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-v23.git')))
+BARE_REPO = Path(os.getenv('AIOS_GITOPS_BARE_REPO', str(ROOT / 'runtime' / 'gitea-bin' / 'data' / 'repositories' / 'aios' / 'aios.git')))
 monitor = ActionMonitor()
 
 BASE_MODELS = [

active-runtime/app/search_agent_adapter.py

@@ -0,0 +1,92 @@
+"""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

@@ -0,0 +1,73 @@
+"""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

@@ -0,0 +1,27 @@
+"""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

@@ -0,0 +1,118 @@
+"""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

@@ -0,0 +1,252 @@
+"""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

@@ -0,0 +1,65 @@
+"""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

@@ -0,0 +1,85 @@
+"""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

@@ -0,0 +1,41 @@
+"""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

@@ -0,0 +1,124 @@
+"""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

@@ -0,0 +1,121 @@
+"""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/task_action_api.py

@@ -0,0 +1,41 @@
+"""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

@@ -0,0 +1,115 @@
+"""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

@@ -0,0 +1,34 @@
+"""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

@@ -0,0 +1,81 @@
+"""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

@@ -0,0 +1,129 @@
+"""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

@@ -0,0 +1,147 @@
+"""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

@@ -0,0 +1,50 @@
+"""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

@@ -0,0 +1,159 @@
+"""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

@@ -0,0 +1,33 @@
+"""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

@@ -0,0 +1,29 @@
+"""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"]

config/search-gateway-policy.yaml

@@ -0,0 +1,92 @@
+search_gateway:
+  enabled: true
+  scope: general_purpose_network_search
+  principle: shared_base_capability_with_group_user_session_customization
+
+  customization:
+    enabled: true
+    precedence:
+      - base
+      - group_profile
+      - user_profile
+      - session_profile
+    customizable:
+      - provider_order
+      - trusted_domains
+      - query_expansion_hints
+      - domain_profiles
+      - preferred_language
+      - preferred_region
+    non_overridable:
+      - audit_required
+      - fallback_required
+      - authorization_required
+      - blocked_behaviors
+      - privacy_boundaries
+
+  domain_profiles:
+    supported_defaults:
+      - general
+      - education_exam_data
+      - policy_regulation
+      - software_library
+      - product_research
+      - company_research
+    extensible_by_group: true
+    extensible_by_user: true
+    extension_requires_audit: true
+
+  providers:
+    routing:
+      - cache
+      - official_site
+      - general_web
+      - vertical_source
+      - browser_fetch
+      - user_authorized_file
+      - internal_archive
+    failure_policy:
+      single_provider_failure_is_not_terminal: true
+      require_fallback_attempts: true
+      record_provider_failures: true
+
+  allowed_sources:
+    - public_web_pages
+    - official_announcements
+    - public_documents
+    - public_exam_papers
+    - user_authorized_files
+    - user_authorized_links
+    - internal_archives
+
+  blocked_behaviors:
+    - bypass_login
+    - bypass_captcha
+    - scrape_private_student_grades
+    - scrape_student_private_data
+    - bulk_scrape_protected_platforms
+    - collect_data_without_authorization
+
+  evidence:
+    require_source_record: true
+    require_confidence: true
+    require_attempt_log: true
+    require_clarification_when_insufficient: true
+
+  audit:
+    enabled: true
+    record:
+      - query
+      - requester
+      - resolved_profile
+      - expanded_queries
+      - providers_attempted
+      - provider_failures
+      - evidence_selected
+      - blocked_reasons
+      - final_confidence
+
+  user_experience:
+    do_not_answer_provider_unavailable_as_final_failure: true
+    explain_public_vs_private_data_boundary: true
+    ask_for_subject_platform_file_or_link_when_needed: true

config/task-center-policy.yaml

@@ -0,0 +1,47 @@
+task_center:
+  enabled: true
+  purpose: autonomous_operation_management
+
+  lifecycle:
+    states:
+      - new
+      - pending
+      - assigned
+      - running
+      - blocked
+      - waiting_approval
+      - approved
+      - completed
+      - failed
+      - closed
+
+  sources:
+    - command_watcher
+    - openclaw
+    - hermes
+    - codex
+    - agent_event_bus
+
+  required_tracking:
+    - creator
+    - assigned_by
+    - executor
+    - progress
+    - elapsed_time
+    - remaining_work
+    - blockers
+    - approvals
+    - notifications
+
+  governance:
+    require_audit: true
+    require_rbac_actions: true
+    require_notification_trace: true
+
+  statistics:
+    - completion_rate
+    - average_duration
+    - blocked_count
+    - approval_wait_time
+    - executor_distribution
+    - notification_rate

ops/openclaw/CMD-20260709-complete-search-gateway-runtime-loop.md

@@ -0,0 +1,76 @@
+# CMD-20260709-complete-search-gateway-runtime-loop
+
+## Goal
+
+Complete deployment of AIOS General Search Gateway runtime loop.
+
+## Components
+
+Deploy:
+
+- Search Gateway core
+- Profile resolver
+- Provider registry
+- Audit store
+- Event bridge
+- Runtime orchestrator
+- Search dashboard
+
+## Runtime Integration
+
+Connect:
+
+- Custom GPT bridge
+- OpenClaw
+- Hermes
+- Codex
+- Agent Event Bus
+- Audit Plane
+
+## Validation
+
+Run:
+
+```bash
+pytest tests/test_search_gateway_general_capability.py \
+       tests/test_search_provider_registry.py \
+       tests/test_search_gateway_orchestrator.py
+```
+
+Required signals:
+
+- AIOS_GENERAL_SEARCH_GATEWAY_READY
+- AIOS_SEARCH_PROFILE_CUSTOMIZATION_READY
+- AIOS_SEARCH_PROVIDER_REGISTRY_READY
+- AIOS_SEARCH_AUDIT_READY
+- AIOS_SEARCH_EVENT_LOOP_READY
+- AIOS_SEARCH_RUNTIME_LOOP_READY
+
+## Web UI
+
+Enable:
+
+- /admin/ai-evolution/search
+
+Show:
+
+- provider health
+- fallback count
+- evidence quality
+- search audit
+- group/user profile customization
+
+## Notification
+
+After deployment send WeChat report containing:
+
+- branch
+- commit SHA
+- test results
+- runtime status
+- enabled providers
+- success signals
+
+## Governance
+
+Production provider credentials, paid APIs and private data integrations require owner approval.

ops/openclaw/CMD-20260709-complete-task-center-closed-loop.md

@@ -0,0 +1,74 @@
+# CMD-20260709-complete-task-center-closed-loop
+
+## Goal
+
+Complete AIOS Task Center autonomous closed loop.
+
+## Deploy
+
+Components:
+
+- Task lifecycle state machine
+- Task Event Bridge
+- Task Store
+- Task Statistics
+- Task Action API
+- Task Web UI
+
+## Integrations
+
+Connect:
+
+- Command Watcher: every CMD becomes a task
+- OpenClaw: execution updates task automatically
+- Hermes: delegation updates task automatically
+- Codex: development tasks update task automatically
+- Audit Plane: stores evidence
+- Notification Agent: completion/blocking notifications
+
+## Required UI actions
+
+Every task page must expose RBAC controlled buttons:
+
+- assign
+- start
+- update progress
+- block
+- request approval
+- approve
+- reject
+- resume
+- retry
+- complete
+- notify
+- close
+
+## Statistics
+
+Display:
+
+- total tasks
+- completion rate
+- average execution time
+- blocked tasks
+- approval waiting time
+- executor distribution
+- blocker ranking
+- notification completion rate
+
+## Validation
+
+- AIOS_TASK_LIFECYCLE_READY
+- AIOS_TASK_EVENT_LOOP_READY
+- AIOS_TASK_STATISTICS_READY
+- AIOS_TASK_CLOSURE_LOOP_READY
+- AIOS_TASK_WEB_UI_ACTIONS_READY
+
+## Notification
+
+After deployment send WeChat summary:
+
+- deployment result
+- task center URL
+- tests
+- success signals

ops/openclaw/CMD-20260709-dispatch-search-gateway-production-deployment.md

@@ -0,0 +1,238 @@
+# CMD-20260709-dispatch-search-gateway-production-deployment
+
+## Priority
+
+P0
+
+## Goal
+
+Deploy AIOS General Search Gateway runtime loop and report completion to Owner via WeChat.
+
+## Branch
+
+```text
+patch/search-gateway-governed-general-capability
+```
+
+## Preconditions
+
+Existing implementation files are already committed on the branch:
+
+- active-runtime/app/search_gateway.py
+- active-runtime/app/search_profile_resolver.py
+- active-runtime/app/search_provider_registry.py
+- active-runtime/app/search_audit_store.py
+- active-runtime/app/search_event_bridge.py
+- active-runtime/app/search_gateway_orchestrator.py
+- active-runtime/app/search_agent_adapter.py
+- active-runtime/app/search_gateway_api.py
+- active-runtime/app/search_gateway_dashboard.py
+- active-runtime/app/search_architect_integration.py
+- config/search-gateway-policy.yaml
+- tests/test_search_gateway_general_capability.py
+- tests/test_search_provider_registry.py
+- tests/test_search_gateway_orchestrator.py
+- tests/test_search_agent_adapter.py
+- tests/test_search_architect_integration.py
+
+## Execute
+
+### 1. Fix documentation path if needed
+
+Run first if docs/architecture is not writable:
+
+```text
+ops/openclaw/CMD-20260709-search-gateway-document-permission-fix.md
+```
+
+### 2. Run test suite
+
+```bash
+cd /data/aios-gitops/workspace
+
+git fetch origin
+git checkout patch/search-gateway-governed-general-capability
+git pull origin patch/search-gateway-governed-general-capability
+
+pytest tests/test_search_gateway_general_capability.py \
+       tests/test_search_provider_registry.py \
+       tests/test_search_gateway_orchestrator.py \
+       tests/test_search_agent_adapter.py \
+       tests/test_search_architect_integration.py
+```
+
+### 3. Register runtime modules/routes
+
+Register Search Gateway APIs:
+
+- GET /admin/ai-evolution/search/status
+- GET /admin/ai-evolution/search/overview
+- POST /admin/ai-evolution/search/query
+
+Operation IDs:
+
+- getSearchGatewayStatus
+- getSearchGatewayOverview
+- runSearchGatewayQuery
+
+### 4. Wire agent clients
+
+Route all runtime search calls through Search Gateway adapters:
+
+- OpenClaw -> OpenClawSearchClient
+- Hermes -> HermesSearchClient
+- Codex -> CodexSearchClient
+- Custom GPT bridge -> CustomGPTSearchClient
+
+No agent should directly perform ad-hoc web search after this deployment.
+
+### 5. Configure providers
+
+Enable provider registry entries:
+
+- cache
+- official_site
+- general_web
+- vertical_source
+- browser_fetch
+- user_authorized_file
+- internal_archive
+
+Production credentials, paid APIs, private platform access, or sensitive data integrations require Owner approval before enabling.
+
+Public web/official-site/internal-archive providers may be enabled immediately if already available in runtime.
+
+### 6. Enable governance layers
+
+Enable:
+
+- profile resolver
+- group/user/session customization
+- audit store
+- event bridge
+- provider fallback
+- Search Gateway Web UI
+- Architect search governance integration
+
+### 7. Web UI
+
+Deploy:
+
+```text
+/admin/ai-evolution/search
+```
+
+Show:
+
+- provider health
+- configured provider count
+- fallback status
+- recent search audit
+- blocked search count
+- profile customization state
+- evidence quality
+
+### 8. Acceptance smoke tests
+
+Run these live requests through Search Gateway API:
+
+#### Public general search
+
+```json
+{
+  "query": "latest Python package release notes",
+  "requester": "openclaw",
+  "intent": "software_library",
+  "user_scope": "public"
+}
+```
+
+Expected:
+
+- status is found or not_found
+- provider attempts recorded
+- no direct provider failure as final answer without fallback attempt
+
+#### Group/user customization
+
+```json
+{
+  "query": "AI agent observability",
+  "requester": "hermes",
+  "intent": "software_library",
+  "group_profile": {
+    "profile_id": "group-default",
+    "scope": "group",
+    "query_expansion_hints": ["GitHub", "release notes"]
+  },
+  "user_scope": "public"
+}
+```
+
+Expected:
+
+- resolved_profile includes group overlay
+- audit is recorded
+
+#### Guardrail block
+
+```json
+{
+  "query": "绕过验证码 抓取个人成绩",
+  "requester": "openclaw",
+  "user_scope": "public"
+}
+```
+
+Expected:
+
+- status = blocked
+- blocked_reasons populated
+- audit/event recorded
+
+## Success Signals
+
+Return all of these if deployment succeeds:
+
+```text
+AIOS_GENERAL_SEARCH_GATEWAY_READY
+AIOS_SEARCH_PROFILE_CUSTOMIZATION_READY
+AIOS_SEARCH_PROVIDER_REGISTRY_READY
+AIOS_SEARCH_PROVIDER_FALLBACK_READY
+AIOS_SEARCH_AUDIT_READY
+AIOS_SEARCH_EVENT_LOOP_READY
+AIOS_SEARCH_RUNTIME_LOOP_READY
+AIOS_SEARCH_WEB_UI_READY
+AIOS_SEARCH_AGENT_ADAPTERS_READY
+AIOS_SEARCH_ARCHITECT_GOVERNANCE_READY
+AIOS_SEARCH_WECHAT_NOTIFICATION_SENT
+```
+
+## WeChat report to Owner
+
+After deployment, send WeChat report containing:
+
+- branch
+- latest commit SHA
+- test results
+- provider status
+- live smoke test results
+- Web UI URL
+- success signals
+- remaining limitations, if any
+
+## Output back to ChatGPT
+
+Return:
+
+- command status
+- commit SHA deployed
+- tests passed/failed
+- enabled providers
+- API routes verified
+- Web UI route verified
+- WeChat notification result
+
+## Governance
+
+This command deploys the governed shared Search Gateway. It does not authorize bypassing login, CAPTCHA, protected platforms, or private data boundaries. Any provider requiring secrets, payment, private platform access, or sensitive data requires Owner approval before production enablement.

ops/openclaw/CMD-20260709-enable-general-search-gateway.md

@@ -0,0 +1,103 @@
+# CMD-20260709-enable-general-search-gateway
+
+## Goal
+
+Deploy AIOS general-purpose governed Search Gateway as a shared capability for Custom GPT, OpenClaw, Hermes, Codex and future agents.
+
+## Scope
+
+This is a general search capability, not an education-only feature.
+
+Supported customization layers:
+
+1. base profile
+2. group profile
+3. user profile
+4. session profile
+
+Customizable:
+
+- provider order
+- trusted domains
+- query expansion hints
+- domain profiles
+- preferred language/region
+
+Non-overridable:
+
+- audit
+- fallback
+- authorization
+- privacy/safety boundaries
+- blocked behaviors
+
+## Deploy
+
+1. Register Search Gateway modules:
+   - active-runtime/app/search_gateway.py
+   - active-runtime/app/search_profile_resolver.py
+   - active-runtime/app/search_gateway_api.py
+   - active-runtime/app/search_gateway_dashboard.py
+
+2. Register routes:
+   - GET /admin/ai-evolution/search/status
+   - GET /admin/ai-evolution/search/overview
+   - POST /admin/ai-evolution/search/query
+
+3. Configure provider adapters:
+   - cache
+   - official_site
+   - general_web
+   - vertical_source
+   - browser_fetch
+   - user_authorized_file
+   - internal_archive
+
+4. Enforce fallback:
+   - a single provider failure must not end the user request
+   - provider failures must be logged
+   - ask for clarification when evidence is insufficient
+
+5. Connect Search Gateway to agents:
+   - OpenClaw
+   - Hermes
+   - Codex
+   - Custom GPT bridge
+
+6. Add Web UI:
+   - /admin/ai-evolution/search
+
+7. Notify owner by WeChat after deployment with:
+   - branch
+   - commit SHA
+   - tests result
+   - provider status
+   - success signals
+
+## Validate
+
+Run:
+
+```bash
+pytest tests/test_search_gateway_general_capability.py
+```
+
+Acceptance cases:
+
+1. provider failure fallback works
+2. general non-education query expansion works
+3. group/user/session customization works
+4. hard guardrails cannot be disabled
+5. blocked private/unauthorized collection requests are blocked
+
+## Success signals
+
+- AIOS_GENERAL_SEARCH_GATEWAY_READY
+- AIOS_SEARCH_PROFILE_CUSTOMIZATION_READY
+- AIOS_SEARCH_PROVIDER_FALLBACK_READY
+- AIOS_SEARCH_GOVERNANCE_AUDIT_READY
+- AIOS_SEARCH_WECHAT_NOTIFICATION_SENT
+
+## Governance
+
+Search is a shared AIOS capability. Any provider with credentials, payment, private platform access or sensitive data access requires owner approval before production enablement.

ops/openclaw/CMD-20260709-enable-search-gateway-general-capability.md

@@ -0,0 +1,93 @@
+# CMD-20260709-enable-search-gateway-general-capability
+
+## Goal
+
+Deploy AIOS governed general-purpose Search Gateway.
+
+## Scope
+
+This is a generic networking/search capability for AIOS, not limited to education exam queries.
+
+## Deploy
+
+1. Register Search Gateway modules:
+   - active-runtime/app/search_gateway.py
+   - active-runtime/app/search_gateway_api.py
+   - active-runtime/app/search_gateway_dashboard.py
+
+2. Enable API routes:
+   - GET /admin/ai-evolution/search/status
+   - GET /admin/ai-evolution/search/overview
+   - POST /admin/ai-evolution/search/query
+
+3. Configure providers through runtime secrets/config only:
+   - cache
+   - official site search
+   - general web search
+   - vertical source search
+   - browser fetch for public pages
+   - user-authorized file/link processing
+   - internal archive search
+
+4. Enforce policy:
+   - no single provider failure may terminate search
+   - provider failures must trigger fallback
+   - final answers must include evidence/confidence or clarification request
+   - blocked requests must be audited
+
+5. Wire callers:
+   - OpenClaw
+   - Hermes
+   - Codex
+   - Custom GPT bridge
+   - Architect weekly research agent
+
+## Compliance Boundary
+
+Do not implement or enable:
+
+- login bypass
+- CAPTCHA bypass
+- scraping private student grades
+- scraping student private data
+- bulk scraping protected platforms
+- collection without authorization
+
+Allowed:
+
+- public web pages
+- official announcements
+- public documents
+- public exam papers
+- user-authorized files
+- user-authorized links
+- internal archives
+
+## Tests
+
+Run:
+
+```bash
+pytest tests/test_search_gateway.py tests/test_search_gateway_dashboard.py
+```
+
+## Validation Signals
+
+- AIOS_SEARCH_GATEWAY_READY
+- AIOS_SEARCH_PROVIDER_FALLBACK_READY
+- AIOS_SEARCH_EVIDENCE_AUDIT_READY
+- AIOS_SEARCH_WEB_UI_READY
+
+## Notification
+
+After deployment and tests, notify Owner through WeChat with:
+
+```text
+AIOS Search Gateway deployed.
+Fallback, evidence audit, Web UI and compliance guard are ready.
+```
+
+## Governance
+
+This capability is recommended as R-level because it adds a system-wide Search Gateway foundation.
+Owner gate is required before enabling external paid providers, new secrets, or production-wide search routing.

ops/openclaw/CMD-20260709-enable-task-center-webui.md

@@ -0,0 +1,61 @@
+# CMD-20260709-enable-task-center-webui
+
+## Goal
+
+Deploy AIOS Task Center Web UI for autonomous operation visibility.
+
+## Page
+
+```text
+/admin/ai-evolution/tasks
+```
+
+## Display
+
+Every task must show:
+
+- task title
+- task source
+- assigned by
+- executor agent
+- current status
+- progress percentage
+- current step
+- completed steps
+- remaining steps
+- blocked reason
+- elapsed time
+- owner gate state
+- completion notification status
+- notification channel
+- notification timestamp
+
+## Data Sources
+
+Connect:
+
+- Agent Event Bus
+- Command Watcher
+- OpenClaw execution records
+- Hermes delegation records
+- Codex execution records
+- Audit Plane
+
+## Validation
+
+- AIOS_TASK_CENTER_READY
+- AIOS_TASK_PROGRESS_VISIBLE
+- AIOS_TASK_NOTIFICATION_TRACE_READY
+
+## Governance
+
+Task progress should be visible through Web UI. Users should not need to ask manually for repeated status updates.
+
+## Notification
+
+On deployment completion send WeChat report with:
+
+- deployment status
+- commit SHA
+- page URL
+- validation results

ops/openclaw/CMD-20260709-search-gateway-document-permission-fix.md

@@ -0,0 +1,47 @@
+# CMD-20260709-search-gateway-document-permission-fix
+
+## Goal
+
+Restore Git write permission for architecture documentation path.
+
+## Symptom
+
+Writing:
+
+```text
+/docs/architecture/AIOS_SEARCH_GATEWAY_DESIGN.md
+```
+
+failed with:
+
+```text
+Permission denied
+```
+
+## Execute
+
+Check:
+
+```bash
+ls -ld /data/aios-gitops/workspace/docs
+ls -ld /data/aios-gitops/workspace/docs/architecture
+stat /data/aios-gitops/workspace/docs/architecture
+id
+```
+
+Fix ownership to runtime Git user only if required:
+
+```bash
+chown -R <runtime_user>:<runtime_group> /data/aios-gitops/workspace/docs/architecture
+chmod -R u+rwX,g+rwX /data/aios-gitops/workspace/docs/architecture
+```
+
+Do not use chmod 777.
+
+## Validation
+
+Create and commit architecture documentation test file through GitOps.
+
+Success:
+
+AIOS_SEARCH_GATEWAY_DOC_WRITE_READY

ops/openclaw/CMD-20260709-task-center-source-sync.md

@@ -0,0 +1,70 @@
+# CMD-20260709-task-center-source-sync
+
+## Goal
+
+Enable automatic Task Center source synchronization.
+
+## Branch
+
+patch/search-gateway-governed-general-capability
+
+## Components
+
+- Task Source Ingestor
+- Task Orchestrator
+- Task Store
+- Task Event Bridge
+- Task Statistics
+
+## Sources
+
+Import task records from:
+
+- command watcher folders
+- OpenClaw runs
+- Hermes delegations
+- Codex work records
+- agent lifecycle events
+
+## Deploy
+
+1. Load TaskOrchestrator.
+2. Convert existing active commands into tasks.
+3. Convert running commands into running tasks.
+4. Convert completed commands into completed tasks.
+5. Link new agent runs to task_id.
+6. Emit task events for creation, update, block, approval and completion.
+7. Store tasks in runtime/task-center/tasks.jsonl.
+
+## Web UI
+
+Update /admin/ai-evolution/tasks to show:
+
+- origin
+- assigned_by
+- executor
+- status
+- progress
+- elapsed time
+- remaining work
+- blockers
+- approval state
+- notification state
+
+## Validate
+
+Run:
+
+pytest tests/test_task_orchestrator.py tests/test_task_event_and_statistics.py tests/test_task_lifecycle.py tests/test_task_center.py
+
+## Success Signals
+
+- AIOS_TASK_SOURCE_SYNC_READY
+- AIOS_TASK_AUTO_GENERATION_READY
+- AIOS_AGENT_TASK_BINDING_READY
+- AIOS_TASK_PROGRESS_SYNC_READY
+- AIOS_TASK_OPERATION_CENTER_READY
+
+## Report
+
+Send WeChat summary after deployment with task count, active count, blocked count, notification pending count and success signals.

ops/openclaw/CMD-20260709-upgrade-task-center-governance.md

@@ -0,0 +1,74 @@
+# CMD-20260709-upgrade-task-center-governance
+
+## Goal
+
+Upgrade Task Center from status dashboard to full task governance loop.
+
+## Features
+
+Deploy:
+
+- task lifecycle state machine
+- task action buttons
+- approval workflow
+- blocking workflow
+- retry/resume workflow
+- notification trace
+- task statistics
+
+## Web UI
+
+Page:
+
+```text
+/admin/ai-evolution/tasks
+```
+
+Each task displays:
+
+- creator
+- assigner
+- executor
+- progress
+- elapsed time
+- remaining steps
+- blocker
+- approval state
+- notification state
+
+Actions:
+
+- 分配任务
+- 开始执行
+- 更新进度
+- 标记阻塞
+- 请求审批
+- 批准
+- 拒绝
+- 继续执行
+- 重试
+- 标记完成
+- 发送通知
+- 关闭任务
+
+## Data Integration
+
+Connect:
+
+- Agent Event Bus
+- Command Watcher
+- OpenClaw
+- Hermes
+- Codex
+- Audit Plane
+
+## Validation
+
+- AIOS_TASK_LIFECYCLE_READY
+- AIOS_TASK_ACTION_BUTTONS_READY
+- AIOS_TASK_APPROVAL_FLOW_READY
+- AIOS_TASK_CLOSURE_LOOP_READY
+
+## Governance
+
+Approval buttons must respect RBAC. Owner approval is required only where policy requires it.

ops/openclaw/TASK-CENTER-VISUAL-DASHBOARD-DEPLOY-20260709.md

@@ -0,0 +1,60 @@
+# TASK CENTER VISUAL DASHBOARD DEPLOY 20260709
+
+## Goal
+
+Enable AIOS Task Center visual operations dashboard.
+
+## Page
+
+/admin/ai-evolution/tasks
+
+## Views
+
+- Kanban state board
+- Execution timeline
+- Task lifecycle flow
+- Statistics summary
+
+## Task Card Fields
+
+- source
+- assigned_by
+- executor
+- status
+- progress
+- elapsed time
+- remaining steps
+- blocker
+- approval state
+- notification state
+
+## Operation Buttons
+
+Render role controlled buttons for:
+
+- start
+- update progress
+- mark blocked
+- request approval
+- approve
+- reject
+- retry
+- complete
+- send notification
+- close
+
+## Validation
+
+Run:
+
+pytest tests/test_task_dashboard_view.py tests/test_task_lifecycle.py tests/test_task_center.py
+
+## Success Signals
+
+- AIOS_TASK_CENTER_VISUAL_READY
+- AIOS_TASK_FLOW_VIEW_READY
+- AIOS_TASK_OPERATION_BUTTONS_READY
+
+## Report
+
+Send completion report through the configured notification channel with page url, commit sha, test result and success signals.

patches/patch_search-gateway-governed-general-capability.branch.json

@@ -0,0 +1,9 @@
+{
+  "type": "branch",
+  "branch": "patch/search-gateway-governed-general-capability",
+  "base": "main",
+  "created_by": "chatgpt-gitops-bot",
+  "created_at": "2026-07-09T04:40:14Z",
+  "direct_main_push": false,
+  "owner_approval_required": true
+}

tests/test_search_agent_adapter.py

@@ -0,0 +1,19 @@
+from active_runtime.app.search_agent_adapter import AgentSearchContext, OpenClawSearchClient
+
+
+class FakeOrchestrator:
+    def execute(self, payload):
+        return payload
+
+
+def test_agent_adapter_keeps_agent_identity_and_profile():
+    client = OpenClawSearchClient(FakeOrchestrator())
+    result = client.search_public(
+        "latest framework",
+        AgentSearchContext(
+            agent="openclaw",
+            group_profile={"domain_profiles": ["software_library"]},
+        ),
+    )
+    assert result["requester"] == "openclaw"
+    assert result["group_profile"]["domain_profiles"] == ["software_library"]

tests/test_search_architect_integration.py

@@ -0,0 +1,12 @@
+from active_runtime.app.search_architect_integration import SearchArchitectIntegration
+
+
+def test_search_architect_recommends_release_for_new_capability():
+    result = SearchArchitectIntegration().review({"new_search_capability": True})
+    assert result.version_bump == "R"
+    assert result.owner_gate_required is True
+
+
+def test_search_architect_recommends_c_for_minor_cost_change():
+    result = SearchArchitectIntegration().review({"cost_increase": True})
+    assert result.version_bump == "C"

tests/test_search_gateway.py

@@ -0,0 +1,66 @@
+from active_runtime.app.search_gateway import (
+    SearchEvidence,
+    SearchGateway,
+    SearchProviderAttempt,
+    SearchRequest,
+)
+
+
+class FailingProvider:
+    name = "failing-provider"
+
+    def search(self, request, queries):
+        raise RuntimeError("provider unavailable")
+
+
+class SuccessProvider:
+    name = "success-provider"
+
+    def search(self, request, queries):
+        return [
+            SearchEvidence(
+                title="public result",
+                url="https://example.com/public",
+                source="example",
+                snippet="public evidence",
+                confidence="high",
+            )
+        ], SearchProviderAttempt(provider=self.name, status="ok", result_count=1)
+
+
+def test_provider_failure_falls_back_to_next_provider():
+    gateway = SearchGateway(providers=[FailingProvider(), SuccessProvider()])
+    result = gateway.search(SearchRequest(query="public data", requester="test"))
+    assert result.status == "found"
+    assert len(result.attempts) == 2
+    assert result.attempts[0].status == "failed"
+    assert result.confidence == "high"
+
+
+def test_private_student_data_is_blocked_without_authorized_file():
+    gateway = SearchGateway()
+    result = gateway.search(
+        SearchRequest(
+            query="查询学生个人成绩",
+            requester="test",
+            data_type="personal_grade",
+            user_scope="public",
+        )
+    )
+    assert result.status == "blocked"
+    assert result.blocked_reasons
+
+
+def test_education_exam_not_found_requests_clarification():
+    gateway = SearchGateway()
+    result = gateway.search(
+        SearchRequest(
+            query="湖南2025年秋季高中第一次月考数据",
+            requester="test",
+            intent="education_exam_data",
+            region="湖南",
+            time_range="2025秋季",
+        )
+    )
+    assert result.status == "not_found"
+    assert "学校名称" in result.need_clarification[0]

tests/test_search_gateway_dashboard.py

@@ -0,0 +1,10 @@
+from active_runtime.app.search_gateway_dashboard import SearchGatewayDashboard
+
+
+def test_search_gateway_dashboard_reports_provider_failures():
+    result = SearchGatewayDashboard().overview(
+        search_runs=[{"status": "not_found"}, {"status": "blocked"}],
+        providers=[{"name": "p1", "status": "failed"}],
+    )
+    assert result["route"] == "/admin/ai-evolution/search"
+    assert result["status"] == "attention_required"

tests/test_search_gateway_general_capability.py

@@ -0,0 +1,66 @@
+from active_runtime.app.search_gateway import SearchEvidence, SearchGateway, SearchProviderAttempt, SearchRequest
+from active_runtime.app.search_profile_resolver import SearchProfileResolver
+
+
+class FailingProvider:
+    name = "general_web"
+
+    def search(self, request, queries):
+        raise RuntimeError("provider unavailable")
+
+
+class SuccessProvider:
+    name = "official_site"
+
+    def search(self, request, queries):
+        return [
+            SearchEvidence(
+                title="Official result",
+                url="https://example.gov/result",
+                source="official_site",
+                snippet="public evidence",
+                confidence="high",
+            )
+        ], SearchProviderAttempt(provider=self.name, status="ok", result_count=1)
+
+
+def test_single_provider_failure_is_not_terminal():
+    gateway = SearchGateway(providers=[FailingProvider(), SuccessProvider()])
+    result = gateway.search(SearchRequest(query="policy update", requester="test", intent="policy_regulation"))
+    assert result.status == "found"
+    assert any(a.status == "failed" for a in result.attempts)
+    assert result.confidence == "high"
+
+
+def test_group_user_profile_customization_adds_hints_without_disabling_guardrails():
+    profile = SearchProfileResolver().resolve(
+        group_profile={"profile_id": "group-a", "scope": "group", "query_expansion_hints": ["group trusted source"]},
+        user_profile={"profile_id": "user-a", "scope": "user", "trusted_domains": ["example.com"]},
+        session_profile={"profile_id": "session-a", "scope": "session", "domain_profiles": ["software_library"]},
+    )
+    assert "group trusted source" in profile.query_expansion_hints
+    assert "example.com" in profile.trusted_domains
+    assert profile.audit_required is True
+    assert profile.fallback_required is True
+    assert "bypass_login" in profile.blocked_behaviors
+
+
+def test_private_or_bypass_request_is_blocked():
+    gateway = SearchGateway(providers=[SuccessProvider()])
+    result = gateway.search(SearchRequest(query="绕过验证码 抓取个人成绩", requester="test"))
+    assert result.status == "blocked"
+    assert result.blocked_reasons
+
+
+def test_general_query_planning_not_limited_to_education():
+    gateway = SearchGateway(providers=[])
+    result = gateway.search(
+        SearchRequest(
+            query="latest package release",
+            requester="test",
+            intent="software_library",
+            user_profile={"domain_profiles": ["software_library"], "query_expansion_hints": ["migration"]},
+        )
+    )
+    assert result.status == "not_found"
+    assert any("release notes" in q or "migration" in q for q in result.expanded_queries)

tests/test_search_gateway_orchestrator.py

@@ -0,0 +1,9 @@
+from active_runtime.app.search_gateway_orchestrator import SearchGatewayOrchestrator
+
+
+def test_search_orchestrator_has_audit_registry_event_layers():
+    orchestrator = SearchGatewayOrchestrator()
+    status = orchestrator.status()
+    assert status["audit"] == "enabled"
+    assert status["events"] == "enabled"
+    assert status["registry"]["enabled"] > 0

tests/test_search_provider_registry.py

@@ -0,0 +1,29 @@
+from active_runtime.app.search_provider_registry import SearchProviderRegistry, StaticArchiveProvider
+from active_runtime.app.search_gateway import SearchGateway, SearchRequest
+
+
+def test_provider_registry_has_default_layers():
+    registry = SearchProviderRegistry()
+    status = registry.status()
+    names = {item["name"] for item in status["providers"]}
+    assert "official_site" in names
+    assert "general_web" in names
+    assert "internal_archive" in names
+
+
+def test_internal_archive_can_supply_evidence():
+    registry = SearchProviderRegistry()
+    registry.register_provider(
+        "internal_archive",
+        StaticArchiveProvider([
+            {
+                "title": "AIOS document",
+                "snippet": "search gateway architecture",
+                "tags": "search gateway",
+                "confidence": "high",
+            }
+        ]),
+    )
+    gateway = SearchGateway(registry.ordered())
+    result = gateway.search(SearchRequest(query="search gateway", requester="test"))
+    assert result.status == "found"

tests/test_task_center.py

@@ -0,0 +1,18 @@
+from active_runtime.app.task_center import AIOSTaskRecord, TaskCenter, TaskNotificationStatus, TaskProgress
+
+
+def test_task_center_tracks_progress_and_notification():
+    result = TaskCenter().summarize([
+        AIOSTaskRecord(
+            task_id="t1",
+            title="deploy search gateway",
+            assigned_by="owner",
+            executor="openclaw",
+            source="cmd",
+            status="completed",
+            progress=TaskProgress(percent=100, current_step="done"),
+            notification=TaskNotificationStatus(required=True, sent=False),
+        )
+    ])
+    assert result["summary"]["completed"] == 1
+    assert result["summary"]["notification_pending"] == 1

tests/test_task_dashboard_view.py

@@ -0,0 +1,11 @@
+from active_runtime.app.task_dashboard_view import TaskDashboardView
+
+
+def test_task_dashboard_contains_operations_views():
+    result = TaskDashboardView().build([
+        {"task_id": "t1", "status": "running", "executor": "openclaw"}
+    ])
+    assert result["route"] == "/admin/ai-evolution/tasks"
+    assert "kanban" in result["views"]
+    assert "timeline" in result["views"]
+    assert "flow" in result["views"]

tests/test_task_event_and_statistics.py

@@ -0,0 +1,16 @@
+from active_runtime.app.task_event_bridge import TaskEventBridge
+from active_runtime.app.task_statistics import TaskStatistics
+
+
+def test_task_event_bridge_creates_events():
+    event = TaskEventBridge().task_created({"task_id": "t1", "title": "demo"})
+    assert event["kind"] == "task_created"
+
+
+def test_task_statistics_counts():
+    result = TaskStatistics().summarize([
+        {"status": "completed", "elapsed_seconds": 10},
+        {"status": "blocked", "blocker": "approval"},
+    ])
+    assert result["completed"] == 1
+    assert result["blocked"] == 1

tests/test_task_lifecycle.py

@@ -0,0 +1,17 @@
+from active_runtime.app.task_lifecycle import TaskLifecycle
+
+
+def test_owner_approval_button_appears_for_waiting_task():
+    lifecycle = TaskLifecycle()
+    actions = lifecycle.available_actions({"task_id": "t1", "status": "waiting_approval"}, "owner")
+    approve = [a for a in actions if a["action"] == "approve"][0]
+    assert approve["enabled"] is True
+
+
+def test_block_requires_reason():
+    lifecycle = TaskLifecycle()
+    try:
+        lifecycle.transition({"status": "running"}, "block", "executor")
+        assert False
+    except ValueError:
+        assert True

tests/test_task_orchestrator.py

@@ -0,0 +1,19 @@
+from active_runtime.app.task_orchestrator import TaskOrchestrator
+
+
+def test_command_creates_task():
+    orchestrator = TaskOrchestrator()
+    task = orchestrator.create_from_command("ops/openclaw/CMD-test.md", "active")
+    assert task["source"] == "command_watcher"
+    assert task["executor"] == "openclaw"
+
+
+def test_agent_execution_creates_task():
+    orchestrator = TaskOrchestrator()
+    task = orchestrator.create_from_agent_execution({
+        "execution_id": "e1",
+        "entry_agent": "hermes",
+        "status": "completed",
+    })
+    assert task["source"] == "agent_execution"
+    assert task["status"] == "completed"

tests/test_task_policy_acceptance.py

@@ -0,0 +1,12 @@
+from pathlib import Path
+
+
+def test_task_center_policy_exists():
+    path = Path("config/task-center-policy.yaml")
+    assert path.exists()
+
+
+def test_task_center_required_tracking_documented():
+    text = Path("config/task-center-policy.yaml").read_text(encoding="utf-8")
+    assert "executor" in text
+    assert "notifications" in text

versions/V1R4C1.json

@@ -0,0 +1,53 @@
+{
+    "version": "V1R4C1",
+    "tag": "V1R4C1",
+    "previous_version": "V1R3C1",
+    "rollback_version": "V1R3C1",
+    "baseline": "V1R3C1",
+    "release_reason": "Promote group-owner-agent-context-isolation with Agent Observability and Agent Event Bus unified platform",
+    "purpose": "Deploy complete agent observability, context isolation, and unified event bus pipeline",
+    "changes": [
+        "Group-owner-agent-context-isolation: resolver, RBAC, API, audit, dashboard",
+        "Agent observability: Hermes model, Web UI dashboard, policy, store, API, runtime hooks, event bus bridge, closed loop tests",
+        "Agent Event Bus unified: admin dashboard, configuration, API adapters, openapi operation ids",
+        "AI evolution dashboard API endpoint",
+        "Agent Command Plane and Audit Plane (V1R3C1 baseline)",
+        "OpenAPI workspace permission fix",
+        "ChatGPT Actions API internals refactored with ActionMonitor"
+    ],
+    "artifacts": [
+        "active-runtime/app/agent_context_resolver.py",
+        "active-runtime/app/agent_context_rbac.py",
+        "active-runtime/app/agent_context_api.py",
+        "active-runtime/app/agent_context_audit.py",
+        "active-runtime/app/agent_context_dashboard.py",
+        "active-runtime/app/aios_chatgpt_actions_api.py",
+        "config/agent-context-isolation-policy.yaml",
+        "active-runtime/app/agent_observability_model.py",
+        "active-runtime/app/agent_observability_dashboard.py",
+        "active-runtime/app/agent_observability_policy.py",
+        "active-runtime/app/agent_observability_store.py",
+        "active-runtime/app/agent_observability_api.py",
+        "active-runtime/app/agent_observability_hooks.py",
+        "active-runtime/app/agent_event_bus_bridge.py",
+        "active-runtime/app/agent_event_bus_dashboard.py",
+        "active-runtime/app/agent_event_bus_config.py",
+        "active-runtime/app/agent_event_bus_api.py",
+        "tests/test_agent_observability_loop.py"
+    ],
+    "validated_actions": [
+        "getRuntimeStatus",
+        "getBaseline",
+        "listVersions",
+        "listPatches",
+        "getDiff",
+        "createBranch",
+        "createPatch",
+        "commitFile"
+    ],
+    "secret_plaintext_written": false,
+    "owner_approval_required": true,
+    "owner_notification_channels": ["wechat", "web_ui_audit"],
+    "created_at": "2026-07-09T10:57:00+08:00",
+    "author": "openclaw"
+}

versions/proposals/V1R4C2-search-gateway-general-capability.json

@@ -0,0 +1,21 @@
+{
+  "version": "V1R4C2",
+  "type": "R",
+  "name": "General Search Gateway Capability",
+  "status": "proposal",
+  "reason": "Add shared AIOS networking intelligence capability with provider governance, profile customization, audit and event integration.",
+  "changes": [
+    "Search Gateway core",
+    "Provider registry",
+    "Group/user/session search profiles",
+    "Search audit plane",
+    "Search event bridge",
+    "Agent adapters for OpenClaw Hermes Codex CustomGPT",
+    "Search governance dashboard"
+  ],
+  "breaking_change": false,
+  "owner_gate_required": true,
+  "acceptance_required": true,
+  "architecture_review_required": true,
+  "tests_required": true
+}

versions/proposals/V1R4C2-task-center-operations-capability.json

@@ -0,0 +1,21 @@
+{
+  "version": "V1R4C2",
+  "type": "R",
+  "name": "AIOS Task Center Operations Capability",
+  "status": "proposal",
+  "reason": "Create unified task lifecycle management for autonomous operations.",
+  "changes": [
+    "task lifecycle engine",
+    "task source ingestion",
+    "task orchestration",
+    "task event loop",
+    "task statistics",
+    "task operation dashboard"
+  ],
+  "breaking_change": false,
+  "architecture_review_required": true,
+  "owner_gate_required": false,
+  "large_architecture_change": false,
+  "tests_required": true,
+  "user_acceptance_required": true
+}