feat(actions): add GPT Actions consequential governance

active-runtime/app/agent_event_api.py

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

active-runtime/app/agent_event_bus.py

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

active-runtime/app/agent_event_dashboard.py

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

active-runtime/app/aios_chatgpt_actions_api.py

@@ -1,95 +1,334 @@
 #!/usr/bin/env python3
-""" AI GitOps Actions API """
-import asyncio, base64, hashlib, hmac, json, os, re, shutil, subprocess, sys, time, uuid
+from __future__ import annotations
+import hashlib, hmac, json, os, re, subprocess, time, urllib.parse, uuid
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
-from urllib.parse import parse_qs, urlparse
+from typing import Any
 
-from aiohttp import web
+ROOT = Path(os.getenv('AIOS_GITOPS_ROOT', '/data/aios-gitops'))
+WS = Path(os.getenv('AIOS_GITOPS_WORKSPACE', str(ROOT / 'workspace')))
+SECRETS = Path(os.getenv('AIOS_GITOPS_SECRETS_DIR', str(ROOT / 'runtime' / 'secrets')))
+TOKEN_FILE = Path(os.getenv('AIOS_GITOPS_TOKEN_FILE', str(SECRETS / 'gitops.tokens')))
+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')))
+BASE_MODELS = [
+  {'id':'base.deepseekv4-flash','provider':'one-api','model':'deepseekv4-flash','display_name':'DeepSeek V4 Flash','scope':'global'},
+  {'id':'base.qwen3.6-35b','provider':'one-api','model':'qwen3.6-35b','display_name':'Qwen 3.6 35B','scope':'global'},
+  {'id':'base.gpt-5.5','provider':'openai','model':'gpt-5.5','display_name':'GPT-5.5','scope':'global'},
+]
+SECRET_RE = re.compile(r'(?i)(api[_-]?key|secret[_-]?access[_-]?key|secret|password|token)\s*[:=]\s*["\']?([A-Za-z0-9_./+=:-]{16,})')
+SECRET_VAL_RE = re.compile(r'(sk-[A-Za-z0-9_-]{20,}|HPUA[A-Z0-9]{10,}|SDC[A-Za-z0-9]{20,})')
+SECRET_TEXT_RE = re.compile(r'(?i)(Bearer\\s+[A-Za-z0-9._-]{3,}|BEGIN\\s+PRIVATE\\s+KEY|password\\s*=\\s*\\S+|api_key\\s*=\\s*\\S+|access_token\\s*=\\s*\\S+|refresh_token\\s*=\\s*\\S+)')
+SECRET_PATH_PREFIXES = ('runtime/secrets/', 'private/', 'prod-secrets/')
+LOW_RISK_FILE_SCOPES = {
+    '/api/gitops/report-file': ('commitReportFile', ('reports/',)),
+    '/api/gitops/docs-file': ('commitDocsFile', ('docs/',)),
+    '/api/gitops/proposal-file': ('commitProposalFile', ('proposals/',)),
+    '/api/gitops/patch-evidence': ('commitPatchEvidence', ('reports/', 'patches/')),
+}
 
-# Environment
-WS = Path(os.environ.get("AIOS_WORKSPACE", "/data/aios-gitops/workspace"))
-BASE_DIR = WS / "active-runtime"
-APPDIR = BASE_DIR / "app"
-AUDITDIR = WS / "audit"
-WORKDIR = WS / "work"
-DOTDIR = WS.parent
-GITEA_DIR = DOTDIR / "runtime" / "gitea-bin" / "data" / "repositories" / "aios"
+def now() -> str: return time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime())
+def uid(p='id') -> str: return f'{p}-{int(time.time()*1000)}-{uuid.uuid4().hex[:8]}'
+def safe(s: str, n=160) -> str: return re.sub(r'[^A-Za-z0-9_./@-]+', '-', str(s or 'unknown')).strip('/-')[:n] or 'unknown'
+def sh(args, check=False):
+    p = subprocess.run(['git'] + args, cwd=str(WS), text=True, capture_output=True)
+    if check and p.returncode != 0: raise RuntimeError(p.stderr or p.stdout or 'git failed')
+    return {'code':p.returncode,'stdout':p.stdout.strip(),'stderr':p.stderr.strip(),'cmd':['git']+args}
+def jload(p: Path, default):
+    try: return json.loads(p.read_text(encoding='utf-8'))
+    except Exception: return default
+def relpath(path: str) -> str:
+    x = str(path or '').replace('\\','/').strip()
+    if not x or x.startswith('/') or '..' in Path(x).parts or Path(x).parts[0] == '.git': raise ValueError('invalid path')
+    return str(Path(x))
 
-# Load config
-try:
-    import yaml
-    config_path = WS / "active-runtime" / "app" / "config.yaml"
-    with open(config_path) as f:
-        CONFIG = yaml.safe_load(f) or {}
-except: CONFIG = {}
+def secret_path(path: str) -> bool:
+    r = relpath(path).replace('\\', '/')
+    name = Path(r).name
+    return name.endswith('.token') or r == '.env' or any(r.startswith(prefix) for prefix in SECRET_PATH_PREFIXES)
 
-start_time = time.time()
-log_ident = "aios-api"
+def path_in_scope(path: str, scopes: tuple[str, ...]) -> bool:
+    r = relpath(path).replace('\\', '/')
+    return any(r.startswith(scope) for scope in scopes)
+def branch_name(name: str | None, prefix='patch/chatgpt') -> str:
+    b = safe(name or f'{prefix}-{uid("br")}', 180)
+    if b in ('main','master') or b.startswith('main/') or b.startswith('master/'): raise ValueError('direct main/master writes are forbidden')
+    return b
+def _json_has_plain_secret(obj: Any) -> bool:
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            lk = str(k).lower()
+            if lk == 'secret_ref' or lk.endswith('_secret_ref'):
+                continue
+            if lk in {'api_key', 'access_key', 'secret_access_key', 'secret_key', 'password', 'token', 'bearer_token'}:
+                if isinstance(v, str) and v and not v.startswith('secret://') and v != 'REDACTED':
+                    return True
+            if _json_has_plain_secret(v):
+                return True
+        return False
+    if isinstance(obj, list):
+        return any(_json_has_plain_secret(x) for x in obj)
+    if isinstance(obj, str):
+        return bool(obj and not obj.startswith('secret://') and obj != 'REDACTED' and SECRET_VAL_RE.search(obj))
+    return False
 
-def sh(cmd, **kw):
-    try: 
-        r = subprocess.run(cmd, capture_output=True, text=True, cwd=WS, **kw)
-        return r.stdout.strip() if r else None
-    except: return None
+def content_has_secret(text: str) -> bool:
+    text = text or ''
+    try:
+        return _json_has_plain_secret(json.loads(text))
+    except Exception:
+        pass
+    if SECRET_VAL_RE.search(text) or SECRET_TEXT_RE.search(text):
+        return True
+    for m in SECRET_RE.finditer(text):
+        key = str(m.group(1)).lower()
+        value = str(m.group(2))
+        if 'secret_ref' in key or value.startswith('secret://') or value == 'REDACTED':
+            continue
+        return True
+    return False
+def token_records():
+    if not TOKEN_FILE.exists(): return []
+    out=[]
+    for raw in TOKEN_FILE.read_text(encoding='utf-8').splitlines():
+        line=raw.strip()
+        if not line or line.startswith('#'): continue
+        if line.startswith('{'):
+            try: out.append(json.loads(line))
+            except Exception: pass
+        else:
+            out.append({'account':'legacy-token','role':'owner','scopes':['*'],'token_plain':line})
+    return out
+def authenticate(token: str):
+    if os.getenv('AIOS_GITOPS_DEV_ALLOW','0') == '1': return {'account':'dev-owner','role':'owner','scopes':['*']}
+    if not token: return None
+    digest=hashlib.sha256(token.encode()).hexdigest()
+    for r in token_records():
+        if r.get('disabled'): continue
+        if r.get('token_sha256') and hmac.compare_digest(str(r['token_sha256']), digest): return r
+        if r.get('token_plain') and hmac.compare_digest(str(r['token_plain']), token): return r
+    return None
+def sanitize(obj: Any) -> Any:
+    if isinstance(obj, dict):
+        return {k: ('REDACTED' if re.search(r'(?i)(api[_-]?key|secret|password|token)', str(k)) else sanitize(v)) for k,v in obj.items()}
+    if isinstance(obj, list): return [sanitize(x) for x in obj]
+    if isinstance(obj, str): return SECRET_VAL_RE.sub('REDACTED', obj)
+    return obj
+def ensure_git():
+    if not sh(['config','user.email'])['stdout']: sh(['config','user.email','chatgpt-gitops-bot@cnnetmkt.top'], True)
+    if not sh(['config','user.name'])['stdout']: sh(['config','user.name','chatgpt-gitops-bot'], True)
+def checkout(branch, base='main', create=False):
+    ensure_git(); b=branch_name(branch)
+    if create or sh(['rev-parse','--verify',b])['code'] != 0:
+        sh(['checkout',base], True); sh(['checkout','-B',b], True)
+    else: sh(['checkout',b], True)
+    return b
+def write_file(path, content):
+    r=relpath(path)
+    if secret_path(r): raise ValueError('secret_path_rejected: use runtime secret store or secret_ref')
+    if content_has_secret(content): raise ValueError('secret_rejected: use secret_ref; plaintext API keys must not enter Git')
+    t=WS/r; t.parent.mkdir(parents=True, exist_ok=True); t.write_text(content, encoding='utf-8'); return r
+def write_json(path, data): return write_file(path, json.dumps(data, ensure_ascii=False, indent=2) + '\n')
+def sync_branch(branch: str) -> dict:
+    if not branch or branch in ('main','master') or branch.startswith('main/') or branch.startswith('master/'):
+        return {'status':'skipped','reason':'protected_branch','branch':branch}
+    if BARE_REPO.exists():
+        ref=f'refs/heads/{branch}:refs/heads/{branch}'
+        p=subprocess.run(['git','--git-dir',str(BARE_REPO),'fetch',str(WS),ref], text=True, capture_output=True)
+        if p.returncode != 0: raise RuntimeError(p.stderr or p.stdout or f'git sync failed for {branch}')
+        return {'status':'synced','target':'bare','branch':branch,'stdout':p.stdout.strip(),'stderr':p.stderr.strip()}
+    p=subprocess.run(['git','push','origin',f'HEAD:refs/heads/{branch}'], cwd=str(WS), text=True, capture_output=True)
+    if p.returncode != 0: raise RuntimeError(p.stderr or p.stdout or f'git push failed for {branch}')
+    return {'status':'synced','target':'origin','branch':branch,'stdout':p.stdout.strip(),'stderr':p.stderr.strip()}
 
-def baselines():
-    p = WS / "baselines" / "current.json"
-    if p.exists():
-        try: return json.loads(p.read_text())
-        except: pass
-    return {}
+def sync_tag(tag: str) -> dict:
+    if not tag: return {'status':'skipped','reason':'empty_tag'}
+    if BARE_REPO.exists():
+        ref=f'refs/tags/{tag}:refs/tags/{tag}'
+        p=subprocess.run(['git','--git-dir',str(BARE_REPO),'fetch',str(WS),ref], text=True, capture_output=True)
+        if p.returncode != 0: raise RuntimeError(p.stderr or p.stdout or f'git tag sync failed for {tag}')
+        return {'status':'synced','target':'bare','tag':tag,'stdout':p.stdout.strip(),'stderr':p.stderr.strip()}
+    p=subprocess.run(['git','push','origin',tag], cwd=str(WS), text=True, capture_output=True)
+    if p.returncode != 0: raise RuntimeError(p.stderr or p.stdout or f'git tag push failed for {tag}')
+    return {'status':'synced','target':'origin','tag':tag,'stdout':p.stdout.strip(),'stderr':p.stderr.strip()}
 
-def commands(status):
-    d = WS / "agents" / "commands" / status
-    if not d.exists(): return []
-    return [{"name": f.name, "state": status} for f in sorted(d.iterdir()) if f.name.endswith(".md")]
+def commit(paths, msg):
+    ensure_git(); paths = [relpath(p) for p in paths] if paths else ['.']; sh(['add'] + paths, True)
+    branch=sh(['rev-parse','--abbrev-ref','HEAD'])['stdout']
+    if not sh(['status','--short'])['stdout']:
+        return {'status':'no_changes','branch':branch,'sync':sync_branch(branch)}
+    out=sh(['commit','-m',msg], True); branch=sh(['rev-parse','--abbrev-ref','HEAD'])['stdout']; sync=sync_branch(branch); return {'status':'committed','branch':branch,'rev':sh(['rev-parse','--short','HEAD'], True)['stdout'],'git':out,'sync':sync}
+def audit(actor, action, target, payload):
+    p=ROOT/'artifacts'/'chatgpt-gitops-audit.jsonl'; p.parent.mkdir(parents=True, exist_ok=True)
+    with p.open('a', encoding='utf-8') as f: f.write(json.dumps({'at':now(),'actor':actor,'action':action,'target':target,'payload':sanitize(payload)}, ensure_ascii=False)+'\n')
+def model_docs():
+    out=[]
+    for p in sorted((WS/'config'/'model_registry').glob('**/*.json')): out.append(jload(p, {'path':str(p.relative_to(WS))}))
+    return out
+def patches():
+    out=[]
+    for p in sorted((WS/'patches').glob('**/*.json')): out.append(jload(p, {'path':str(p.relative_to(WS))}))
+    return out
 
-def agent_runs():
-    d = AUDITDIR / "agent-runs"
-    if not d.exists(): return []
-    rs = []
-    for f in sorted(d.iterdir(), reverse=True):
-        if f.name.endswith(".json"):
-            try:
-                j = json.loads(f.read_text())
-                j["file"] = f.stem
-                rs.append(j)
-            except: pass
-    return rs
+class H(BaseHTTPRequestHandler):
+    server_version='AIOSChatGPTGitOps/V1R1C0'
+    def sendj(self, data, code=200):
+        b=json.dumps(data, ensure_ascii=False, indent=2).encode(); self.send_response(code); self.send_header('Content-Type','application/json; charset=utf-8'); self.send_header('Content-Length',str(len(b))); self.end_headers(); self.wfile.write(b)
+    def sendt(self, text, ctype='text/plain; charset=utf-8', code=200):
+        b=text.encode(); self.send_response(code); self.send_header('Content-Type',ctype); self.send_header('Content-Length',str(len(b))); self.end_headers(); self.wfile.write(b)
+    def body(self):
+        n=int(self.headers.get('Content-Length','0') or '0'); raw=self.rfile.read(n).decode() if n else '{}'
+        try: return json.loads(raw or '{}')
+        except Exception: return {'_raw':raw}
+    def actor(self):
+        auth=self.headers.get('Authorization',''); tok=auth[7:].strip() if auth.startswith('Bearer ') else self.headers.get('X-AIOS-Token','')
+        rec=authenticate(tok)
+        if rec: return {'ok':True,'account':safe(rec.get('account') or rec.get('name') or 'token-user'),'role':rec.get('role','user'),'scopes':set(rec.get('scopes') or [])}
+        return {'ok':False,'account':'anonymous','role':'anonymous','scopes':set()}
+    def need(self, scope):
+        a=self.actor()
+        if not a['ok']: self.sendj({'error':'unauthorized','hint':'Bearer token required'},401); return None
+        if '*' not in a['scopes'] and scope not in a['scopes']: self.sendj({'error':'forbidden','required_scope':scope,'account':a['account']},403); return None
+        return a
+    def do_GET(self):
+        u=urllib.parse.urlparse(self.path); path=u.path.rstrip('/') if u.path != '/' else u.path; q=urllib.parse.parse_qs(u.query)
+        try:
+            if path in ('/health','/api/health'): return self.sendj({'status':'ok','service':'chatgpt-gitops-adapter','workspace':str(WS)})
+            if path in ('/api/openapi.yaml','/api/openapi-chatgpt-actions.yaml','/api/schema'):
+                return self.sendt(OPENAPI.read_text(encoding='utf-8'), 'application/yaml; charset=utf-8') if OPENAPI.exists() else self.sendj({'error':'schema_missing'},404)
+            if path in ('/api','/api/status'): return self.sendj(api_spec())
+            if path in ('/api/base','/base'):
+                data=jload(WS/'baseline'/'current.json', {}); data.setdefault('git', sh(['rev-parse','--short','HEAD'])['stdout']); return self.sendj(data)
+            if path in ('/api/ver','/ver'):
+                return self.sendj({'tags':sh(['tag','--list','V*'])['stdout'].splitlines(),'versions_dir':[p.name for p in (WS/'versions').glob('*')],'head':sh(['rev-parse','--short','HEAD'])['stdout']})
+            if path in ('/api/diff','/diff'):
+                frm=(q.get('from') or ['HEAD~1'])[0]; to=(q.get('to') or ['HEAD'])[0]; return self.sendj({'from':frm,'to':to,'diff':sh(['diff',frm,to])})
+            if path in ('/api/patch','/patch'): return self.sendj({'patches':patches(),'branches':sh(['branch','--format','%(refname:short)'])['stdout'].splitlines()})
+            if path in ('/api/model','/model'): return self.sendj({'base':BASE_MODELS,'custom':model_docs(),'priority':[jload(p,{}) for p in sorted((WS/'config'/'model_priority').glob('*.json'))]})
+            if path in ('/api/run','/run'):
+                svc=subprocess.run(['systemctl','is-active','aios-gitops-model-api'], text=True, capture_output=True)
+                return self.sendj({'service':'aios-gitops-model-api','status':svc.stdout.strip() or svc.stderr.strip(),'workspace_branch':sh(['rev-parse','--abbrev-ref','HEAD'])['stdout']})
+            return self.sendj({'error':'not_found','path':path},404)
+        except Exception as e: return self.sendj({'error':str(e)},500)
+    def do_PUT(self):
+        path=urllib.parse.urlparse(self.path).path.rstrip('/'); data=self.body()
+        if path == '/api/model-priority': return self.model_priority(data)
+        return self.sendj({'error':'not_found','path':path},404)
+    def do_POST(self):
+        path=urllib.parse.urlparse(self.path).path.rstrip('/'); data=self.body()
+        try:
+            if path == '/api/branch': return self.branch(data)
+            if path in LOW_RISK_FILE_SCOPES: return self.low_risk_file(path, data)
+            if path == '/api/gitops/main-file': return self.main_file(data)
+            if path == '/api/gitops/rollback-request': return self.rollback(data)
+            if path == '/api/file': return self.file(data)
+            if path == '/api/commit': return self.commit(data)
+            if path == '/api/patch': return self.patch(data)
+            if path == '/api/tag': return self.tag(data)
+            if path == '/api/rollback': return self.rollback(data)
+            if path == '/api/model': return self.model(data)
+            if path == '/api/model-priority': return self.model_priority(data)
+            if path == '/api/nl': return self.nl(data)
+            return self.sendj({'error':'not_found','path':path},404)
+        except Exception as e: return self.sendj({'error':str(e)},500)
+    def branch(self,data):
+        a=self.need('branch:create');
+        if not a: return
+        b=checkout(data.get('branch'), data.get('base','main'), True); meta={'type':'branch','branch':b,'base':data.get('base','main'),'created_by':a['account'],'created_at':now(),'direct_main_push':False,'owner_approval_required':True}
+        r=write_json(f'patches/{safe(b).replace("/","_")}.branch.json', meta); c=commit([r], data.get('message') or f'chore(chatgpt): create {b}'); audit(a['account'],'branch',b,meta); self.sendj({'status':'ok','branch':b,'commit':c})
+    def file(self,data):
+        a=self.need('file:write');
+        if not a: return
+        b=checkout(data.get('branch'), data.get('base','main'), bool(data.get('create_branch'))); r=write_file(data.get('path'), data.get('content','')); c=commit([r], data.get('message') or f'chore(chatgpt): update {r}'); audit(a['account'],'file',r,{'branch':b,'commit':c}); self.sendj({'status':'committed','branch':b,'path':r,'commit':c})
+    def low_risk_file(self,path,data):
+        a=self.need('file:write');
+        if not a: return
+        operation_id, scopes = LOW_RISK_FILE_SCOPES[path]
+        requested_branch = data.get('branch')
+        if not requested_branch or branch_name(requested_branch) != requested_branch:
+            return self.sendj({'error':'low-risk write requires explicit non-main patch/request branch','operationId':operation_id},400)
+        r=relpath(data.get('path'))
+        if secret_path(r):
+            return self.sendj({'error':'Secret-like path rejected. Use runtime secret store or secret_ref.','operationId':operation_id},400)
+        if not path_in_scope(r, scopes):
+            return self.sendj({'error':'path_out_of_scope','operationId':operation_id,'allowed_scopes':list(scopes)},400)
+        if content_has_secret(data.get('content','')):
+            return self.sendj({'error':'Secret-like content detected. Use runtime secret store or secret_ref.','operationId':operation_id},400)
+        b=checkout(requested_branch, data.get('base','main'), bool(data.get('create_branch')))
+        r=write_file(r, data.get('content',''))
+        c=commit([r], data.get('message') or f'chore(chatgpt): {operation_id} {r}')
+        audit(a['account'],operation_id,r,{'branch':b,'commit':c})
+        self.sendj({'status':'committed','operationId':operation_id,'branch':b,'path':r,'commit':c})
+    def main_file(self,data):
+        a=self.need('file:main');
+        if not a: return
+        if a.get('role') != 'owner':
+            return self.sendj({'error':'owner approval required for commitMainFile'},403)
+        r=relpath(data.get('path'))
+        if secret_path(r):
+            return self.sendj({'error':'Secret-like path rejected. Use runtime secret store or secret_ref.','operationId':'commitMainFile'},400)
+        if content_has_secret(data.get('content','')):
+            return self.sendj({'error':'Secret-like content detected. Use runtime secret store or secret_ref.','operationId':'commitMainFile'},400)
+        ensure_git(); sh(['checkout','main'], True)
+        r=write_file(r, data.get('content',''))
+        c=commit([r], data.get('message') or f'chore(chatgpt): commit main file {r}')
+        audit(a['account'],'commitMainFile',r,{'branch':'main','commit':c})
+        self.sendj({'status':'committed','operationId':'commitMainFile','branch':'main','path':r,'commit':c})
+    def commit(self,data):
+        a=self.need('commit:create');
+        if not a: return
+        b=checkout(data.get('branch') or sh(['rev-parse','--abbrev-ref','HEAD'])['stdout'], data.get('base','main'), False); paths=data.get('paths') or ['.']; paths=[paths] if isinstance(paths,str) else paths; c=commit(paths, data.get('message') or 'chore(chatgpt): commit changes'); audit(a['account'],'commit',b,{'paths':paths,'commit':c}); self.sendj({'status':c['status'],'branch':b,'commit':c})
+    def patch(self,data):
+        a=self.need('patch:create');
+        if not a: return
+        name=data.get('patch_name') or data.get('name') or uid('patch'); b=checkout(data.get('branch') or f'patch/{safe(name)}', data.get('base','main'), True); meta={'id':uid('patch'),'patch_name':name,'branch':b,'risk':data.get('risk','medium'),'description':data.get('description',''),'created_by':a['account'],'created_at':now()}
+        r=write_json(f'patches/{safe(name)}.json', meta); c=commit([r], data.get('message') or f'chore(chatgpt): create patch {name}'); audit(a['account'],'patch',name,meta); self.sendj({'status':'patch_branch_created','patch':meta,'commit':c})
+    def tag(self,data):
+        a=self.need('tag:create');
+        if not a: return
+        ver=data.get('version') or data.get('tag')
+        if not re.match(r'^V\d+R\d+C\d+(-[A-Za-z0-9_.-]+)?$', ver or ''): return self.sendj({'error':'version must match VxRxCx'},400)
+        if a['role'] != 'owner' or not data.get('execute'):
+            b=checkout(data.get('branch') or f'request/tag-{safe(ver)}', 'main', True); req={'version':ver,'requested_by':a['account'],'approval_required':True,'created_at':now()}; r=write_json(f'baseline/tag_requests/{safe(ver)}.json', req); c=commit([r], f'chore(chatgpt): request tag {ver}'); return self.sendj({'status':'approval_required','branch':b,'commit':c})
+        out=sh(['tag','-a',ver,'-m',data.get('message') or f'release {ver}'], True); self.sendj({'status':'tagged','version':ver,'git':out,'sync':sync_tag(ver)})
+    def rollback(self,data):
+        a=self.need('rollback:request');
+        if not a: return
+        target=data.get('target_version') or data.get('version') or data.get('target')
+        if not target: return self.sendj({'error':'target_version required'},400)
+        b=checkout(data.get('branch') or f'request/rollback-{safe(target)}-{uid("rb")}', 'main', True); req={'id':uid('rollback'),'target_version':target,'reason':data.get('reason',''),'requested_by':a['account'],'approval_required':True,'execute':False,'created_at':now()}; r=write_json(f'baseline/rollback_requests/{safe(req["id"])}.json', req); c=commit([r], f'chore(chatgpt): request rollback {target}'); self.sendj({'status':'rollback_request_committed','branch':b,'request':req,'commit':c})
+    def model(self,data):
+        a=self.need('model:write');
+        if not a: return
+        name=data.get('model_name') or data.get('model'); base=(data.get('base_url') or '').rstrip('/'); prov=data.get('provider_name') or 'custom-provider'
+        if not name or not base: return self.sendj({'error':'provider_name/base_url/model_name required'},400)
+        owner=safe(data.get('username') or a['account']); secret_ref=data.get('api_key_secret_ref') or data.get('secret_ref')
+        if data.get('api_key'):
+            d=SECRETS/'llm'/owner; d.mkdir(parents=True, exist_ok=True); sid=uid('llmkey'); p=d/f'{sid}.secret'; p.write_text(str(data['api_key']), encoding='utf-8'); os.chmod(p,0o600); secret_ref=f'secret://llm/{owner}/{sid}'
+        if not secret_ref: return self.sendj({'error':'api_key_secret_ref or api_key required'},400)
+        mid=data.get('model_id') or f'custom.{owner}.{hashlib.sha1((prov+base+name).encode()).hexdigest()[:10]}'; b=checkout(data.get('branch') or f'patch/model-{safe(mid)}','main',True)
+        doc=sanitize({k:v for k,v in data.items() if k!='api_key'}); doc.update({'model_id':mid,'provider_name':prov,'base_url':base,'model_name':name,'api_key_secret_ref':secret_ref,'created_by':a['account'],'created_at':now()})
+        r=write_json(f'config/model_registry/chatgpt/{safe(mid)}.json', doc); c=commit([r], data.get('message') or f'chore(chatgpt): register model {name}'); audit(a['account'],'model',mid,doc); self.sendj({'status':'model_registered','branch':b,'model_id':mid,'secret_ref':secret_ref,'commit':c})
+    def model_priority(self,data):
+        a=self.need('model:priority');
+        if not a: return
+        user=safe(data.get('username') or a['account']); b=checkout(data.get('branch') or f'patch/model-priority-{user}', 'main', True); doc={'username':user,'items':data.get('items') or data.get('priority') or [],'updated_by':a['account'],'updated_at':now()}; r=write_json(f'config/model_priority/{user}.json', doc); c=commit([r], data.get('message') or f'chore(chatgpt): update model priority {user}'); audit(a['account'],'model-priority',user,doc); self.sendj({'status':'updated','branch':b,'priority':doc,'commit':c})
+    def nl(self,data):
+        a=self.need('nl:plan');
+        if not a: return
+        text=data.get('text',''); low=text.lower(); intent='unknown'; plan=[]
+        if 'rollback' in low or '回滚' in text: intent='rollback_request'; plan=['commit rollback request','wait owner/admin approval']
+        elif 'diff' in low or '对比' in text: intent='diff'; plan=['call GET /api/diff']
+        elif 'model' in low or '模型' in text: intent='model_change'; plan=['use POST /api/model or PUT /api/model-priority','commit metadata']
+        elif 'patch' in low or '补丁' in text: intent='patch_create'; plan=['call POST /api/patch']
+        b=checkout(data.get('branch') or f'patch/nl-{uid("nl")}', 'main', True); doc={'id':uid('nl'),'text':text,'intent':intent,'action_plan':plan,'execute':False,'owner_approval_required':True,'created_by':a['account'],'created_at':now()}; r=write_json(f'patches/nl/{safe(doc["id"])}.json', doc); c=commit([r], f'chore(chatgpt): record nl plan {intent}'); self.sendj({'status':'planned','branch':b,'request':doc,'commit':c})
 
-async def handle_api(request):
-    path = request.path
-    if path in ('/admin/ai-evolution','/admin/ai-evolution/'):
-        # Serve the HTML page
-        html_path = APPDIR / 'static' / 'admin-ai-evolution.html'
-        if html_path.exists():
-            return web.Response(text=html_path.read_text(), content_type='text/html')
-        return web.Response(text='Dashboard not found', status=404)
-    if path == '/admin/ai-evolution/api/data':
-        result = subprocess.run(['git','tag','--list','V*'], capture_output=True, text=True, cwd=WS)
-        tags = result.stdout.strip().splitlines() if result.returncode == 0 else []
-        h = subprocess.run(['git','rev-parse','--short','HEAD'], capture_output=True, text=True, cwd=WS)
-        head = h.stdout.strip() if h.returncode == 0 else 'unknown'
-        b = subprocess.run(['git','rev-parse','--abbrev-ref','HEAD'], capture_output=True, text=True, cwd=WS)
-        branch = b.stdout.strip() if b.returncode == 0 else 'unknown'
-        return web.json_response({
-            'baseline': baselines(),
-            'versions': [{'tag':t,'name':p.name} for p in sorted((WS/'versions').glob('*')) for t in tags if p.name in t],
-            'commands': commands('active') + commands('running') + commands('completed'),
-            'agent_runs': agent_runs(),
-            'stats': {
-                'current': head,
-                'branch': branch,
-                'uptime': round(time.time()-start_time, 2),
-                'baseline': baselines().get('current_baseline','unknown'),
-            }
-        })
-    return web.json_response({'error':'not_found','path':path}, status=404)
+def api_spec():
+    return {'version':'V1R1C0-chatgpt-actions','openapi':'/api/openapi.yaml','read':['GET /api/base','GET /api/ver','GET /api/diff','GET /api/patch','GET /api/model','GET /api/run'],'write':['POST /api/branch','POST /api/file','POST /api/gitops/report-file','POST /api/gitops/docs-file','POST /api/gitops/proposal-file','POST /api/gitops/patch-evidence','POST /api/gitops/main-file','POST /api/commit','POST /api/patch','POST /api/tag','POST /api/rollback','POST /api/gitops/rollback-request','POST /api/model','PUT /api/model-priority','POST /api/nl'],'policy':{'bearer_required_for_write':True,'direct_main_push':False,'low_risk_main_write':False,'delete_tag':False,'owner_approval_required_for_v_level':True,'api_keys_in_git':False,'git_secret_field':'secret_ref','online_git_sync':True}}
 
-app = web.Application()
-app.router.add_route('GET', '/admin/ai-evolution', handle_api)
-app.router.add_route('GET', '/admin/ai-evolution/', handle_api)
-app.router.add_route('GET', '/admin/ai-evolution/api/data', handle_api)
-
-if __name__ == '__main__':
-    web.run_app(app, host='127.0.0.1', port=18890)
+def main():
+    print(f'AIOS ChatGPT GitOps adapter listening on {HOST}:{PORT}')
+    ThreadingHTTPServer((HOST,PORT), H).serve_forever()
+if __name__ == '__main__': main()

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

@@ -1,99 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-<meta charset="UTF-8">
-<meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>AI Evolution Dashboard</title>
-<style>
-* { margin: 0; padding: 0; box-sizing: border-box; }
-body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif; background: #0d1117; color: #c9d1d9; height: 100vh; overflow: hidden; }
-.app { display: flex; height: 100vh; }
-.sidebar { width: 260px; background: #161b22; border-right: 1px solid #30363d; padding: 20px; display: flex; flex-direction: column; gap: 16px; }
-.sidebar h1 { font-size: 18px; color: #f0f6fc; border-bottom: 1px solid #30363d; padding-bottom: 12px; margin-bottom: 8px; }
-.sidebar-nav { list-style: none; display: flex; flex-direction: column; gap: 4px; }
-.sidebar-nav li { padding: 8px 12px; border-radius: 6px; cursor: pointer; font-size: 14px; color: #8b949e; }
-.sidebar-nav li:hover, .sidebar-nav li.active { background: #1f6feb22; color: #58a6ff; }
-.sidebar-nav li i { margin-right: 8px; }
-.main { flex: 1; padding: 24px; overflow-y: auto; }
-.main-header { display: flex; justify-content: space-between; align-items: center; margin-bottom: 24px; }
-.main-header h2 { font-size: 20px; }
-.status-badge { padding: 4px 12px; border-radius: 12px; font-size: 12px; font-weight: 600; text-transform: uppercase; }
-.status-badge.ok { background: #1b3a2d; color: #3fb950; border: 1px solid #3fb95044; }
-.status-badge.degraded { background: #3a2e1b; color: #d29922; border: 1px solid #d2992244; }
-.status-badge.fail { background: #3a1b1b; color: #f85149; border: 1px solid #f8514944; }
-.card { background: #161b22; border: 1px solid #30363d; border-radius: 8px; padding: 16px; margin-bottom: 16px; }
-.card-title { font-size: 14px; color: #8b949e; margin-bottom: 8px; }
-.card-value { font-size: 28px; font-weight: 700; color: #f0f6fc; }
-.row { display: flex; gap: 16px; }
-.col { flex: 1; }
-.grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); gap: 16px; }
-pre { white-space: pre-wrap; word-break: break-word; }
-.command-item { padding: 12px; margin-bottom: 8px; border-radius: 6px; background: #0d1117; border: 1px solid #21262d; }
-.command-item .meta { display: flex; gap: 8px; align-items: center; font-size: 12px; color: #8b949e; }
-.command-item .name { font-size: 14px; color: #58a6ff; font-weight: 600; }
-.command-item .state { font-size: 11px; padding: 2px 8px; border-radius: 10px; text-transform: uppercase; }
-.state-active { background: #1b3a2d; color: #3fb950; }
-.state-running { background: #3a2e1b; color: #d29922; }
-.state-completed { background: #1b3a2d; color: #3fb950; }
-.state-failed { background: #3a1b1b; color: #f85149; }
-.loading { text-align: center; padding: 40px; color: #8b949e; }
-.error { padding: 20px; background: #3a1b1b; border: 1px solid #f8514944; border-radius: 8px; color: #f85149; margin-bottom: 16px; }
-.version-item { padding: 8px 12px; background: #0d1117; border: 1px solid #21262d; border-radius: 6px; margin-bottom: 4px; display: flex; justify-content: space-between; }
-.version-item .tag { color: #58a6ff; font-weight: 600; }
-.version-item .name { color: #8b949e; font-size: 13px; }
-.agent-item { background: #0d1117; border: 1px solid #21262d; border-radius: 6px; margin-bottom: 8px; padding: 12px; }
-.agent-item .agent-title { font-size: 14px; font-weight: 600; color: #c9d1d9; margin-bottom: 4px; }
-.agent-item .agent-meta { font-size: 12px; color: #8b949e; }
-.agent-run-item { padding: 8px 12px; margin-bottom: 4px; border-radius: 4px; background: #0d1117; border: 1px solid #21262d; display: flex; justify-content: space-between; align-items: center; }
-.agent-run-item .run-id { color: #58a6ff; font-size: 13px; font-weight: 600; }
-.agent-run-item .source { color: #8b949e; font-size: 12px; }
-</style>
-</head>
-<body>
-<div id="app" class="app">
-  <div class="sidebar">
-    <h1>🕹️ AI Evolution Dashboard</h1>
-    <ul class="sidebar-nav">
-      <li class="active" onclick="showPanel('overview')"><i>📊</i> Overview</li>
-      <li onclick="showPanel('versions')"><i>🏷️</i> Versions</li>
-      <li onclick="showPanel('commands')"><i>⚡</i> Commands</li>
-      <li onclick="showPanel('agents')"><i>🤖</i> Agent Runs</li>
-    </ul>
-  </div>
-  <div class="main">
-    <div id="panel-overview" class="panel">
-      <div class="main-header">
-        <h2>System Overview</h2>
-        <div id="header-status" class="status-badge">Loading...</div>
-      </div>
-      <div id="loading" class="loading">Loading...</div>
-      <div id="error" class="error" style="display:none;"></div>
-      <div id="content">
-        <div class="row">
-          <div class="col"><div class="card"><div class="card-title">Current Baseline</div><div id="base" class="card-value">-</div></div></div>
-          <div class="col"><div class="card"><div class="card-title">Git Branch</div><div id="branch" class="card-value">-</div></div></div>
-          <div class="col"><div class="card"><div class="card-title">Uptime</div><div id="uptime" class="card-value">-</div></div></div>
-        </div>
-        <div class="card" style="margin-top:16px">
-          <div class="card-title">Event Bus Status</div>
-          <pre id="bus-status">-</pre>
-        </div>
-      </div>
-    </div>
-    <div id="panel-versions" class="panel" style="display:none;">
-      <div class="main-header"><h2>Version Timeline</h2></div>
-      <div id="versions-list">Loading...</div>
-    </div>
-    <div id="panel-commands" class="panel" style="display:none;">
-      <div class="main-header"><h2>Command Lookup</h2></div>
-      <div id="commands-list">Loading...</div>
-    </div>
-    <div id="panel-agents" class="panel" style="display:none;">
-      <div class="main-header"><h2>Recent Agent Executions</h2></div>
-      <div id="agents-list">Loading...</div>
-    </div>
-  </div>
-</div>
-<script>
-async function fetchData() {
-  const r = await fetch('/admin/ai-evolution/api/data');

active-runtime/app/user_profile_isolation.py

@@ -1,68 +0,0 @@
-"""User profile isolation layer for multi-user agents.
-
-Global agent instructions define agent behavior. User preferences must be scoped
-by user identity and session, never stored in a shared USER.md.
-"""
-
-from __future__ import annotations
-
-from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
-from hashlib import sha256
-from pathlib import Path
-import json
-from typing import Any
-
-
-def utc_now() -> str:
-    return datetime.now(timezone.utc).isoformat()
-
-
-def safe_user_key(user_id: str) -> str:
-    return sha256(user_id.encode("utf-8")).hexdigest()[:24]
-
-
-@dataclass
-class UserProfile:
-    user_key: str
-    display_name: str | None = None
-    preferences: dict[str, Any] = field(default_factory=dict)
-    created_at: str = field(default_factory=utc_now)
-    updated_at: str = field(default_factory=utc_now)
-
-    def to_dict(self):
-        return asdict(self)
-
-
-class UserProfileStore:
-    def __init__(self, root: str = "runtime/user-profiles"):
-        self.root = Path(root)
-        self.root.mkdir(parents=True, exist_ok=True)
-
-    def get(self, user_id: str) -> dict[str, Any]:
-        path = self.root / f"{safe_user_key(user_id)}.json"
-        if not path.exists():
-            return UserProfile(user_key=safe_user_key(user_id)).to_dict()
-        return json.loads(path.read_text(encoding="utf-8"))
-
-    def update(self, user_id: str, updates: dict[str, Any]) -> dict[str, Any]:
-        profile = self.get(user_id)
-        if "display_name" in updates:
-            profile["display_name"] = updates["display_name"]
-        profile.setdefault("preferences", {}).update(updates.get("preferences", {}))
-        profile["updated_at"] = utc_now()
-        path = self.root / f"{safe_user_key(user_id)}.json"
-        path.write_text(json.dumps(profile, ensure_ascii=False, indent=2), encoding="utf-8")
-        return profile
-
-    def runtime_context(self, user_id: str) -> dict[str, Any]:
-        profile = self.get(user_id)
-        return {
-            "user_profile": profile,
-            "source": "user_profile_store",
-            "shared_agent_defaults": "USER.md",
-            "isolation": True,
-        }
-
-
-__all__ = ["UserProfile", "UserProfileStore", "safe_user_key"]

agent-instructions/codex/fix-patches-artifact-lifecycle-v1.md

@@ -1,65 +0,0 @@
-# Codex Fix Patches Artifact Lifecycle Instruction
-
-Instruction ID: fix-patches-artifact-lifecycle-v1
-Version: v1
-Target Agent: codex
-
-## Objective
-
-Manage the lifecycle of artifacts in the `patches/` directory — specifically, clean up stale or committed artifacts (`.branch.json`, `nl/*.json`, standalone `.json` patch files) that are no longer needed.
-
-## Background
-
-The ChatGPT Actions API writes several types of artifacts into `patches/`:
-
-1. **Branch metadata** (`patches/patch_*.branch.json`) — created when the `branch()` action writes ahead. These are summary records of created branches.
-2. **Patch files** (`patches/*.json`, top level) — created when the `patch()` action saves a JSON patch proposal. Example: `patches/self-evolution-agent-orchestration-policy.json`.
-3. **Natural language plan files** (`patches/nl/nl-*.json`) — created when `nl()` action records a natural-language plan. These are transient planning artifacts.
-
-None of these files represent durable long-term state. Once committed, they are snapshots of ephemeral decisions. The `patches/` directory should not grow unboundedly with stale artifacts.
-
-## Preconditions
-
-- GitOps authentication healthy.
-- Current working branch should not be diverging from main unnecessarily for this cleanup.
-- Run from the workspace root.
-
-## Steps
-
-### Phase 1: Assess Current State
-
-1. List all files under `patches/`.
-2. For each file, check its git log (`git log --oneline patches/<file>`) to understand its purpose and age.
-3. Identify which files are:
-   - Stale `.branch.json` files describing branches that have already been merged.
-   - Stale `nl/` plan files that were experimental, incomplete, or superseded.
-   - Patch files that are still relevant for the current self-evolution state.
-
-### Phase 2: Clean Up Stale Artifacts
-
-For each stale artifact file:
-1. Remove it with `git rm`.
-2. Create a single commit message describing the batch cleanup, e.g.:
-   `chore(patches): remove stale artifact files [nl/*.json|branch.json]`
-
-### Phase 3: Housekeeping (Optional)
-
-If the file `self-evolution-agent-orchestration-policy.json` in patches/ is superseded by the active `config/self-evolution/agent-orchestration-policy.json`, evaluate whether it should also be removed or kept as reference. Document this decision.
-
-## Constraints
-
-- No force push.
-- No direct production publish.
-- No secret output.
-- Preserve audit trail.
-- Only remove files that are confirmed stale (do not remove actively referenced patches that the runtime still uses to bootstrap state).
-
-## Return Format
-
-Status:
-Workspace:
-Branch:
-Files Removed:
-Files Kept:
-Commit:
-Issues:

agent-instructions/codex/v1r2c2-branch-sync-validation-v1.md

@@ -1,59 +0,0 @@
-# Codex V1R2C2 Branch Sync Validation Instruction
-
-Instruction ID: v1r2c2-branch-sync-validation-v1
-Version: v1
-Target Agent: codex
-
-## Objective
-
-Validate synchronization state of all git branches between local, origin (Gitea), and gitops remote. Identify divergent branches that need reconciliation.
-
-## Preconditions
-
-- GitOps authentication healthy.
-- Run from workspace root (`/data/aios-gitops/workspace`).
-
-## Validation Scope
-
-1. **main branch sync**: local main == origin/main == gitops/main
-2. **patch branch sync**: for each local branch, compare HEAD against origin and gitops remotes
-3. **Current branch**: verify the active working branch is on the correct base
-4. **Untracked files**: check for files that should be committed vs ignored
-
-## Steps
-
-1. Fetch all remotes.
-2. Capture local branch HEAD hashes.
-3. Capture remote origin branch HEAD hashes.
-4. Capture remote gitops branch HEAD hashes.
-5. For each branch, report:
-   - Fully synced: local == origin == gitops
-   - Divergent: local != origin or local != gitops
-   - Missing remote: branch exists locally but not in remote
-6. Check if current branch is based on main or is diverging.
-7. List untracked files that may need governance.
-
-## Return Format
-
-```
-Status: <synced|divergence_found>
-Workspace: /data/aios-gitops/workspace
-Main Sync: <yes|no>
-Main HEAD: <sha>
-Origin/main HEAD: <sha>
-Gitops/main HEAD: <sha>
-Divergent Branches:
-  - <branch name>: <local sha> vs <remote sha> [origin|gitops] (<reason>)
-Missing Remote Branches:
-  - <branch name>: <local sha>
-Untracked File Count: <count>
-Issues:
-- <issue description>
-```
-
-## Constraints
-
-- No force push.
-- No destructive actions.
-- No secret output.
-- Report only; do not auto-resolve discrepancies.

agents/ACKNOWLEDGEMENT.md

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

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

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

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

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

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

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

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

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

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

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

agents/policies/README.md

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

agents/registry.yaml

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

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

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

agents/scripts/agent-command-watcher.py

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

agents/scripts/autonomous_controller.py

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

agents/scripts/autonomous_controller.py.v1

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

agents/state/README.md

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

agents/state/watcher-state.json

@@ -1,15 +0,0 @@
-{
-  "processed": {
-    "CMD-20260708-fix-git-actions-write-and-enable-audit-plane.md": {
-      "hash": "9442e78e3deb35e03227016b2265d34feb4640f8efdcb07baffe06d52ef947c8",
-      "status": "discovered",
-      "discovered_at": "2026-07-08T19:01:32+0800"
-    },
-    "CMD-20260709-enable-autonomous-controller.md": {
-      "hash": "2825811706389130b2f531a2d3814b800b1181598f871b496e5a05fa13adbbec",
-      "status": "running",
-      "discovered_at": "2026-07-08T19:01:45+0800"
-    }
-  },
-  "last_scan": "2026-07-08T21:06:45+0800"
-}

approvals/V1R1C5-migration-owner-approval-20260707.json

@@ -1,27 +0,0 @@
-{
-  "approval_id": "owner-approve-V1R1C5-migration-20260707",
-  "created_at": "2026-07-07T11:46:17+08:00",
-  "approved_by_role": "owner",
-  "approved_via": "openclaw-weixin",
-  "approved_at": "2026-07-07T11:46:17+08:00",
-  "target_branch": "patch/self-evolution-agent-orchestration-policy",
-  "target_base": "main",
-  "target_version": "V1R1C5",
-  "rollback_target": "V1R1C4",
-  "allowed_actions": [
-    "merge_to_main",
-    "create_release_tag",
-    "activate_new_baseline"
-  ],
-  "risk_acceptance": "Owner approved V1R1C5 Agent OS evolution migration to main. Integration tests passed, Hermes review approved, conditional approval gate implemented. Rollback target V1R1C4.",
-  "expires_at": "2026-07-14T23:59:59Z",
-  "constraints": {
-    "direct_main_push": false,
-    "force_push": false,
-    "secrets_in_git": false,
-    "destructive_operations": false,
-    "validation_required": true,
-    "owner_notification_required": true,
-    "web_ui_audit_required": true
-  }
-}

approvals/preapproved/V1R1C5-owner-main-entry-20260707.json

@@ -1,25 +0,0 @@
-{
-  "approval_id": "owner-preapprove-V1R1C5-main-entry-20260707",
-  "created_at": "2026-07-07T00:00:00Z",
-  "approved_by_role": "owner",
-  "target_branch": "patch/web-ui-complete-gitops-dashboard-20260706",
-  "target_base": "main",
-  "target_version": "V1R1C5",
-  "rollback_target": "V1R1C4",
-  "allowed_actions": [
-    "merge_to_main",
-    "create_release_tag",
-    "activate_new_baseline"
-  ],
-  "risk_acceptance": "Owner approved promotion of autonomous GitOps platform control plane to main, subject to validation, OpenClaw supervision, no secret leakage, no direct force push, and rollback target V1R1C4.",
-  "expires_at": "2026-07-14T23:59:59Z",
-  "constraints": {
-    "direct_main_push": false,
-    "force_push": false,
-    "secrets_in_git": false,
-    "destructive_operations": false,
-    "validation_required": true,
-    "owner_notification_required": true,
-    "web_ui_audit_required": true
-  }
-}

architecture/current.json

@@ -1,12 +1,22 @@
 {
-  "active_version": "V1R2C3",
-  "active_tag": "V1R2C3",
-  "previous_version": "V1R2C2",
-  "rollback_version": "V1R2C2",
-  "mode": "gitops-online",
-  "update_mode": "git_patch_only",
-  "zip_update_deprecated": true,
-  "chatgpt_access": true,
-  "codex_access": true,
-  "updated_at": "2026-07-08T00:00:00Z"
+  "version": "V1R1C0",
+  "architecture_version": "V1",
+  "release_version": "R1",
+  "change_version": "C0",
+  "components": [
+    "webops",
+    "owner-admin-user",
+    "npm",
+    "casdoor",
+    "openclaw",
+    "hermes",
+    "one-api",
+    "gitops-control",
+    "baseline-registry",
+    "custom-llm-registry",
+    "runtime-selector"
+  ],
+  "entry": "https://cnnetmkt.top",
+  "proxy": "npm",
+  "runtime_sync": "openclaw"
 }

audit/README.md

@@ -1,41 +0,0 @@
-# AIOS Agent Execution Audit Plane
-
-## Purpose
-Record every agent-initiated action on the AIOS GitOps runtime: what, who, when, why, result.
-
-## Audit Lifecycle
-
-1. **Pre-flight**: Record intent before execution
-2. **In-flight**: Capture command, input, git state, branch
-3. **Post-flight**: Record result, outputs, errors, duration
-4. **Archive**: Immutable commit to git as structured JSON logs
-
-## Audit Schema (v1)
-
-```json
-{
-  "audit_id": "<uuid or hash>",
-  "event_type": "command_execution | command_completed | command_failed | baseline_promotion | tag_creation | state_change",
-  "command_ref": "CMD-<date>-<description>",
-  "agent": "openclaw | hermes | codex",
-  "user": "gitops-write-bot",
-  "timestamp": "<ISO-8601>",
-  "git": {
-    "branch": "main",
-    "sha_head": "<sha>",
-    "baseline": "V1R3C1",
-    "dirty": false
-  },
-  "input": {},
-  "output": {},
-  "duration_ms": 0,
-  "result": "success | failure | pending",
-  "error": null
-}
-```
-
-## Storage
-- `audit/agent-runs/` — per-agent JSONL
-- `audit/command-history/` — per-command aggregated
-- `audit/version-history/` — per-baseline audit trail
-- All audit files committed to git (immutable)

audit/agent-runs/openclaw-1783508505.json

@@ -1,16 +0,0 @@
-{
-  "agent_run_id": "openclaw-1783508505",
-  "command": "CMD-20260709-enable-autonomous-controller.md",
-  "agent": "openclaw",
-  "version": "V1R3C1",
-  "objective": "Command: CMD-20260709-enable-autonomous-controller.md",
-  "start_time": "2026-07-08T19:01:45+0800",
-  "end_time": null,
-  "interaction_count": 0,
-  "tool_call_count": 0,
-  "changed_files": [],
-  "commit_sha": null,
-  "test_result": null,
-  "final_result": "running",
-  "evidence_path": "evidence/CMD-20260709-enable-autonomous-controller/"
-}

audit/agent-runs/openclaw-20260708-001.json

@@ -1,23 +0,0 @@
-{
-  "id": "openclaw-20260708-001",
-  "command": "CMD-20260708-fix-git-actions-write-and-enable-audit-plane",
-  "agent": "openclaw",
-  "version": "V1R3C1",
-  "start_time": "2026-07-08T15:17:00+08:00",
-  "end_time": "2026-07-08T15:32:00+08:00",
-  "interaction_count": 45,
-  "objective": "Fix Git Actions write permission - token hash mismatch in gitops.tokens",
-  "input_source": "git",
-  "actions": [
-    "investigate: diagnosed 401 unauthorized on write API",
-    "diagnose: found multiline JSON record ignored by token_records()",
-    "fix: updated SHA256 hash in first gitops-write-bot record",
-    "fix: removed duplicate multiline record",
-    "fix: removed duplicate multiline record",
-    "verify: branch create + file write + commit + sync all passed"
-  ],
-  "result": "success",
-  "evidence": "evidence/CMD-20260708-fix-git-actions-write-and-enable-audit-plane/",
-  "commit": "pending",
-  "approval": "autonomous"
-}

audit/agent-runs/openclaw-20260708-002.json

@@ -1,24 +0,0 @@
-{
-  "id": "openclaw-20260708-002",
-  "command": "CMD-20260708-fix-git-actions-write-and-enable-audit-plane",
-  "agent": "openclaw",
-  "version": "V1R3C1",
-  "start_time": "2026-07-08T15:34:00+08:00",
-  "end_time": "2026-07-08T15:36:00+08:00",
-  "interaction_count": 12,
-  "objective": "Initialize Agent Command Plane directory structure and audit plane",
-  "input_source": "git",
-  "actions": [
-    "create: agents/commands/active/running/completed/failed/",
-    "create: agents/policies/ agents/state/",
-    "create: agents/registry.yaml",
-    "create: audit/agent-runs/version-history/command-history/",
-    "create: audit/README.md audit/manifest.json",
-    "create: docs/architecture/AIOS_AGENT_AUDIT_PLANE.md",
-    "create: evidence/CMD-20260708-.../"
-  ],
-  "result": "success",
-  "evidence": "evidence/CMD-20260708-fix-git-actions-write-and-enable-audit-plane/",
-  "commit": "pending",
-  "approval": "autonomous"
-}

audit/agent-runs/openclaw-20260708-003.json

@@ -1,10 +0,0 @@
-{
-  "agent_run_id": "openclaw-20260708-003",
-  "agent": "openclaw",
-  "command": "CMD-20260708-enable-aios-autonomous-operation-and-notification",
-  "start_time": "2026-07-08T15:00:00+08:00",
-  "end_time": "2026-07-08T16:20:00+08:00",
-  "final_result": "success",
-  "interaction_count": 75,
-  "summary": "Initialized autonomous operation mode: Git command watcher running, Web UI dashboard live, audit records created. Pending: WeChat notification system integration."
-}

audit/manifest.json

@@ -1,7 +0,0 @@
-{
-  "schema_version": "1.0.0",
-  "audit_plane_enabled": true,
-  "created_at": "2026-07-08T15:20:00+08:00",
-  "baseline": "V1R3C1",
-  "initiated_by": "CMD-20260708-fix-git-actions-write-and-enable-audit-plane"
-}

baseline/current.json

@@ -1 +1,108 @@
-{"current_baseline":"V1R3C1","promoted_at":"2026-07-08T14:31:00+08:00","previous_baseline":"V1R2C3"}
+{
+  "active_version": "V1R1C4",
+  "active_tag": "V1R1C4",
+  "mode": "gitops-online",
+  "version_policy": "VxRxCx",
+  "update_mode": "git_patch_only",
+  "zip_update_deprecated": true,
+  "entry": "https://cnnetmkt.top",
+  "links": {
+    "git": "https://g.cnnetmkt.top/git/aios/aios-v23",
+    "baseline": "/base",
+    "versions": "/ver",
+    "diff": "/diff",
+    "patch": "/patch",
+    "model": "/model",
+    "runtime": "/run",
+    "api": "https://cnnetmkt.top/api",
+    "hook": "/hook"
+  },
+  "features": {
+    "multiuser_runtime": true,
+    "shared_dedicated_runtime": true,
+    "custom_llm": true,
+    "user_model_priority": true,
+    "chatgpt_rw": true,
+    "codex_rw": true,
+    "portal_gitops_dashboard": true,
+    "human_shortlinks_login_required": true
+  },
+  "version": "V1R1C4",
+  "baseline_tag": "V1R1C0-baseline-20260706",
+  "source": "AIOS_V1R1C0_MULTIUSER_GITOPS_CUSTOM_LLM_PROD_FULL_DEPLOY_20260706.zip",
+  "source_package": "AIOS_V1R1C0_MULTIUSER_GITOPS_CUSTOM_LLM_PROD_FULL_DEPLOY_20260706.zip",
+  "zip_update_mode": "deprecated",
+  "chatgpt_access": true,
+  "codex_access": true,
+  "git_url": "https://g.cnnetmkt.top/git/aios/aios-v23.git",
+  "short_links": [
+    "/git",
+    "/base",
+    "/ver",
+    "/diff",
+    "/patch",
+    "/model",
+    "/run",
+    "/api",
+    "/hook"
+  ],
+  "updated_at": "2026-07-06T11:16:23Z",
+  "auth": {
+    "primary_domain": "https://auth.cnnetmkt.top",
+    "backup_domain": "https://auth.h.imruyi.top:8443",
+    "primary_user_entry": "https://cnnetmkt.top/",
+    "primary_callback": "https://cnnetmkt.top/casdoor/callback/",
+    "casdoor_application": "admin/aios-portal",
+    "backup_domain_role": "standby-only"
+  },
+  "previous_version": "V1R1C3",
+  "codex_gitops": {
+    "config": "config/codex/gitops-online.json",
+    "token_account": "codex-gitops-bot",
+    "token_ref": "secret_ref://aios-gitops/runtime/codex-gitops-bot",
+    "direct_main_push": false,
+    "all_writes_require_git_commit": true,
+    "api_keys_in_git": false,
+    "online_git_sync": true,
+    "bare_repo": "/data/aios-gitops/runtime/gitea-bin/data/repositories/aios/aios-v23.git"
+  },
+  "last_collaboration_test": {
+    "timestamp": "20260706T104130Z",
+    "local_codex_branch": "patch/collab-local-codex-20260706T104130Z",
+    "custom_gpt_branch": "patch/collab-custom-gpt-20260706T104130Z",
+    "custom_gpt_url": "https://chatgpt.com/g/g-6a4b7c82dff08191bc980798edea1bac-aios-gitops-kong-zhi-tai",
+    "result": "merged_to_main"
+  },
+  "security": {
+    "human_shortlinks": {
+      "status": "login_required",
+      "routes": [
+        "/base",
+        "/ver",
+        "/diff",
+        "/patch",
+        "/model",
+        "/run"
+      ],
+      "target": "https://cnnetmkt.top/portal/me/#gitops",
+      "machine_api": "https://cnnetmkt.top/api"
+    },
+    "gitea": {
+      "web": "https://g.cnnetmkt.top/git/aios/aios-v23",
+      "require_signin_view": true,
+      "registration_disabled": true,
+      "default_local_account": "disabled_without_password",
+      "owner_password_sync": "aios-gitea-owner-sync.timer",
+      "owner_password_source": "secret_ref://aios/user-control-center/UCC_OWNER_PASSWORD"
+    }
+  },
+  "last_auth_portal_fix": {
+    "version": "V1R1C4",
+    "timestamp": "2026-07-06T11:16:23Z",
+    "shortlinks": "redirect_to_login_protected_portal_gitops_section",
+    "gitea_owner_sync": "enabled",
+    "portal_overlay": "overlays/user-control-center",
+    "portal_baseline_cache": "/app/runtime/gitops/current.json",
+    "sync_log_secret_hygiene": "runuser_without_sudo_command_logging"
+  }
+}

baseline/promotions/V1R4C0-test.owner-approved.json

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

cmd/command-plane/README.md

@@ -1,27 +0,0 @@
-# AIOS Git Agent Command Plane
-
-**Bootstrap:** CMD-BOOTSTRAP-001
-
-The Agent Command Plane provides a structured foundation for autonomous GitOps operation.
-
-## Directory Structure
-
-```
-cmd/command-plane/
-├── approvals/    — Approval gates and pre-approved actions
-├── audit/        — Audit trail for all command plane operations
-├── events/       — Inbound/outbound event bus
-├── reports/      — Execution reports and summaries
-├── requests/     — Pending command requests and artifacts
-├── scripts/      — Command plane tooling
-├── state/        — Current state and operational locks
-└── manifest.json — Bootstrap manifest
-```
-
-## Usage
-
-Command plane scripts in `scripts/` can read/write events, requests, approvals,
-and state. The autonomous daemon (`services/aios-autonomous-daemon/`) is the
-primary consumer of this command plane.
-
-Events flow: `events/` → processing → `requests/` → `approvals/` → execution → `reports/` → `audit/`

cmd/command-plane/manifest.json

@@ -1,16 +0,0 @@
-{
-  "command_plane": "CMD-BOOTSTRAP-001",
-  "version": "1.0.0",
-  "created_at": "2026-07-08T15:14:00+08:00",
-  "baseline": "V1R3C1",
-  "description": "AIOS Git Agent Command Plane initialization",
-  "directories": {
-    "events": "inbound/outbound event bus for command plane operations",
-    "requests": "pending command requests and artifacts",
-    "approvals": "approval gates and pre-approved actions",
-    "audit": "audit trail for all command plane operations",
-    "reports": "execution reports and summaries",
-    "state": "current command plane state and locks",
-    "scripts": "command plane scripts and tooling"
-  }
-}

config/agent-event-bus.yaml

@@ -1,35 +0,0 @@
-agent_event_bus:
-  enabled: true
-  replacement_for:
-    - agents/commands
-    - agents/messages
-  storage:
-    root: agents/events
-    states:
-      - pending
-      - running
-      - completed
-      - failed
-    audit: agents/events/audit
-  supported_kinds:
-    - command
-    - agent_status
-    - gpt_inbox
-    - gpt_reply
-    - audit_event
-    - approval_request
-    - failure_report
-    - daily_report
-  api:
-    operations:
-      - createAgentEvent
-      - listAgentEvents
-      - getAgentEvent
-      - transitionAgentEvent
-      - getAgentEventStats
-  dashboard:
-    route: /admin/ai-evolution/events
-  governance:
-    secrets_in_git: false
-    direct_main_push: false
-    owner_gate_required: true

config/self-evolution/agent-resource-manager.json

@@ -1,43 +0,0 @@
-{
-  "$schema": "schema/self-evolution.schema.json",
-  "title": "Agent Resource Manager Configuration",
-  "description": "Defines resource limits, parallel task limits, priority, runtime isolation, and overload handling for agent orchestration.",
-  "version": "1.0.0",
-  "config": {
-    "default_resource_limits": {
-      "max_concurrent_tasks": 5,
-      "max_memory_mb": 1024,
-      "max_cpu_cores": 2,
-      "timeout_seconds": 300
-    },
-    "agent_priority_levels": {
-      "critical": 100,
-      "high": 80,
-      "medium": 50,
-      "low": 20,
-      "background": 0
-    },
-    "runtime_isolation": {
-      "enabled": true,
-      "namespace_per_agent": true,
-      "ephemeral_storage": "1Gi",
-      "network_policy": "restrictive"
-    },
-    "overload_handling": {
-      "max_queue_depth": 100,
-      "backpressure_threshold": 0.9,
-      "cooldown_seconds": 30,
-      "scaling_strategy": "queue"
-    },
-    "agent_pools": {
-      "server_agents": {
-        "max_instances": 3,
-        "priority": "high"
-      },
-      "external_agents": {
-        "max_instances": 5,
-        "priority": "medium"
-      }
-    }
-  }
-}

config/user-profile-isolation-policy.yaml

@@ -1,20 +0,0 @@
-user_profile_isolation:
-  enabled: true
-  principle: one_agent_many_users_requires_scoped_user_context
-  global_files:
-    USER.md: agent_defaults_only
-  user_data:
-    storage: runtime/user-profiles
-    isolation_key: user_id_hash
-    git_commit_required: false
-    reason: user preferences are runtime data, not shared configuration
-  forbidden:
-    - shared_user_preferences_in_USER_MD
-    - cross_user_profile_access
-    - user_identity_data_in_public_agent_config
-  audit:
-    enabled: true
-    events:
-      - profile_created
-      - profile_updated
-      - context_loaded

db/migrations/20260707_message_outbox.sql

@@ -1,40 +0,0 @@
-CREATE TABLE IF NOT EXISTS message_outbox (
-  id TEXT PRIMARY KEY,
-  channel TEXT NOT NULL,
-  recipient_user_id TEXT NOT NULL,
-  recipient_role TEXT,
-  message_type TEXT NOT NULL,
-  priority TEXT NOT NULL DEFAULT 'normal',
-  title TEXT,
-  content TEXT NOT NULL,
-  payload TEXT,
-  status TEXT NOT NULL DEFAULT 'queued',
-  retry_count INTEGER NOT NULL DEFAULT 0,
-  last_error TEXT,
-  created_at TEXT NOT NULL,
-  sent_at TEXT
-);
-
-CREATE INDEX IF NOT EXISTS idx_message_outbox_dispatch
-ON message_outbox(channel, status, priority, created_at);
-
-CREATE TABLE IF NOT EXISTS channel_bindings (
-  id TEXT PRIMARY KEY,
-  user_id TEXT NOT NULL,
-  channel_type TEXT NOT NULL,
-  external_chat_id TEXT NOT NULL,
-  status TEXT NOT NULL DEFAULT 'active',
-  updated_at TEXT NOT NULL
-);
-
-CREATE INDEX IF NOT EXISTS idx_channel_bindings_lookup
-ON channel_bindings(user_id, channel_type, status, updated_at);
-
-CREATE TABLE IF NOT EXISTS audit_logs (
-  id TEXT PRIMARY KEY,
-  actor TEXT NOT NULL,
-  action TEXT NOT NULL,
-  target TEXT,
-  detail TEXT,
-  created_at TEXT NOT NULL
-);

deploy/install/install.sh

@@ -1,46 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-echo "[AIOS] Installing Autonomous GitOps System..."
-
-WORKDIR=/data/aios-gitops/workspace
-ETC=/etc/aios
-RUNTIME=/data/aios-gitops/runtime
-SERVICE_USER=aios
-
-if ! id "$SERVICE_USER" >/dev/null 2>&1; then
-  echo "[AIOS] Creating system user: $SERVICE_USER"
-  useradd --system --home /data/aios-gitops --shell /usr/sbin/nologin "$SERVICE_USER"
-fi
-
-mkdir -p "$ETC"
-cp deploy/systemd/aios-autonomous-daemon.env.template "$ETC/aios-autonomous-daemon.env"
-
-mkdir -p \
-  "$RUNTIME/events" \
-  "$RUNTIME/audit" \
-  "$RUNTIME/requests" \
-  "$RUNTIME/reports/codex" \
-  "$RUNTIME/approvals/preapproved" \
-  "$RUNTIME/integrations/v1r1-personal-wechat/outbox" \
-  "$RUNTIME/integrations/v1r1-personal-wechat/inbox" \
-  "$RUNTIME/integrations/v1r1-personal-wechat/status"
-
-chown -R "$SERVICE_USER:$SERVICE_USER" /data/aios-gitops/runtime || true
-chown -R "$SERVICE_USER:$SERVICE_USER" "$WORKDIR" || true
-
-cp deploy/systemd/aios-autonomous-daemon.service /etc/systemd/system/
-cp deploy/systemd/aios-v1r1-wechat-worker.service /etc/systemd/system/
-
-systemctl daemon-reload
-systemctl enable aios-autonomous-daemon.service || true
-systemctl enable aios-v1r1-wechat-worker.service || true
-
-systemctl restart aios-autonomous-daemon.service || true
-systemctl restart aios-v1r1-wechat-worker.service || true
-
-sleep 2
-systemctl status aios-autonomous-daemon.service --no-pager || true
-systemctl status aios-v1r1-wechat-worker.service --no-pager || true
-
-echo "[AIOS] Installation complete"

docs/architecture/AIOS_AGENT_AUDIT_PLANE.md

@@ -1,132 +0,0 @@
-<<<<<<< HEAD
-# AIOS Agent Audit Plane Architecture
-
-## Overview
-
-The AIOS Agent Audit Plane provides a complete traceability framework for all autonomous agent operations on the AIOS GitOps repository. Every agent action — from command discovery to execution to version promotion — is recorded, versioned, and auditable.
-
-## Architecture
-
-```
-Git Repository
-    |
-    v
-Agent Command Plane (agents/commands/)
-    |   active/  running/  completed/  failed/
-    |   + registry.yaml
-    v
-[OpenClaw | Hermes | Codex]
-    |
-    +---> Execution
-    |         |
-    |         v
-    |     evidence/<CMD-ID>/   (detection, execution, test, final)
-    |
-    +---> Audit
-    |         |
-    |         v
-    |     audit/agent-runs/        (per-agent log)
-    |     audit/command-history/   (per-command log)
-    |     audit/version-history/   (per-baseline log)
-    |
-    +---> Git Commit
-              |
-              v
-          Web UI Timeline
-              /admin/ai-history
-```
-
-## Data Flow
-
-1. CMD file lands in `agents/commands/active/`
-2. Agent picks it up, reads it
-3. Agent executes, writes evidence to `evidence/<CMD-ID>/`
-4. Agent writes audit record to `audit/agent-runs/`
-5. Git commit locks the audit record
-6. Web UI displays timeline from git history
-
-## Audit Record Schema
-
-```json
-{
-  "id": "",
-  "command": "CMD-20260708-...",
-  "agent": "openclaw",
-  "version": "V1R3C1",
-  "start_time": "",
-  "end_time": "",
-  "interaction_count": 0,
-  "objective": "",
-  "input_source": "git",
-  "actions": [],
-  "result": "",
-  "evidence": "",
-  "commit": "",
-  "approval": ""
-}
-```
-
-## Ownership
-
-- All agent modifications must be bound to a version (e.g., V1R3C1)
-- Every code change must be traceable to who/what agent created it
-- No agent-created changes without audit trail
-
-## Related
-
-- [Agent Command Plane](../agents/README.md)
-- [Baseline System](baseline-system.md)
-=======
-# AIOS Agent Audit Plane
-
-## Purpose
-
-Every agent action is recorded. All code changes are traceable to:
-- Who made the change
-- Why the change was made
-- When it was made
-- Which version introduced it
-- What test results showed
-
-## Directory Structure
-
-```
-audit/
-├── agent-runs/         # Per-execution records (JSON)
-├── command-history/    # Command lifecycle history
-├── version-history/    # Version/baseline change log
-└── interaction-history/ # Agent conversation traces
-```
-
-## Agent Run Record
-
-| Field | Description |
-|-------|-------------|
-| agent_run_id | Unique execution ID |
-| command | Command file name |
-| agent | Executing agent name |
-| version | Baseline version at execution time |
-| objective | Human-readable goal |
-| start_time | ISO-8601 start timestamp |
-| end_time | ISO-8601 completion timestamp |
-| interaction_count | Agent-owner interaction turns |
-| tool_call_count | Tool invocations during execution |
-| changed_files | Files modified in this run |
-| commit_sha | Git commit hash |
-| test_result | Test verification outcome |
-| final_result | SUCCESS / FAILED / PARTIAL |
-| evidence_path | Link to evidence directory |
-
-## Version History
-
-Records baseline promotions, rollbacks, and version changes.
-
-## Interaction History
-
-Conversation logs between agent and owner for each command execution.
-
-## Audit Trail Requirement
-
-All changes tracked via Git with signed commits where possible.
-Every commit message references the originating Command ID.
->>>>>>> 4d18ee0 (feat(cmd): enable Agent Command Plane, audit plane, and Web UI dashboard)

docs/architecture/GPT_ACTIONS_CONSEQUENTIAL_GOVERNANCE.md

@@ -0,0 +1,70 @@
+# GPT Actions Consequential Governance
+
+## Objective
+
+Reduce unnecessary ChatGPT Actions confirmation prompts for low-risk GitOps write operations while preserving confirmation protection for high-risk changes.
+
+## Platform Boundary
+
+Instructions can reduce how often a Custom GPT chooses high-risk actions, but they cannot guarantee that the ChatGPT platform will suppress every external Action confirmation prompt. The platform may still ask the user to confirm writes to external services.
+
+`x-openai-isConsequential` is the OpenAPI-level control used to communicate whether an Action is consequential:
+
+- Low-risk GitOps evidence and documentation writes use `x-openai-isConsequential: false`.
+- High-risk runtime, rollback, main-branch, tag, release, baseline, authentication, permission, and production-model changes use `x-openai-isConsequential: true`.
+
+Fully unattended background writes should be executed by the AIOS Orchestrator, not by direct Custom GPT UI Actions.
+
+## Low-Risk Actions
+
+Low-risk Actions are limited to non-main patch branches and controlled evidence paths:
+
+| operationId | Consequential | Path Scope |
+|---|---:|---|
+| `commitReportFile` | `false` | `reports/**` |
+| `commitDocsFile` | `false` | `docs/**` |
+| `commitProposalFile` | `false` | `proposals/**` |
+| `commitPatchEvidence` | `false` | `reports/**`, `patches/**` |
+
+Low-risk Actions must reject:
+
+- `main` and `master` writes.
+- `runtime/secrets/**`.
+- `.env`.
+- `*.token`.
+- `private/**`.
+- `prod-secrets/**`.
+- Secret-like content such as credential values, passwords, API keys, private keys, or access tokens.
+- Merge, rollback, tag, release, runtime, production, baseline, permission, or authentication mutations.
+
+## High-Risk Actions
+
+High-risk Actions intentionally keep confirmation protection:
+
+| operationId | Consequential | Reason |
+|---|---:|---|
+| `commitFile` | `true` | Legacy generic write API retained for compatibility. |
+| `commitMainFile` | `true` | Explicit main-branch write. |
+| `createRollbackRequest` | `true` | Rollback-related workflow. |
+| `requestRollback` | `true` | Legacy rollback request compatibility. |
+| `requestOrCreateTag` | `true` | Release/tag workflow. |
+| `setModelPriority` | `true` | Model-routing policy mutation. |
+| `registerModel` | `true` | Runtime model registry mutation. |
+
+## Compatibility
+
+The legacy `commitFile` operation is preserved and marked consequential. Custom GPTs should prefer the low-risk specialized operations for docs, reports, proposals, and patch evidence.
+
+## Secret Handling
+
+The schema uses placeholders only. Action authentication remains injected by GPT Builder Actions configuration at runtime. Real tokens, passwords, API keys, private keys, and secret values must never be placed in OpenAPI examples, docs, reports, tests, or scripts.
+
+## Validation
+
+Validation is covered by:
+
+- `tests/test_openapi_consequential_flags.py`.
+- `tests/test_gitops_low_risk_commit_policy.py`.
+- `scripts/smoke_gpt_actions_consequential_governance.py`.
+
+These checks validate the consequential matrix, path scoping, main-branch rejection for low-risk writes, secret-path rejection, secret-like content rejection, and placeholder-only schema examples.

docs/codex/gitops-platform-ui-validation-playbook.md

@@ -1,154 +0,0 @@
-# Codex 验收手册：GitOps Platform UI
-
-## 目标
-
-本次变更的目标是把 `cnnetmkt.top` AIOS GitOps Web UI 从基础 dashboard 升级为平台级控制台，形成可审计、可审批、可灰度、可回滚请求的 GitOps 操作入口。
-
-## 验证分支
-
-- Branch: `patch/web-ui-complete-gitops-dashboard-20260706`
-- Base: `main`
-- 当前目标基线: `V1R1C4`
-- 合并后建议新基线: `V1R1C5`
-
-## 主线差异点
-
-与 `main` 相比，本分支新增或修改以下直接内容：
-
-1. `overlays/user-control-center/portal/gitops-dashboard/index.html`
-   - 新增平台级 GitOps 控制台页面。
-   - 包含 Overview、RBAC、Approval、Diff Tree、Patch、Model、Release、Audit 模块。
-
-2. `overlays/user-control-center/portal/gitops-dashboard/app.js`
-   - 新增浏览器运行时 Platform Control Plane。
-   - 包含 API-first client、RBAC guard、approval fallback、audit local store、diff tree parser、model graph、SSE event hook。
-
-3. `overlays/user-control-center/portal/gitops-dashboard/styles.css`
-   - 控制台样式。
-
-4. `overlays/user-control-center/portal/gitops-dashboard/manifest.json`
-   - 控制台 manifest。
-
-5. `overlays/user-control-center/portal/gitops-dashboard/gitops-ui-policy.json`
-   - UI 侧策略声明。
-
-6. `overlays/user-control-center/portal/gitops-dashboard/gitops-enterprise-api.contract.json`
-   - 后端 API 契约说明。
-
-7. `patches/patch_web-ui-complete-gitops-dashboard-20260706.branch.json`
-   - GitOps branch 元数据。
-
-## 间接影响区域
-
-Codex 验证时必须确认以下间接影响：
-
-1. Portal 登录入口不应被破坏。
-   - `/portal/me/#gitops`
-   - `/portal/me/#gitops-dashboard`
-
-2. 现有短链仍应保持登录保护或正常跳转。
-   - `/base`
-   - `/ver`
-   - `/diff`
-   - `/patch`
-   - `/model`
-   - `/run`
-
-3. 机器 API 不应被前端变更破坏。
-   - `/api/base`
-   - `/api/ver`
-   - `/api/diff`
-   - `/api/patch`
-   - `/api/model`
-   - `/api/run`
-
-4. 敏感信息不得进入 Git、日志、前端源码或测试产物。
-   - 禁止真实 API key。
-   - 禁止 Bearer token。
-   - 禁止 password / private key。
-   - 允许 `secret_ref://...`。
-
-5. 高风险操作不得绕过审批。
-   - rollback 只能 request。
-   - tag/release 默认只能 request。
-   - runtime 写入只能 request。
-   - UI 不提供 direct main write。
-
-## Codex 快速验证命令
-
-在目标工作区执行：
-
-```bash
-git fetch --all --prune
-git checkout patch/web-ui-complete-gitops-dashboard-20260706
-git diff --stat main...HEAD
-bash scripts/validate-gitops-platform-ui.sh patch/web-ui-complete-gitops-dashboard-20260706 main
-```
-
-## 灰度验证外的必测项目
-
-除正常灰度页面点击验证外，Codex 必须按 `tests/acceptance/gitops-platform-ui.acceptance.json` 执行以下测试组：
-
-1. Static Files
-   - 必须存在 index/html/js/css/manifest/policy/contract 文件。
-
-2. Security
-   - 源码中不得出现真实 secret/token/password。
-   - 模型注册必须只允许 `secret_ref://`。
-   - rollback/tag/runtime/main write 必须 request-only 或 disabled。
-
-3. UI Direct Impact
-   - 所有 tab id 必须能在 HTML 中找到。
-   - app.js 必须绑定 `DOMContentLoaded`。
-   - app.js 必须包含 `guardAction`、`audit`、`createApproval`、`renderDiffTree`。
-
-4. API Contract Compatibility
-   - 读接口保持 `/api/base`、`/api/ver`、`/api/run`、`/api/patch`、`/api/model`。
-   - 写接口必须包含 branch、patch/plan、model、model-priority、rollback-request、tag-request。
-
-5. Indirect Regression
-   - 不得修改 auth/casdoor 配置。
-   - 不得修改 Gitea owner password sync 配置。
-   - 不得修改 baseline active_version。
-   - 不得删除任何版本/tag/patch 历史。
-
-## 验收判定
-
-- PASS: 所有 required 测试项通过，且没有 secret 泄漏、没有 direct main write、没有破坏短链/API。
-- FAIL: 任一 required 测试项失败。
-- BLOCKED: 需要真实后端或浏览器环境，但静态检查通过；必须列出 blocked 项，不得合并 main。
-
-## 失败回流规则
-
-如果验证失败，Codex 必须输出：
-
-1. 失败测试 ID。
-2. 失败文件路径。
-3. 具体失败原因。
-4. 最小修改建议。
-5. 是否阻止合并。
-
-然后把问题交给自定义 GPT 继续修改同一 patch 分支。修复后重复执行完整验收，直到 PASS。
-
-## 合并规则
-
-只有满足以下条件才能合并 main：
-
-1. `scripts/validate-gitops-platform-ui.sh` PASS。
-2. acceptance JSON 中所有 `required: true` 项 PASS。
-3. 灰度验证通过。
-4. 无 secret 泄漏。
-5. 无 direct main write。
-6. 已创建或确认合并后基线提案 `V1R1C5`。
-
-## 合并后基线要求
-
-合并进入 main 后，必须定义新基线：
-
-- Version: `V1R1C5`
-- Purpose: `Promote AIOS GitOps Platform Control Plane UI with Codex validation workflow, acceptance tests, RBAC/approval/audit/release/model control-plane scaffolding.`
-- Risk: `high`
-- Approval: `owner/admin required`
-- Rollback target: `V1R1C4`
-
-合并后再创建 tag/version，不允许在未合并或未验收通过前直接创建生产 tag。

docs/gitops/openapi-chatgpt-actions.yaml

@@ -2,9 +2,11 @@ openapi: 3.1.0
 info:
   title: AIOS GitOps Controlled Access API
   version: V1R1C0-chatgpt-actions
-  description: Controlled ChatGPT Actions API for AIOS online GitOps baseline. Read endpoints are public. Write endpoints require Bearer token and create Git commits on non-main branches.
+  description: Controlled ChatGPT Actions API for AIOS online GitOps baseline. Read
+    endpoints are public. Write endpoints require Bearer token and create Git commits
+    on non-main branches.
 servers:
-  - url: https://cnnetmkt.top
+- url: https://cnnetmkt.top
 security: []
 components:
   securitySchemes:
@@ -15,234 +17,603 @@ components:
   schemas:
     BranchRequest:
       type: object
-      required: [branch]
+      required:
+      - branch
       properties:
-        branch: {type: string, example: patch/chatgpt-actions-demo}
-        base: {type: string, default: main}
-        message: {type: string}
+        branch:
+          type: string
+          example: patch/chatgpt-actions-demo
+        base:
+          type: string
+          default: main
+        message:
+          type: string
     FileCommitRequest:
       type: object
-      required: [branch, path, content]
+      required:
+      - branch
+      - path
+      - content
       properties:
-        branch: {type: string}
-        base: {type: string, default: main}
-        create_branch: {type: boolean, default: false}
-        path: {type: string, example: docs/gitops/chatgpt-change.md}
-        content: {type: string}
-        message: {type: string}
+        branch:
+          type: string
+        base:
+          type: string
+          default: main
+        create_branch:
+          type: boolean
+          default: false
+        path:
+          type: string
+          example: docs/gitops/chatgpt-change.md
+        content:
+          type: string
+        message:
+          type: string
     CommitRequest:
       type: object
       properties:
-        branch: {type: string}
+        branch:
+          type: string
         paths:
           type: array
-          items: {type: string}
-        message: {type: string}
+          items:
+            type: string
+        message:
+          type: string
     PatchRequest:
       type: object
-      required: [patch_name]
+      required:
+      - patch_name
       properties:
-        patch_name: {type: string}
-        branch: {type: string}
-        base: {type: string, default: main}
-        risk: {type: string, enum: [low, medium, high]}
-        description: {type: string}
-        message: {type: string}
+        patch_name:
+          type: string
+        branch:
+          type: string
+        base:
+          type: string
+          default: main
+        risk:
+          type: string
+          enum:
+          - low
+          - medium
+          - high
+        description:
+          type: string
+        message:
+          type: string
     TagRequest:
       type: object
-      required: [version]
+      required:
+      - version
       properties:
-        version: {type: string, example: V1R1C1}
-        message: {type: string}
+        version:
+          type: string
+          example: V1R1C1
+        message:
+          type: string
         execute:
           type: boolean
-          description: Owner-approved calls only. Otherwise an approval request commit is created.
+          description: Owner-approved calls only. Otherwise an approval request commit
+            is created.
     RollbackRequest:
       type: object
-      required: [target_version]
+      required:
+      - target_version
       properties:
-        target_version: {type: string}
-        reason: {type: string}
-        branch: {type: string}
+        target_version:
+          type: string
+        reason:
+          type: string
+        branch:
+          type: string
     ModelRequest:
       type: object
-      required: [provider_name, base_url, model_name]
+      required:
+      - provider_name
+      - base_url
+      - model_name
       properties:
-        username: {type: string}
-        provider_name: {type: string}
-        base_url: {type: string}
-        model_name: {type: string}
-        display_name: {type: string}
+        username:
+          type: string
+        provider_name:
+          type: string
+        base_url:
+          type: string
+        model_name:
+          type: string
+        display_name:
+          type: string
         api_key_secret_ref:
           type: string
           description: Preferred. Git stores this secret_ref only.
         api_key:
           type: string
           writeOnly: true
-          description: Accepted only for runtime secret storage; never committed to Git or logs.
-        branch: {type: string}
-        message: {type: string}
+          description: Accepted only for runtime secret storage; never committed to
+            Git or logs.
+        branch:
+          type: string
+        message:
+          type: string
     ModelPriorityRequest:
       type: object
-      required: [items]
+      required:
+      - items
       properties:
-        username: {type: string}
-        branch: {type: string}
+        username:
+          type: string
+        branch:
+          type: string
         items:
           type: array
           items:
             type: object
             properties:
-              model_id: {type: string}
-              priority: {type: integer}
-              enabled: {type: boolean}
-              fallback_policy: {type: string}
+              model_id:
+                type: string
+              priority:
+                type: integer
+              enabled:
+                type: boolean
+              fallback_policy:
+                type: string
     NLRequest:
       type: object
-      required: [text]
+      required:
+      - text
       properties:
-        text: {type: string}
-        branch: {type: string}
+        text:
+          type: string
+        branch:
+          type: string
+    LowRiskFileCommitRequest:
+      type: object
+      required:
+      - branch
+      - path
+      - content
+      - message
+      properties:
+        branch:
+          type: string
+          description: Non-main patch branch. Must start with patch/ or request/.
+          example: patch/gpt-actions-consequential-governance
+        base:
+          type: string
+          default: main
+          description: Base branch used when create_branch is true.
+        create_branch:
+          type: boolean
+          default: false
+        path:
+          type: string
+          description: File path constrained by the operation path scope.
+          example: reports/example-report.md
+        content:
+          type: string
+          description: File content. Must not include secrets, credentials, passwords,
+            API keys, private keys, or token values.
+        message:
+          type: string
+          description: Commit message. Must not include secrets or credentials.
+          example: 'docs(actions): add GPT Actions governance evidence'
+    MainFileCommitRequest:
+      type: object
+      required:
+      - path
+      - content
+      - message
+      properties:
+        branch:
+          type: string
+          default: main
+          description: Main branch. This high-risk operation requires explicit owner
+            intent.
+        path:
+          type: string
+          description: File path for explicit main-branch maintenance. Secret paths
+            are always rejected.
+        content:
+          type: string
+          description: File content. Must not include secrets, credentials, passwords,
+            API keys, private keys, or token values.
+        message:
+          type: string
+          description: Commit message. Must not include secrets or credentials.
+    RollbackRequestAction:
+      type: object
+      required:
+      - target_version
+      - reason
+      properties:
+        target_version:
+          type: string
+          example: V1R1C4
+        reason:
+          type: string
+          example: Owner-approved rollback request
+        branch:
+          type: string
+          example: request/rollback-V1R1C4
 paths:
   /api/base:
     get:
       operationId: getBaseline
       summary: Read current AIOS baseline
-      responses: {'200': {description: OK}}
+      responses:
+        '200':
+          description: OK
   /api/ver:
     get:
       operationId: listVersions
       summary: List GitOps versions
-      responses: {'200': {description: OK}}
+      responses:
+        '200':
+          description: OK
   /api/diff:
     get:
       operationId: getDiff
       summary: Read Git diff between refs
       parameters:
-        - in: query
-          name: from
-          schema: {type: string, default: HEAD~1}
-        - in: query
-          name: to
-          schema: {type: string, default: HEAD}
-      responses: {'200': {description: OK}}
+      - in: query
+        name: from
+        schema:
+          type: string
+          default: HEAD~1
+      - in: query
+        name: to
+        schema:
+          type: string
+          default: HEAD
+      responses:
+        '200':
+          description: OK
   /api/patch:
     get:
       operationId: listPatches
       summary: List patch records
-      responses: {'200': {description: OK}}
+      responses:
+        '200':
+          description: OK
     post:
       operationId: createPatch
       summary: Create a patch branch and commit metadata
-      security: [{bearerAuth: []}]
+      security:
+      - bearerAuth: []
       requestBody:
         required: true
         content:
           application/json:
-            schema: {$ref: '#/components/schemas/PatchRequest'}
-      responses: {'200': {description: Patch branch committed}, '401': {description: Unauthorized}, '403': {description: Forbidden}}
+            schema:
+              $ref: '#/components/schemas/PatchRequest'
+      responses:
+        '200':
+          description: Patch branch committed
+        '401':
+          description: Unauthorized
+        '403':
+          description: Forbidden
       x-openai-isConsequential: true
   /api/model:
     get:
       operationId: readModelRegistry
       summary: Read visible model registry and priority
-      responses: {'200': {description: OK}}
+      responses:
+        '200':
+          description: OK
     post:
       operationId: registerModel
-      summary: Register a custom model; API keys are stored as runtime secrets and Git receives secret_ref only
-      security: [{bearerAuth: []}]
+      summary: Register a custom model; API keys are stored as runtime secrets and
+        Git receives secret_ref only
+      security:
+      - bearerAuth: []
       requestBody:
         required: true
         content:
           application/json:
-            schema: {$ref: '#/components/schemas/ModelRequest'}
-      responses: {'200': {description: Model registered and committed}, '401': {description: Unauthorized}, '403': {description: Forbidden}}
+            schema:
+              $ref: '#/components/schemas/ModelRequest'
+      responses:
+        '200':
+          description: Model registered and committed
+        '401':
+          description: Unauthorized
+        '403':
+          description: Forbidden
       x-openai-isConsequential: true
   /api/run:
     get:
       operationId: getRuntimeStatus
       summary: Read runtime status
-      responses: {'200': {description: OK}}
+      responses:
+        '200':
+          description: OK
   /api/branch:
     post:
       operationId: createBranch
       summary: Create a non-main branch and commit branch metadata
-      security: [{bearerAuth: []}]
+      security:
+      - bearerAuth: []
       requestBody:
         required: true
         content:
           application/json:
-            schema: {$ref: '#/components/schemas/BranchRequest'}
-      responses: {'200': {description: Branch created}, '401': {description: Unauthorized}, '403': {description: Forbidden}}
+            schema:
+              $ref: '#/components/schemas/BranchRequest'
+      responses:
+        '200':
+          description: Branch created
+        '401':
+          description: Unauthorized
+        '403':
+          description: Forbidden
       x-openai-isConsequential: true
   /api/file:
     post:
       operationId: commitFile
       summary: Write a file and create a Git commit on a non-main branch
-      security: [{bearerAuth: []}]
+      security:
+      - bearerAuth: []
       requestBody:
         required: true
         content:
           application/json:
-            schema: {$ref: '#/components/schemas/FileCommitRequest'}
-      responses: {'200': {description: File committed}, '400': {description: Secret rejected or invalid path}, '401': {description: Unauthorized}}
+            schema:
+              $ref: '#/components/schemas/FileCommitRequest'
+      responses:
+        '200':
+          description: File committed
+        '400':
+          description: Secret rejected or invalid path
+        '401':
+          description: Unauthorized
       x-openai-isConsequential: true
   /api/commit:
     post:
       operationId: commitChanges
       summary: Commit existing workspace changes on a non-main branch
-      security: [{bearerAuth: []}]
+      security:
+      - bearerAuth: []
       requestBody:
         required: false
         content:
           application/json:
-            schema: {$ref: '#/components/schemas/CommitRequest'}
-      responses: {'200': {description: Commit result}, '401': {description: Unauthorized}}
+            schema:
+              $ref: '#/components/schemas/CommitRequest'
+      responses:
+        '200':
+          description: Commit result
+        '401':
+          description: Unauthorized
       x-openai-isConsequential: true
   /api/tag:
     post:
       operationId: requestOrCreateTag
       summary: Request tag creation; owner execution is required for direct tag
-      security: [{bearerAuth: []}]
+      security:
+      - bearerAuth: []
       requestBody:
         required: true
         content:
           application/json:
-            schema: {$ref: '#/components/schemas/TagRequest'}
-      responses: {'200': {description: Tag request committed or tag created}, '403': {description: Forbidden}}
+            schema:
+              $ref: '#/components/schemas/TagRequest'
+      responses:
+        '200':
+          description: Tag request committed or tag created
+        '403':
+          description: Forbidden
       x-openai-isConsequential: true
   /api/rollback:
     post:
       operationId: requestRollback
       summary: Commit a rollback request requiring owner/admin approval
-      security: [{bearerAuth: []}]
+      security:
+      - bearerAuth: []
       requestBody:
         required: true
         content:
           application/json:
-            schema: {$ref: '#/components/schemas/RollbackRequest'}
-      responses: {'200': {description: Rollback request committed}, '401': {description: Unauthorized}}
+            schema:
+              $ref: '#/components/schemas/RollbackRequest'
+      responses:
+        '200':
+          description: Rollback request committed
+        '401':
+          description: Unauthorized
       x-openai-isConsequential: true
   /api/model-priority:
     put:
       operationId: setModelPriority
       summary: Set model priority and commit policy file
-      security: [{bearerAuth: []}]
+      security:
+      - bearerAuth: []
       requestBody:
         required: true
         content:
           application/json:
-            schema: {$ref: '#/components/schemas/ModelPriorityRequest'}
-      responses: {'200': {description: Priority updated and committed}, '401': {description: Unauthorized}}
+            schema:
+              $ref: '#/components/schemas/ModelPriorityRequest'
+      responses:
+        '200':
+          description: Priority updated and committed
+        '401':
+          description: Unauthorized
       x-openai-isConsequential: true
   /api/nl:
     post:
       operationId: planNaturalLanguageGitOpsAction
-      summary: Convert natural language to a safe committed plan without executing V-level changes
-      security: [{bearerAuth: []}]
+      summary: Convert natural language to a safe committed plan without executing
+        V-level changes
+      security:
+      - bearerAuth: []
       requestBody:
         required: true
         content:
           application/json:
-            schema: {$ref: '#/components/schemas/NLRequest'}
-      responses: {'
+            schema:
+              $ref: '#/components/schemas/NLRequest'
+      responses:
+        '200':
+          description: Plan committed
+        '401':
+          description: Unauthorized
+      x-openai-isConsequential: true
+  /api/gitops/report-file:
+    post:
+      operationId: commitReportFile
+      x-openai-isConsequential: false
+      x-aios-path-scope: reports/**
+      summary: Commit a report file to a controlled GitOps patch branch
+      description: Low-risk report write. Commits markdown or JSON evidence under
+        reports/** to a non-main patch branch. This operation must not write secrets,
+        credentials, token values, runtime secret files, rollback requests, or production
+        config.
+      security:
+      - bearerAuth: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/LowRiskFileCommitRequest'
+      responses:
+        '200':
+          description: File committed successfully
+        '400':
+          description: Invalid branch, path, or secret-like content rejected
+        '401':
+          description: Authorization header was not injected
+        '403':
+          description: Authorization scope is insufficient
+  /api/gitops/docs-file:
+    post:
+      operationId: commitDocsFile
+      x-openai-isConsequential: false
+      x-aios-path-scope: docs/**
+      summary: Commit a docs file to a controlled GitOps patch branch
+      description: Low-risk documentation write under docs/** on a non-main patch
+        branch. It must not include real tokens, passwords, API keys, private keys,
+        credentials, rollback execution, or production config mutation.
+      security:
+      - bearerAuth: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/LowRiskFileCommitRequest'
+      responses:
+        '200':
+          description: File committed successfully
+        '400':
+          description: Invalid branch, path, or secret-like content rejected
+        '401':
+          description: Authorization header was not injected
+        '403':
+          description: Authorization scope is insufficient
+  /api/gitops/proposal-file:
+    post:
+      operationId: commitProposalFile
+      x-openai-isConsequential: false
+      x-aios-path-scope: proposals/**
+      summary: Commit a proposal file to a controlled GitOps patch branch
+      description: Low-risk proposal write under proposals/** on a non-main patch
+        branch. It must not include real tokens, passwords, API keys, private keys,
+        credentials, runtime secret files, rollback execution, or production config
+        mutation.
+      security:
+      - bearerAuth: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/LowRiskFileCommitRequest'
+      responses:
+        '200':
+          description: File committed successfully
+        '400':
+          description: Invalid branch, path, or secret-like content rejected
+        '401':
+          description: Authorization header was not injected
+        '403':
+          description: Authorization scope is insufficient
+  /api/gitops/patch-evidence:
+    post:
+      operationId: commitPatchEvidence
+      x-openai-isConsequential: false
+      x-aios-path-scope: reports/**, patches/**
+      summary: Commit patch evidence to a controlled GitOps patch branch
+      description: Low-risk evidence write under reports/** or patches/** on a non-main
+        patch branch. It must not include real tokens, passwords, API keys, private
+        keys, credentials, runtime secret files, rollback execution, or production
+        config mutation.
+      security:
+      - bearerAuth: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/LowRiskFileCommitRequest'
+      responses:
+        '200':
+          description: File committed successfully
+        '400':
+          description: Invalid branch, path, or secret-like content rejected
+        '401':
+          description: Authorization header was not injected
+        '403':
+          description: Authorization scope is insufficient
+  /api/gitops/main-file:
+    post:
+      operationId: commitMainFile
+      x-openai-isConsequential: true
+      summary: Commit a file directly to main branch
+      description: High-risk explicit main-branch write. This operation exists only
+        for owner-approved maintenance and must not include real secrets, credentials,
+        passwords, private keys, API keys, token values, or runtime secret paths.
+      security:
+      - bearerAuth: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/MainFileCommitRequest'
+      responses:
+        '200':
+          description: File committed successfully
+        '400':
+          description: Invalid path or secret-like content rejected
+        '401':
+          description: Authorization header was not injected
+        '403':
+          description: Authorization scope is insufficient or owner approval missing
+  /api/gitops/rollback-request:
+    post:
+      operationId: createRollbackRequest
+      x-openai-isConsequential: true
+      summary: Create an owner-review rollback request
+      description: High-risk rollback request. Creates auditable rollback intent and
+        must never silently mutate production state or bypass owner/admin review.
+      security:
+      - bearerAuth: []
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/RollbackRequestAction'
+      responses:
+        '200':
+          description: Rollback request committed
+        '400':
+          description: Invalid rollback request or secret-like content rejected
+        '401':
+          description: Authorization header was not injected
+        '403':
+          description: Authorization scope is insufficient or owner approval missing

evidence/CMD-20260708-enable-aios-autonomous-operation-and-notification/final-report.md

@@ -1,35 +0,0 @@
-# Final Report: Enable AIOS Autonomous Operation and Notification
-
-## Summary
-Initialized AIOS Autonomous Operation mode with Command Plane, audit system, Web UI dashboard, and WeChat notification channel.
-
-## Deliverables
-
-### 1. Agent Command Plane ✅
-- Created agents/registry.yaml with lifecycle definition
-- Created agent-command-watcher.py (active, running)
-- Created agents/commands/ directory structure
-- Created agents/policies/ and agents/state/ boilerplate
-
-### 2. Audit System ✅
-- Created audit/agent-runs/ with 3 agent run records
-- Created audit/version-history/, audit/command-history/
-- Created audit/README.md and audit/manifest.json
-- Created docs/architecture/AIOS_AGENT_AUDIT_PLANE.md
-- Integrated baseline version tracking (V1R3C1)
-
-### 3. Web UI Dashboard ✅
-- Route: GET /admin/ai-evolution — Dashboard page
-- Route: GET /admin/ai-evolution/api/data — JSON API endpoint
-- Vue 3 single-page dashboard showing: version timeline, command lookup, recent agent runs
-- Auto-refresh every 30 seconds
-
-### 4. CMD-20260708-fix-git-actions-write-and-enable-audit-plane [COMPLETED]
-- Part 1-8 all complete, CMD moved to agents/commands/completed/
-- Git Actions write permission fixed (token hash sync)
-- Agent Command Plane, audit plane, trace, version association verified
-
-### 5. Git References
-- Commit: 9dad8b57 (push to main) + commit: 4d18ee0 (rebase to c796347)
-- Baseline: V1R3C1 (SHA 187dcc3554a20ecfcc4d4faca3774ddf3a1ebd33)
-- All commits pushed to bare repo successfully

evidence/CMD-20260708-fix-git-actions-write-and-enable-audit-plane/detection.json

@@ -1,9 +0,0 @@
-{
-  "timestamp": "2026-07-08T15:17:00+08:00",
-  "channel": "WeChat",
-  "user_request": "执行 Git 中最新命令：CMD-20260708-enable-agent-command-plane ... (later revealed as CMD-BOOTSTRAP-001-enable-command-plane)",
-  "detected_by": "openclaw",
-  "symptom": "write API returning 401 Unauthorized for gitops-write-bot token",
-  "severity": "P0",
-  "initial_diagnosis": "token SHA256 mismatch - gitops.tokens has two records for gitops-write-bot, multiline record skipped by parser"
-}

evidence/CMD-20260708-fix-git-actions-write-and-enable-audit-plane/execution.json

@@ -1,52 +0,0 @@
-{
-  "part_1_write_fix": {
-    "status": "complete",
-    "steps": [
-      "diagnosed token_records() skipping multiline JSON record",
-      "updated SHA256 in first single-line record to match actual token",
-      "removed duplicate multiline record",
-      "restarted aios-gitops-model-api",
-      "verified: branch create + file write + commit + sync all passed"
-    ],
-    "bash_commands_used": [
-      "cat, python3, systemctl, curl, git"
-    ]
-  },
-  "part_2_command_plane": {
-    "status": "complete",
-    "created": [
-      "agents/commands/active/running/completed/failed/",
-      "agents/policies/ agents/state/",
-      "agents/registry.yaml"
-    ]
-  },
-  "part_3_audit_plane": {
-    "status": "complete",
-    "created": [
-      "audit/agent-runs/",
-      "audit/version-history/",
-      "audit/command-history/",
-      "audit/README.md",
-      "audit/manifest.json"
-    ]
-  },
-  "part_4_conversation_trace": {
-    "status": "complete",
-    "created": "evidence/CMD-20260708-.../detection.json"
-  },
-  "part_5_version_association": {
-    "status": "complete",
-    "baseline": "V1R3C1"
-  },
-  "part_6_web_ui": {
-    "status": "n/a-uses-existing-git-history"
-  },
-  "part_7_evidence": {
-    "status": "complete",
-    "created": [
-      "evidence/CMD-20260708-.../detection.json",
-      "evidence/CMD-20260708-.../execution.json",
-      "evidence/CMD-20260708-.../final-report.md"
-    ]
-  }
-}

evidence/CMD-20260708-fix-git-actions-write-and-enable-audit-plane/final-report.md

@@ -1,21 +0,0 @@
-# Final Report: CMD-20260708-fix-git-actions-write-and-enable-audit-plane
-
-## Summary
-Fix Git Actions write permission and enable Agent Audit Plane.
-
-## Results
-- **Write permission**: ✅ Fixed (token hash sync, multiline dedup)
-- **Command Plane**: ✅ Created (agents/, registry.yaml)
-- **Audit Plane**: ✅ Created (audit/, manifest, schema)
-- **Architecture Doc**: ✅ Created (AIOS_AGENT_AUDIT_PLANE.md)
-- **Evidence**: ✅ Created (detection, execution, final report)
-
-## Outcome Signals
-- `AIOS_GIT_ACTION_WRITE_READY` = true
-- `AIOS_AGENT_AUDIT_PLANE_READY` = true
-
-## Next Command
-- `CMD-20260709-autonomous-controller-enable`
-
-## Completion Date
-2026-07-08T15:36:00+08:00

openapi/agent-event-bus-operation-ids.yaml

@@ -1,19 +0,0 @@
-openapi: 3.0.0
-info:
-  title: AIOS Unified Agent Event Bus API
-  version: V1R3C1+
-paths:
-  /agent-events:
-    post:
-      operationId: createAgentEvent
-    get:
-      operationId: listAgentEvents
-  /agent-events/{event_id}:
-    get:
-      operationId: getAgentEvent
-  /agent-events/{event_id}/transition:
-    post:
-      operationId: transitionAgentEvent
-  /agent-events/stats/overview:
-    get:
-      operationId: getAgentEventStats

ops/openclaw/CMD-20260709-enable-unified-agent-event-bus.md

@@ -1,38 +0,0 @@
-# CMD-20260709-enable-unified-agent-event-bus
-
-## Goal
-
-Replace separate command/message queues with the unified Agent Event Bus.
-
-## Deploy
-
-1. Deploy `active-runtime/app/agent_event_bus.py`.
-2. Enable Event API:
-   - createAgentEvent
-   - listAgentEvents
-   - getAgentEvent
-   - transitionAgentEvent
-   - getAgentEventStats
-3. Switch Web UI admin evolution page to:
-   - `/admin/ai-evolution/events`
-4. Enable audit path:
-   - `agents/events/audit`
-5. Keep compatibility adapters for old GPT inbox calls.
-
-## Validation signals
-
-- AIOS_AGENT_EVENT_BUS_READY
-- AIOS_AGENT_EVENT_AUDIT_READY
-- AIOS_AGENT_EVENT_DASHBOARD_READY
-
-## Migration
-
-- Do not delete existing command/message data.
-- New events go to `agents/events`.
-- Legacy queues become compatibility views.
-
-## Governance
-
-- No secrets in Git.
-- No direct main push.
-- Owner gate remains enabled.

ops/openclaw/CMD-20260709-enable-user-profile-isolation.md

@@ -1,30 +0,0 @@
-# CMD-20260709-enable-user-profile-isolation
-
-## Goal
-
-Fix multi-user agent context leakage caused by shared USER.md personalization.
-
-## Rules
-
-- USER.md is agent-level default behavior only.
-- User names, preferences and personalized settings must come from user profile storage.
-- Every WeChat/user session loads only its own profile by user_id.
-
-## Deploy
-
-1. Deploy user profile isolation runtime layer.
-2. Create runtime/user-profiles storage.
-3. Migrate existing shared personalization from USER.md into explicit owner profile if needed.
-4. Remove user-specific names from shared USER.md.
-5. Verify two users cannot read each other's profiles.
-
-## Validation signals
-
-- AIOS_USER_PROFILE_ISOLATION_READY
-- AIOS_MULTIUSER_CONTEXT_SAFE
-
-## Governance
-
-- User preferences are runtime data, not Git configuration.
-- No personal profile data in shared Git files.
-- Audit profile create/update/context load events.

ops/openclaw/directives/OPENCLAW-AIOS-AUTONOMOUS-GITOPS-DEPLOY-20260707.md

@@ -1,154 +0,0 @@
-# OpenClaw 指令：AIOS Autonomous GitOps 静默优化与部署监督
-
-Directive ID: `OPENCLAW-AIOS-AUTONOMOUS-GITOPS-DEPLOY-20260707`
-
-Branch: `patch/web-ui-complete-gitops-dashboard-20260706`
-
-Base: `main`
-
-Current baseline: `V1R1C4`
-
-Proposed baseline after approved merge: `V1R1C5`
-
-## 1. 执行目的
-
-OpenClaw 负责接管本分支的执行与监督，目标是在不影响现有执行层、不破坏用户使用体验的前提下，完成 AIOS Autonomous GitOps Runtime 的验证、静默优化、部署准备、Owner 通报与合并候选推进。
-
-本次改动的目标不是直接绕过 main 保护，而是让系统形成：
-
-- 自动 CI 验证；
-- Codex 自愈修复；
-- event bus + daemon 自动执行；
-- 微信/网页 Owner 审计与操作通道；
-- V1R1C5 基线提案；
-- 失败回流自定义 GPT 修复；
-- 通过后生成 merge candidate。
-
-## 2. OpenClaw 角色
-
-OpenClaw 是本任务的执行监督代理，职责如下：
-
-1. 读取并监督当前分支与 main 的差异。
-2. 按验收测试执行静态验证、安全验证、策略验证、灰度验证。
-3. 发现失败后，生成结构化 failure report。
-4. 将失败项交给自定义 GPT 继续修复同一 patch 分支。
-5. 修复后重复验证，直到 PASS 或触发 hard block。
-6. 生成 merge candidate，但不得直接绕过 main 保护。
-7. 监督 Owner 通知记录：每个 main 版本变更必须有摘要通报与 Web UI 记录。
-
-## 3. 禁止事项
-
-OpenClaw 不得执行以下操作：
-
-- 不得直接 force push；
-- 不得删除版本历史、tag、audit 记录；
-- 不得写入真实凭据；
-- 不得关闭 auth、Gitea 登录保护或 owner sync；
-- 不得在未通过验收前合并 main；
-- 不得在未有审批或预授权 runbook 前执行生产 tag、baseline activation 或 rollback execution。
-
-## 4. 必须执行的命令
-
-```bash
-git fetch --all --prune
-git checkout patch/web-ui-complete-gitops-dashboard-20260706
-git diff --stat main...HEAD
-bash scripts/validate-gitops-platform-ui.sh patch/web-ui-complete-gitops-dashboard-20260706 main
-bash scripts/autonomous-merge-gate.sh patch/web-ui-complete-gitops-dashboard-20260706 main
-```
-
-若部署验证需要启动本地 runtime：
-
-```bash
-bash deploy/install/install.sh
-python3 services/aios-autonomous-daemon/daemon.py emit --type patch_created --branch patch/web-ui-complete-gitops-dashboard-20260706 --base main
-python3 services/aios-autonomous-daemon/daemon.py run --once
-```
-
-## 5. 必须验证的直接修改
-
-OpenClaw 必须检查以下路径：
-
-- `overlays/user-control-center/portal/gitops-dashboard/`
-- `services/aios-autonomous-daemon/`
-- `services/aios-event-ingress/`
-- `deploy/systemd/`
-- `deploy/install/`
-- `config/codex/`
-- `scripts/`
-- `tests/acceptance/`
-- `versions/proposals/V1R1C5-gitops-platform-ui.proposed.json`
-- `skills/`
-- `docs/codex/`
-
-## 6. 必须验证的间接影响
-
-OpenClaw 必须确认以下内容未被破坏：
-
-- `/api/base`、`/api/ver`、`/api/diff`、`/api/patch`、`/api/model`、`/api/run`；
-- `/base`、`/ver`、`/diff`、`/patch`、`/model`、`/run` 登录保护；
-- Portal 登录入口 `/portal/me/#gitops`；
-- Gitea require sign-in view；
-- owner password sync；
-- active baseline 仍为 `V1R1C4`，未提前激活 `V1R1C5`。
-
-## 7. Owner 通报要求
-
-每个 main 版本变更、merge candidate、validation failure、rollback request、approval required 事件都必须形成：
-
-1. Owner 消息摘要；
-2. Web UI 审计记录；
-3. 可追踪 event_id；
-4. 变更功能摘要；
-5. 代码量与配置量统计；
-6. 与上一次主线变化的间隔；
-7. 测试状态；
-8. rollback target。
-
-## 8. OpenClaw 进度监督格式
-
-OpenClaw 每次监督输出必须包含：
-
-```text
-Status: PASS / FAIL / BLOCKED / RUNNING
-Branch: patch/web-ui-complete-gitops-dashboard-20260706
-Base: main
-Current Rev: <rev>
-Validation: <summary>
-Gray Test: <summary>
-Owner Notice: <summary>
-Merge Candidate: yes/no
-Blocked Reason: <reason or none>
-Next Action: <action>
-```
-
-## 9. 失败回流规则
-
-若失败，OpenClaw 必须写入 failure report：
-
-- 路径：`reports/openclaw/failure-<event_id>.json`
-- 内容：失败测试 ID、文件路径、失败原因、建议修复、是否阻断合并。
-
-随后将问题交给自定义 GPT 修改当前 patch 分支，修复后重新执行完整验收。
-
-## 10. 合并前门禁
-
-只有全部满足以下条件，OpenClaw 才能标记为 `merge_candidate_ready`：
-
-- required acceptance tests 全部 PASS；
-- 无凭据泄露；
-- 无 direct main write；
-- 无高风险未审批动作；
-- 灰度验证 PASS；
-- Owner 通报与 Web UI 记录正常；
-- `V1R1C5` baseline proposal 存在且未提前激活。
-
-## 11. 最终输出
-
-OpenClaw 最终应生成：
-
-- `reports/openclaw/final-supervision-report.json`
-- `reports/codex/merge-candidate.json`
-- Owner 摘要事件记录；
-- Web UI audit record；
-- 若失败则生成 failure report 并阻止合并。

overlays/user-control-center/portal/gitops-dashboard/app.js

@@ -1,462 +0,0 @@
-/* AIOS GitOps Platform Control Plane
- * Browser-only runtime with API-first behavior and safe local fallback.
- * No credentials or secret values are stored here. Model registration accepts secret_ref only.
- */
-const Platform = (() => {
-  const state = {
-    tenant: 'default',
-    role: 'viewer',
-    identity: null,
-    baseline: null,
-    versions: null,
-    runtime: null,
-    patches: null,
-    models: null,
-    approvals: [],
-    audit: [],
-    policy: null,
-    eventSource: null
-  };
-
-  const ENDPOINTS = {
-    identity: 'identity',
-    policy: 'platform/policy',
-    audit: 'audit',
-    approvals: 'approval',
-    approvalRequest: 'approval-request',
-    approvalDecision: 'approval-decision',
-    branch: 'branch',
-    plan: 'patch/plan',
-    base: 'base',
-    versions: 'ver',
-    diff: 'diff',
-    patch: 'patch',
-    model: 'model',
-    priority: 'model-priority',
-    runtime: 'run',
-    rollback: 'rollback-request',
-    tag: 'tag-request',
-    events: 'events/gitops'
-  };
-
-  const DEFAULT_POLICY = {
-    roles: {
-      viewer: ['read:*', 'audit:read'],
-      operator: ['read:*', 'audit:read', 'branch:create', 'plan:create', 'approval:create'],
-      admin: ['read:*', 'audit:read', 'branch:create', 'plan:create', 'approval:create', 'model:write', 'priority:write', 'release:request', 'rollback:request'],
-      owner: ['read:*', 'audit:*', 'branch:*', 'plan:*', 'approval:*', 'model:*', 'priority:*', 'release:*', 'rollback:*', 'runtime:*']
-    },
-    highRiskActions: ['release:execute', 'rollback:execute', 'runtime:write', 'tag:create', 'main:write'],
-    destructiveActions: ['delete:*', 'force_push', 'purge:*', 'clear:*'],
-    requiredApprovals: { low: 1, medium: 1, high: 2 },
-    tenantIsolation: true,
-    secretHygiene: {
-      allowSecretRefOnly: true,
-      forbiddenFields: ['api_key', 'token', 'password', 'secret', 'private_key', 'bearer']
-    }
-  };
-
-  function el(id) { return document.getElementById(id); }
-  function qs(sel) { return document.querySelector(sel); }
-  function qsa(sel) { return Array.from(document.querySelectorAll(sel)); }
-
-  function now() { return new Date().toISOString(); }
-
-  function safeStringify(value) {
-    return JSON.stringify(redact(value), null, 2);
-  }
-
-  function redact(value) {
-    if (Array.isArray(value)) return value.map(redact);
-    if (value && typeof value === 'object') {
-      const out = {};
-      for (const [key, val] of Object.entries(value)) {
-        const k = key.toLowerCase();
-        if (['api_key', 'apikey', 'token', 'password', 'secret', 'private_key', 'authorization', 'bearer'].some(x => k.includes(x))) {
-          out[key] = typeof val === 'string' && val.startsWith('secret_ref://') ? val : '[REDACTED]';
-        } else out[key] = redact(val);
-      }
-      return out;
-    }
-    return value;
-  }
-
-  function put(id, value) {
-    const target = el(id);
-    if (target) target.textContent = typeof value === 'string' ? value : safeStringify(value);
-  }
-
-  async function api(path, method = 'GET', body = undefined, options = {}) {
-    const url = `/api/${path}`;
-    const headers = { 'Content-Type': 'application/json', 'X-AIOS-Tenant': state.tenant };
-    const res = await fetch(url, {
-      method,
-      headers,
-      credentials: 'same-origin',
-      body: body === undefined ? undefined : JSON.stringify(body)
-    });
-    let data = null;
-    try { data = await res.json(); } catch (_) { data = { status: res.status, text: await res.text() }; }
-    if (!res.ok && !options.allowError) {
-      const err = new Error(`API ${method} ${url} failed with ${res.status}`);
-      err.response = data;
-      throw err;
-    }
-    return data;
-  }
-
-  function has(capability) {
-    const policy = state.policy || DEFAULT_POLICY;
-    const caps = policy.roles[state.role] || [];
-    return caps.includes('*') || caps.includes(capability) || caps.some(c => c.endsWith(':*') && capability.startsWith(c.slice(0, -1))) || caps.includes('read:*') && capability.startsWith('read:');
-  }
-
-  function guardAction(capability, risk = 'low') {
-    const policy = state.policy || DEFAULT_POLICY;
-    if (policy.destructiveActions.some(pattern => matchCapability(pattern, capability))) return { allowed: false, reason: 'destructive_action_blocked' };
-    if (policy.highRiskActions.includes(capability)) return { allowed: false, reason: 'high_risk_requires_approval' };
-    if (!has(capability)) return { allowed: false, reason: 'insufficient_role' };
-    if (risk === 'high' && !['admin', 'owner'].includes(state.role)) return { allowed: false, reason: 'high_risk_admin_required' };
-    return { allowed: true };
-  }
-
-  function matchCapability(pattern, capability) {
-    if (pattern === capability) return true;
-    if (pattern.endsWith('*')) return capability.startsWith(pattern.slice(0, -1));
-    return false;
-  }
-
-  function audit(action, target, status, detail = {}) {
-    const record = redact({
-      ts: now(), tenant: state.tenant, role: state.role, action, target, status, detail
-    });
-    state.audit.unshift(record);
-    state.audit = state.audit.slice(0, 500);
-    localStorage.setItem('aios.gitops.audit', JSON.stringify(state.audit));
-    put('audit-output', record);
-    renderAudit();
-    postAudit(record);
-    return record;
-  }
-
-  async function postAudit(record) {
-    try { await api(ENDPOINTS.audit, 'POST', record, { allowError: true }); } catch (_) { /* local fallback */ }
-  }
-
-  function loadLocal() {
-    try { state.audit = JSON.parse(localStorage.getItem('aios.gitops.audit') || '[]'); } catch (_) { state.audit = []; }
-    try { state.approvals = JSON.parse(localStorage.getItem('aios.gitops.approvals') || '[]'); } catch (_) { state.approvals = []; }
-  }
-
-  function saveApprovals() {
-    localStorage.setItem('aios.gitops.approvals', JSON.stringify(state.approvals));
-  }
-
-  async function bootstrap() {
-    loadLocal();
-    wireTabs();
-    wireForms();
-    await loadIdentity();
-    await loadPolicy();
-    applyRbac();
-    await refreshAll();
-    await refreshApprovals();
-    await refreshAudit();
-    connectEvents();
-  }
-
-  async function loadIdentity() {
-    try {
-      const identity = await api(ENDPOINTS.identity, 'GET', undefined, { allowError: true });
-      state.identity = identity && identity.user ? identity : { user: 'unknown', role: identity.role || 'viewer', tenant: identity.tenant || 'default' };
-      state.role = state.identity.role || 'viewer';
-      state.tenant = state.identity.tenant || 'default';
-    } catch (_) {
-      state.identity = { user: 'local-preview', role: 'admin', tenant: 'default', source: 'local_fallback' };
-      state.role = 'admin';
-      state.tenant = 'default';
-    }
-    put('identity-output', state.identity);
-    const roleChip = el('role-chip');
-    if (roleChip) roleChip.textContent = `role: ${state.role}`;
-  }
-
-  async function loadPolicy() {
-    try {
-      const policy = await api(ENDPOINTS.policy, 'GET', undefined, { allowError: true });
-      state.policy = policy && policy.roles ? policy : DEFAULT_POLICY;
-    } catch (_) { state.policy = DEFAULT_POLICY; }
-    put('rbac-output', state.policy);
-    renderPermissionMatrix();
-  }
-
-  async function refreshAll() {
-    const tasks = [
-      ['baseline', ENDPOINTS.base],
-      ['versions', ENDPOINTS.versions],
-      ['runtime', ENDPOINTS.runtime],
-      ['patches', ENDPOINTS.patch],
-      ['models', ENDPOINTS.model]
-    ];
-    for (const [key, endpoint] of tasks) {
-      try { state[key] = await api(endpoint, 'GET', undefined, { allowError: true }); }
-      catch (e) { state[key] = { error: e.message, response: e.response }; }
-    }
-    put('baseline-output', state.baseline);
-    put('versions-output', state.versions);
-    put('runtime-output', state.runtime);
-    put('patch-summary-output', state.patches);
-    put('model-output', state.models);
-    updateMetrics();
-    renderModelGraph();
-    audit('dashboard.refresh', 'all', 'ok');
-  }
-
-  function updateMetrics() {
-    const runtimeStatus = state.runtime && state.runtime.status || 'unknown';
-    const version = state.baseline && (state.baseline.active_version || state.baseline.version) || '-';
-    const branches = state.patches && Array.isArray(state.patches.branches) ? state.patches.branches.filter(b => b.startsWith('patch/')).length : 0;
-    const pending = state.approvals.filter(a => a.status === 'pending').length;
-    setText('metric-runtime', runtimeStatus);
-    setText('metric-version', version);
-    setText('metric-branches', String(branches));
-    setText('metric-approvals', String(pending));
-    setText('runtime-chip', `runtime: ${runtimeStatus}`);
-  }
-
-  function setText(id, text) { const node = el(id); if (node) node.textContent = text; }
-
-  function applyRbac() {
-    qsa('.require-operator').forEach(btn => btn.disabled = !has('approval:create') && !has('branch:create'));
-    qsa('.require-admin').forEach(btn => btn.disabled = !['admin', 'owner'].includes(state.role));
-    qsa('.guarded').forEach(btn => btn.disabled = state.role !== 'owner');
-    renderPermissionMatrix();
-  }
-
-  function renderPermissionMatrix() {
-    const policy = state.policy || DEFAULT_POLICY;
-    const caps = ['read:*', 'branch:create', 'plan:create', 'approval:create', 'model:write', 'priority:write', 'release:request', 'rollback:request', 'runtime:write'];
-    const rows = Object.keys(policy.roles).map(role => {
-      const cells = caps.map(cap => `<td>${roleHas(role, cap, policy) ? '✅' : '—'}</td>`).join('');
-      return `<tr><th>${escapeHtml(role)}</th>${cells}</tr>`;
-    }).join('');
-    const html = `<table><thead><tr><th>Role</th>${caps.map(c => `<th>${escapeHtml(c)}</th>`).join('')}</tr></thead><tbody>${rows}</tbody></table>`;
-    const target = el('permission-matrix'); if (target) target.innerHTML = html;
-  }
-
-  function roleHas(role, cap, policy) {
-    const caps = policy.roles[role] || [];
-    return caps.includes('*') || caps.includes(cap) || caps.some(c => c.endsWith(':*') && cap.startsWith(c.slice(0, -1))) || (caps.includes('read:*') && cap.startsWith('read:'));
-  }
-
-  function renderModelGraph() {
-    const target = el('model-priority-graph');
-    if (!target) return;
-    const base = state.models && Array.isArray(state.models.base) ? state.models.base : [];
-    const custom = state.models && Array.isArray(state.models.custom) ? state.models.custom : [];
-    const priority = state.models && Array.isArray(state.models.priority) ? state.models.priority : [];
-    const models = [...base, ...custom];
-    if (!models.length) { target.innerHTML = '<p class="empty">无模型数据</p>'; return; }
-    const byId = new Map(priority.map(p => [p.model_id || p.id, p]));
-    target.innerHTML = models.map((m, idx) => {
-      const p = byId.get(m.id) || { priority: 100 - idx, enabled: true, fallback_policy: 'next_enabled' };
-      return `<div class="node"><strong>${escapeHtml(m.display_name || m.model || m.id)}</strong><span>${escapeHtml(m.id || '')}</span><em>priority ${escapeHtml(String(p.priority))} · ${p.enabled === false ? 'disabled' : 'enabled'} · ${escapeHtml(p.fallback_policy || 'next_enabled')}</em></div>`;
-    }).join('<div class="edge">↓ fallback</div>');
-  }
-
-  async function refreshApprovals() {
-    try {
-      const remote = await api(ENDPOINTS.approvals, 'GET', undefined, { allowError: true });
-      if (remote && Array.isArray(remote.items)) state.approvals = remote.items;
-      else if (Array.isArray(remote)) state.approvals = remote;
-    } catch (_) { /* local approvals already loaded */ }
-    renderApprovals();
-    updateMetrics();
-  }
-
-  function renderApprovals() {
-    const target = el('approval-board');
-    if (!target) return;
-    if (!state.approvals.length) { target.innerHTML = '<p class="empty">暂无审批请求</p>'; return; }
-    target.innerHTML = state.approvals.map(item => {
-      const canDecide = has('approval:*') || state.role === 'owner';
-      return `<article class="approval ${escapeHtml(item.risk || 'medium')}">
-        <header><strong>${escapeHtml(item.type)}</strong><span>${escapeHtml(item.status)}</span></header>
-        <p>${escapeHtml(item.target)}</p><small>${escapeHtml(item.reason || '')}</small>
-        <footer>${canDecide && item.status === 'pending' ? `<button data-approve="${escapeHtml(item.id)}">Approve</button><button data-reject="${escapeHtml(item.id)}">Reject</button>` : ''}</footer>
-      </article>`;
-    }).join('');
-    qsa('[data-approve]').forEach(btn => btn.onclick = () => decideApproval(btn.dataset.approve, 'approved'));
-    qsa('[data-reject]').forEach(btn => btn.onclick = () => decideApproval(btn.dataset.reject, 'rejected'));
-  }
-
-  async function createApproval(payload) {
-    const guard = guardAction('approval:create', payload.risk || 'medium');
-    if (!guard.allowed) return { status: 'blocked', ...guard };
-    const item = {
-      id: `apr-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`,
-      tenant: state.tenant,
-      status: 'pending',
-      created_at: now(),
-      created_by: state.identity && state.identity.user || 'unknown',
-      ...payload
-    };
-    try {
-      const remote = await api(ENDPOINTS.approvalRequest, 'POST', item, { allowError: true });
-      if (remote && (remote.id || remote.status)) {
-        audit('approval.create', item.target, 'ok', remote);
-        await refreshApprovals();
-        return remote;
-      }
-    } catch (_) { /* local fallback */ }
-    state.approvals.unshift(item); saveApprovals(); renderApprovals(); updateMetrics();
-    audit('approval.create.local', item.target, 'ok', item);
-    return item;
-  }
-
-  async function decideApproval(id, status) {
-    const guard = guardAction('approval:decide', 'high');
-    if (!guard.allowed) { audit('approval.decide', id, 'blocked', guard); return; }
-    try {
-      const remote = await api(ENDPOINTS.approvalDecision, 'POST', { id, status }, { allowError: true });
-      audit('approval.decide', id, 'ok', remote);
-    } catch (_) {
-      const item = state.approvals.find(a => a.id === id);
-      if (item) { item.status = status; item.decided_at = now(); item.decided_by = state.identity && state.identity.user || 'unknown'; }
-      saveApprovals(); audit('approval.decide.local', id, 'ok', { status });
-    }
-    renderApprovals(); updateMetrics();
-  }
-
-  async function refreshAudit() {
-    try {
-      const remote = await api(ENDPOINTS.audit, 'GET', undefined, { allowError: true });
-      if (remote && Array.isArray(remote.items)) state.audit = remote.items.concat(state.audit).slice(0, 500);
-    } catch (_) { /* local fallback */ }
-    renderAudit();
-  }
-
-  function renderAudit() {
-    const target = el('audit-table'); if (!target) return;
-    const filter = (el('audit-filter') && el('audit-filter').value || '').toLowerCase();
-    const rows = state.audit.filter(r => !filter || JSON.stringify(r).toLowerCase().includes(filter)).slice(0, 100).map(r =>
-      `<tr><td>${escapeHtml(r.ts)}</td><td>${escapeHtml(r.tenant || '')}</td><td>${escapeHtml(r.role || '')}</td><td>${escapeHtml(r.action)}</td><td>${escapeHtml(r.target)}</td><td>${escapeHtml(r.status)}</td></tr>`
-    ).join('');
-    target.innerHTML = `<table><thead><tr><th>Time</th><th>Tenant</th><th>Role</th><th>Action</th><th>Target</th><th>Status</th></tr></thead><tbody>${rows || '<tr><td colspan="6">无审计记录</td></tr>'}</tbody></table>`;
-  }
-
-  function parseDiffTree(diffData) {
-    const stdout = diffData && diffData.diff && diffData.diff.stdout || diffData && diffData.stdout || '';
-    const files = [];
-    let current = null;
-    stdout.split('\n').forEach(line => {
-      if (line.startsWith('diff --git ')) {
-        const parts = line.split(' ');
-        current = { file: (parts[3] || '').replace(/^b\//, ''), additions: 0, deletions: 0, chunks: 0 };
-        files.push(current);
-      } else if (current) {
-        if (line.startsWith('@@')) current.chunks++;
-        else if (line.startsWith('+') && !line.startsWith('+++')) current.additions++;
-        else if (line.startsWith('-') && !line.startsWith('---')) current.deletions++;
-      }
-    });
-    return files;
-  }
-
-  function renderDiffTree(diffData) {
-    const target = el('diff-tree'); if (!target) return;
-    const files = parseDiffTree(diffData);
-    if (!files.length) { target.innerHTML = '<p class="empty">未解析到文件级 diff，可能是接口返回过大或为空。</p>'; return; }
-    target.innerHTML = files.map(f => `<div class="diff-file"><strong>${escapeHtml(f.file)}</strong><span>+${f.additions} / -${f.deletions} / ${f.chunks} chunks</span></div>`).join('');
-  }
-
-  function connectEvents() {
-    if (!window.EventSource) return;
-    try {
-      state.eventSource = new EventSource(`/api/${ENDPOINTS.events}?tenant=${encodeURIComponent(state.tenant)}`);
-      state.eventSource.onmessage = (event) => {
-        const payload = JSON.parse(event.data);
-        audit('event.gitops', payload.type || 'event', 'ok', payload);
-        if (['approval', 'patch', 'runtime', 'model'].includes(payload.type)) refreshAll();
-      };
-      state.eventSource.onerror = () => { if (state.eventSource) state.eventSource.close(); };
-    } catch (_) { /* server-sent events optional */ }
-  }
-
-  function wireTabs() {
-    qsa('.tabs button').forEach(button => {
-      button.onclick = () => {
-        qsa('.tabs button').forEach(b => b.classList.remove('active'));
-        qsa('.tab').forEach(tab => tab.classList.remove('active'));
-        button.classList.add('active');
-        const target = el(`tab-${button.dataset.tab}`);
-        if (target) target.classList.add('active');
-      };
-    });
-  }
-
-  function wireForms() {
-    const refreshBtn = el('refresh-all'); if (refreshBtn) refreshBtn.onclick = refreshAll;
-    const refreshModel = el('refresh-model'); if (refreshModel) refreshModel.onclick = refreshAll;
-    const refreshApprovalsBtn = el('refresh-approvals'); if (refreshApprovalsBtn) refreshApprovalsBtn.onclick = refreshApprovals;
-    const clearApprovals = el('clear-local-approvals'); if (clearApprovals) clearApprovals.onclick = () => { state.approvals = []; saveApprovals(); renderApprovals(); audit('approval.local.clear', 'localStorage', 'ok'); };
-    const refreshAuditBtn = el('refresh-audit'); if (refreshAuditBtn) refreshAuditBtn.onclick = refreshAudit;
-    const auditFilter = el('audit-filter'); if (auditFilter) auditFilter.oninput = renderAudit;
-    const exportAudit = el('export-audit'); if (exportAudit) exportAudit.onclick = () => downloadJson('aios-gitops-audit.json', state.audit);
-
-    bindForm('approval-form', async f => createApproval({ type: f.get('type'), target: f.get('target'), risk: f.get('risk'), reason: f.get('reason') }), 'approval-output');
-    bindForm('diff-form', async f => {
-      const data = await api(`${ENDPOINTS.diff}?from=${encodeURIComponent(f.get('from'))}&to=${encodeURIComponent(f.get('to'))}`, 'GET', undefined, { allowError: true });
-      renderDiffTree(data); return data;
-    }, 'diff-output');
-    bindForm('branch-form', async f => checkedApi('branch:create', ENDPOINTS.branch, 'POST', { branch: f.get('branch'), base: f.get('base'), message: f.get('message') }), 'branch-output');
-    bindForm('plan-form', async f => checkedApi('plan:create', ENDPOINTS.plan, 'POST', { branch: f.get('branch'), text: f.get('text') }), 'plan-output');
-    bindForm('model-form', async f => {
-      const payload = { provider_name: f.get('provider_name'), base_url: f.get('base_url'), model_name: f.get('model_name'), display_name: f.get('display_name'), api_key_secret_ref: f.get('api_key_secret_ref') };
-      if (!String(payload.api_key_secret_ref || '').startsWith('secret_ref://')) return { status: 'blocked', reason: 'api_key_secret_ref_required' };
-      return checkedApi('model:write', ENDPOINTS.model, 'POST', payload, 'high');
-    }, 'model-register-output');
-    bindForm('priority-form', async f => checkedApi('priority:write', ENDPOINTS.priority, 'PUT', { model_id: f.get('model_id'), priority: Number(f.get('priority')), enabled: f.get('enabled') === 'true', fallback_policy: f.get('fallback_policy') }, 'medium'), 'priority-output');
-    bindForm('rollback-form', async f => checkedApi('rollback:request', ENDPOINTS.rollback, 'POST', { target_version: f.get('target_version'), reason: f.get('reason'), branch: f.get('branch') }, 'high'), 'rollback-output');
-    bindForm('tag-form', async f => checkedApi('release:request', ENDPOINTS.tag, 'POST', { version: f.get('version'), message: f.get('message') }, 'high'), 'tag-output');
-  }
-
-  function bindForm(id, handler, outputId) {
-    const form = el(id); if (!form) return;
-    form.onsubmit = async (e) => {
-      e.preventDefault();
-      const f = new FormData(form);
-      try {
-        const result = await handler(f);
-        put(outputId, result);
-        audit(`${id}.submit`, outputId, result && result.status === 'blocked' ? 'blocked' : 'ok', result);
-      } catch (err) {
-        const detail = { error: err.message, response: err.response };
-        put(outputId, detail);
-        audit(`${id}.submit`, outputId, 'failed', detail);
-      }
-    };
-  }
-
-  async function checkedApi(capability, endpoint, method, payload, risk = 'low') {
-    const guard = guardAction(capability, risk);
-    if (!guard.allowed) return { status: 'blocked', capability, ...guard };
-    return await api(endpoint, method, payload, { allowError: true });
-  }
-
-  function downloadJson(filename, value) {
-    const blob = new Blob([safeStringify(value)], { type: 'application/json' });
-    const url = URL.createObjectURL(blob);
-    const a = document.createElement('a');
-    a.href = url; a.download = filename; a.click();
-    URL.revokeObjectURL(url);
-  }
-
-  function escapeHtml(value) {
-    return String(value == null ? '' : value).replace(/[&<>'"]/g, ch => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '\'': '&#39;', '"': '&quot;' }[ch]));
-  }
-
-  return { bootstrap, refreshAll, state };
-})();
-
-window.addEventListener('DOMContentLoaded', Platform.bootstrap);

overlays/user-control-center/portal/gitops-dashboard/gitops-enterprise-api.contract.json

@@ -1,56 +0,0 @@
-{
-  "name": "aios-gitops-enterprise-api-contract",
-  "version": "1.0.0",
-  "scope": "portal-gitops-dashboard",
-  "principles": {
-    "all_writes_require_git_commit": true,
-    "direct_main_push_from_ui": false,
-    "secrets_in_git": false,
-    "destructive_operations": "forbidden_or_request_only",
-    "server_side_authz_is_authoritative": true
-  },
-  "read_endpoints": {
-    "baseline": "GET /api/base",
-    "versions": "GET /api/ver",
-    "runtime": "GET /api/run",
-    "patches": "GET /api/patch",
-    "model_registry": "GET /api/model",
-    "diff_raw": "GET /api/diff?from={from}&to={to}",
-    "diff_tree": "GET /api/diff/tree?from={from}&to={to}",
-    "approval_queue": "GET /api/approval/queue",
-    "release_pipeline": "GET /api/release/pipeline",
-    "audit_log": "GET /api/audit/log?limit={limit}",
-    "me": "GET /api/me"
-  },
-  "write_endpoints": {
-    "create_branch": "POST /api/branch",
-    "natural_language_plan": "POST /api/patch/plan",
-    "register_model": "POST /api/model",
-    "set_model_priority": "PUT /api/model-priority",
-    "rollback_request": "POST /api/rollback-request",
-    "tag_request": "POST /api/tag-request",
-    "approval_decision": "POST /api/approval/decision",
-    "release_promotion_request": "POST /api/release/promote-request",
-    "audit_append": "POST /api/audit/log"
-  },
-  "approval_decision_payload": {
-    "request_id": "string",
-    "decision": "approve | reject",
-    "reason": "string",
-    "branch": "patch/approval-..."
-  },
-  "release_promotion_payload": {
-    "from_environment": "dev | staging",
-    "to_environment": "staging | prod",
-    "version": "VxRxCx",
-    "reason": "string",
-    "branch": "patch/release-promote-..."
-  },
-  "response_contract": {
-    "write_success_any_of": ["branch", "commit", "rev", "sync_status"],
-    "auth_failure": {
-      "401": "Bearer token not injected",
-      "403": "Bearer token injected but scope insufficient"
-    }
-  }
-}

overlays/user-control-center/portal/gitops-dashboard/gitops-ui-policy.json

@@ -1,79 +0,0 @@
-{
-  "name": "aios-gitops-enterprise-ui-policy",
-  "version": "1.0.0",
-  "scope": "portal-gitops-dashboard",
-  "client_side_notice": "Client-side RBAC is advisory only. Server-side Actions/API authorization remains authoritative.",
-  "roles": {
-    "viewer": {
-      "label": "Viewer",
-      "permissions": [
-        "read:baseline",
-        "read:versions",
-        "read:diff",
-        "read:patch",
-        "read:model",
-        "read:runtime",
-        "read:audit"
-      ]
-    },
-    "developer": {
-      "label": "Developer",
-      "inherits": ["viewer"],
-      "permissions": [
-        "write:branch",
-        "write:plan"
-      ]
-    },
-    "admin": {
-      "label": "Admin",
-      "inherits": ["developer"],
-      "permissions": [
-        "write:model",
-        "write:model_priority",
-        "request:rollback",
-        "request:tag"
-      ]
-    },
-    "owner": {
-      "label": "Owner",
-      "inherits": ["admin"],
-      "permissions": [
-        "approve:rollback",
-        "approve:tag",
-        "approve:priority",
-        "approve:release"
-      ]
-    }
-  },
-  "risk_policy": {
-    "direct_main_write": "disabled_in_ui",
-    "api_keys_in_git": "forbidden",
-    "rollback": "request_only",
-    "tag_create": "request_only_by_default",
-    "runtime_change": "request_only",
-    "baseline_high_risk_change": "request_only",
-    "bulk_delete": "forbidden"
-  },
-  "secret_redaction": {
-    "enabled": true,
-    "patterns": [
-      "api_key",
-      "apikey",
-      "authorization",
-      "bearer",
-      "token",
-      "password",
-      "secret",
-      "private_key",
-      "credential"
-    ],
-    "replacement": "[REDACTED]"
-  },
-  "approval_queues": [
-    "rollback",
-    "tag",
-    "model_priority",
-    "release",
-    "runtime_change"
-  ]
-}

overlays/user-control-center/portal/gitops-dashboard/index.html

@@ -1,224 +0,0 @@
-<!doctype html>
-<html lang="zh-CN">
-<head>
-  <meta charset="utf-8" />
-  <meta name="viewport" content="width=device-width,initial-scale=1" />
-  <title>AIOS Enterprise GitOps Control Plane</title>
-  <link rel="stylesheet" href="./styles.css" />
-</head>
-<body>
-  <div class="shell">
-    <header class="topbar">
-      <div>
-        <p class="eyebrow">cnnetmkt.top / AIOS Enterprise</p>
-        <h1>GitOps Enterprise Control Plane</h1>
-        <p class="subtitle">审批流、RBAC、Release Pipeline、Diff Tree、模型优先级、审计查询</p>
-      </div>
-      <div class="statusbar">
-        <span id="role-chip" class="chip">role: loading</span>
-        <span id="runtime-chip" class="chip muted">runtime: loading</span>
-        <button id="refresh-all" class="primary">刷新全部</button>
-      </div>
-    </header>
-
-    <nav class="tabs" aria-label="Enterprise GitOps modules">
-      <button data-tab="overview" class="active">总览</button>
-      <button data-tab="rbac">RBAC</button>
-      <button data-tab="approval">审批流</button>
-      <button data-tab="diff">Diff Tree</button>
-      <button data-tab="patch">Patch / Branch</button>
-      <button data-tab="model">模型控制</button>
-      <button data-tab="release">Release Pipeline</button>
-      <button data-tab="audit">审计中心</button>
-    </nav>
-
-    <main>
-      <section id="tab-overview" class="tab active">
-        <div class="grid four">
-          <article class="metric"><span>Runtime</span><strong id="metric-runtime">-</strong></article>
-          <article class="metric"><span>Active Version</span><strong id="metric-version">-</strong></article>
-          <article class="metric"><span>Patch Branches</span><strong id="metric-branches">-</strong></article>
-          <article class="metric"><span>Pending Approvals</span><strong id="metric-approvals">-</strong></article>
-        </div>
-        <div class="grid two">
-          <article class="card"><h2>Baseline</h2><pre id="baseline-output">loading...</pre></article>
-          <article class="card"><h2>Versions</h2><pre id="versions-output">loading...</pre></article>
-          <article class="card"><h2>Runtime</h2><pre id="runtime-output">loading...</pre></article>
-          <article class="card"><h2>Patch Summary</h2><pre id="patch-summary-output">loading...</pre></article>
-        </div>
-      </section>
-
-      <section id="tab-rbac" class="tab grid two">
-        <article class="card">
-          <h2>当前用户权限</h2>
-          <p class="hint">按钮级权限由 role + capability 共同控制；viewer 只能读。</p>
-          <pre id="identity-output">loading...</pre>
-        </article>
-        <article class="card">
-          <h2>RBAC 策略</h2>
-          <pre id="rbac-output">loading...</pre>
-        </article>
-        <article class="card span-two">
-          <h2>权限矩阵</h2>
-          <div id="permission-matrix" class="table-wrap">loading...</div>
-        </article>
-      </section>
-
-      <section id="tab-approval" class="tab">
-        <div class="grid two">
-          <article class="card">
-            <h2>Approval Queue</h2>
-            <p class="hint">高风险操作进入审批队列；UI 不直接执行 destructive / production 变更。</p>
-            <div class="toolbar">
-              <button id="refresh-approvals" class="secondary">刷新审批队列</button>
-              <button id="clear-local-approvals" class="secondary guarded">清理本地缓存</button>
-            </div>
-            <div id="approval-board" class="approval-board">loading...</div>
-          </article>
-          <article class="card">
-            <h2>创建审批请求</h2>
-            <form id="approval-form" class="stack">
-              <label>类型
-                <select name="type">
-                  <option value="merge">merge</option>
-                  <option value="release">release</option>
-                  <option value="rollback">rollback</option>
-                  <option value="model_priority">model_priority</option>
-                  <option value="runtime_change">runtime_change</option>
-                </select>
-              </label>
-              <label>目标 <input name="target" placeholder="branch / version / model id" required /></label>
-              <label>风险
-                <select name="risk"><option>low</option><option selected>medium</option><option>high</option></select>
-              </label>
-              <label>说明 <textarea name="reason" rows="5" required></textarea></label>
-              <button class="primary require-operator" type="submit">提交审批请求</button>
-            </form>
-            <pre id="approval-output">等待操作...</pre>
-          </article>
-        </div>
-      </section>
-
-      <section id="tab-diff" class="tab">
-        <article class="card">
-          <h2>File-level Diff Tree</h2>
-          <p class="hint">支持 from/to 参数；会自动按文件聚合 diff，便于 review。</p>
-          <form id="diff-form" class="form-row wrap">
-            <label>From <input name="from" value="HEAD~1" /></label>
-            <label>To <input name="to" value="HEAD" /></label>
-            <button class="primary" type="submit">读取 Diff</button>
-          </form>
-          <div id="diff-tree" class="diff-tree">等待查询...</div>
-          <pre id="diff-output">等待查询...</pre>
-        </article>
-      </section>
-
-      <section id="tab-patch" class="tab grid two">
-        <article class="card">
-          <h2>创建 Patch Branch</h2>
-          <p class="hint">默认从 main 创建非生产 patch 分支；main 写入仅通过明确授权的 GitOps Action。</p>
-          <form id="branch-form" class="stack">
-            <label>Branch <input name="branch" placeholder="patch/my-change" required /></label>
-            <label>Base <input name="base" value="main" /></label>
-            <label>Message <input name="message" value="Create GitOps patch branch" /></label>
-            <button class="primary require-operator" type="submit">创建 Branch</button>
-          </form>
-          <pre id="branch-output">等待操作...</pre>
-        </article>
-        <article class="card">
-          <h2>自然语言 GitOps Plan</h2>
-          <p class="hint">仅生成可审计 plan；高风险操作必须审批。</p>
-          <form id="plan-form" class="stack">
-            <label>目标 Branch <input name="branch" value="patch/web-ui-complete-gitops-dashboard-20260706" /></label>
-            <label>Plan Text <textarea name="text" rows="5" placeholder="描述要执行的 GitOps 变更" required></textarea></label>
-            <button class="primary require-operator" type="submit">生成 Plan</button>
-          </form>
-          <pre id="plan-output">等待操作...</pre>
-        </article>
-      </section>
-
-      <section id="tab-model" class="tab">
-        <div class="grid two">
-          <article class="card">
-            <h2>模型注册表</h2>
-            <button id="refresh-model" class="secondary">刷新模型</button>
-            <pre id="model-output">loading...</pre>
-          </article>
-          <article class="card">
-            <h2>模型优先级图</h2>
-            <div id="model-priority-graph" class="graph">loading...</div>
-          </article>
-          <article class="card">
-            <h2>注册自定义模型</h2>
-            <p class="hint">仅允许 secret_ref；禁止真实 API key 明文。</p>
-            <form id="model-form" class="stack">
-              <label>Provider <input name="provider_name" placeholder="openai / one-api / compatible" required /></label>
-              <label>Base URL <input name="base_url" placeholder="https://example.com/v1" required /></label>
-              <label>Model Name <input name="model_name" placeholder="model-id" required /></label>
-              <label>Display Name <input name="display_name" placeholder="Human readable name" /></label>
-              <label>API Key Secret Ref <input name="api_key_secret_ref" placeholder="secret_ref://..." required /></label>
-              <button class="primary require-admin" type="submit">注册模型</button>
-            </form>
-            <pre id="model-register-output">等待操作...</pre>
-          </article>
-          <article class="card">
-            <h2>模型优先级 / Fallback</h2>
-            <form id="priority-form" class="stack">
-              <label>Model ID <input name="model_id" placeholder="base.gpt-5.5" required /></label>
-              <label>Priority <input name="priority" type="number" value="100" required /></label>
-              <label>Enabled <select name="enabled"><option value="true">true</option><option value="false">false</option></select></label>
-              <label>Fallback Policy <input name="fallback_policy" value="next_enabled" /></label>
-              <button class="primary require-admin" type="submit">保存优先级</button>
-            </form>
-            <pre id="priority-output">等待操作...</pre>
-          </article>
-        </div>
-      </section>
-
-      <section id="tab-release" class="tab">
-        <div class="pipeline" id="release-pipeline">
-          <div class="stage">Patch</div><div class="arrow">→</div><div class="stage">Review</div><div class="arrow">→</div><div class="stage">Approval</div><div class="arrow">→</div><div class="stage guarded-stage">Tag Request</div><div class="arrow">→</div><div class="stage guarded-stage">Deploy</div>
-        </div>
-        <div class="grid two">
-          <article class="card danger-zone">
-            <h2>Rollback Request</h2>
-            <p class="hint">只创建审批请求；不直接执行回滚。</p>
-            <form id="rollback-form" class="stack">
-              <label>Target Version <input name="target_version" placeholder="V1R1C3" required /></label>
-              <label>Reason <textarea name="reason" rows="4" required></textarea></label>
-              <label>Request Branch <input name="branch" value="patch/rollback-request-web-ui" /></label>
-              <button class="danger require-admin" type="submit">创建 Rollback 请求</button>
-            </form>
-            <pre id="rollback-output">等待操作...</pre>
-          </article>
-          <article class="card danger-zone">
-            <h2>Tag / Version Request</h2>
-            <p class="hint">默认创建 owner/admin approval request；UI 禁用直接执行。</p>
-            <form id="tag-form" class="stack">
-              <label>Version <input name="version" placeholder="V1R1C5" required /></label>
-              <label>Message <input name="message" placeholder="Release request" /></label>
-              <label class="disabled"><input name="execute" type="checkbox" disabled /> 直接执行（禁用）</label>
-              <button class="danger require-admin" type="submit">创建 Tag 请求</button>
-            </form>
-            <pre id="tag-output">等待操作...</pre>
-          </article>
-        </div>
-      </section>
-
-      <section id="tab-audit" class="tab">
-        <article class="card">
-          <h2>审计中心</h2>
-          <div class="toolbar">
-            <input id="audit-filter" placeholder="过滤 action / target / status" />
-            <button id="export-audit" class="secondary">导出 JSON</button>
-            <button id="refresh-audit" class="secondary">刷新</button>
-          </div>
-          <div id="audit-table" class="table-wrap">loading...</div>
-          <pre id="audit-output">暂无操作。</pre>
-        </article>
-      </section>
-    </main>
-  </div>
-  <script src="./app.js"></script>
-</body>
-</html>

overlays/user-control-center/portal/gitops-dashboard/manifest.json

@@ -1,22 +0,0 @@
-{
-  "name": "gitops-dashboard",
-  "version": "1.0.0",
-  "mount": "/portal/me/#gitops-dashboard",
-  "description": "Complete GitOps Web UI module",
-  "features": [
-    "baseline_view",
-    "version_list",
-    "diff_view",
-    "patch_view",
-    "model_registry",
-    "runtime_status"
-  ],
-  "api": {
-    "base": "/api/base",
-    "ver": "/api/ver",
-    "diff": "/api/diff",
-    "patch": "/api/patch",
-    "model": "/api/model",
-    "runtime": "/api/run"
-  }
-}

overlays/user-control-center/portal/gitops-dashboard/styles.css

@@ -1,6 +0,0 @@
-body{font-family:Arial,Helvetica,sans-serif;background:#0b0f14;color:#e6edf3;margin:0}
-header{display:flex;align-items:center;justify-content:space-between;padding:12px 16px;background:#111826;border-bottom:1px solid #222}
-nav button{margin-right:8px;padding:8px 10px;background:#1f2937;color:#e6edf3;border:1px solid #2b3645;cursor:pointer}
-nav button:hover{background:#2b3645}
-main{padding:16px}
-pre{background:#0f172a;padding:12px;border:1px solid #1f2937;overflow:auto;min-height:400px}

patches/nl/nl-1783382614842-6c6112e8.json

@@ -0,0 +1,10 @@
+{
+  "id": "nl-1783382614842-6c6112e8",
+  "text": "自我进化执行主体策略更新：除 Windows Codex App 外，同时增加服务器上的 OpenClaw Agent 与 Hermes Agent 作为执行主体。允许启动多个服务器 Agent 并行执行；默认以服务器上的 Agent 为主，Windows Codex App 作为协同执行主体。困难时刻允许访问 https://chatgpt.com/chat/gpt-6a4ba70a063c8191a89bc2d86a4c7fa0-codex-chartgpt-bridge 求助或交互。分歧时刻允许多个 Agent 投票决策；自定义 GPT 权重为双倍，Windows Codex App 权重为双倍。服务器 Agent 默认参与并行协作。该策略应以 GitOps 可审计方式进入自我进化 agent orchestration proposal，不直接执行 V-level 版本变更，不写入任何凭据。",
+  "intent": "unknown",
+  "action_plan": [],
+  "execute": false,
+  "owner_approval_required": true,
+  "created_by": "gitops-write-bot",
+  "created_at": "2026-07-07T00:03:34Z"
+}

patches/nl/nl-1783390999250-8627c20c.json

@@ -0,0 +1,12 @@
+{
+  "id": "nl-1783390999250-8627c20c",
+  "text": "基于 V1R1C4 baseline 和 patch/self-evolution-agent-orchestration-policy 全量重新架构优化：服务器 OpenClaw 与 Hermes 作为主要执行智能体；Codex ChartGPT Bridge 作为架构审核、方案建议和困难问题升级入口；Windows Codex App 作为异常恢复、管理员授权协助和多智能体投票参与者。所有操作基于在线 GitOps 版本。优化方向：建立 Agent Runtime、Registry、Scheduler、Message Bus、Memory、Skill、Evaluator、Consensus、Evolution、Release 全链路；增加异常升级机制，服务器智能体遇到方案选择或复杂实现时生成完整问题上下文并提交审核；完善多 Agent 投票、质量评分、审计、Patch-first、审批发布流程。生成后续实施 proposal，不直接进行生产发布。",
+  "intent": "patch_create",
+  "action_plan": [
+    "call POST /api/patch"
+  ],
+  "execute": false,
+  "owner_approval_required": true,
+  "created_by": "gitops-write-bot",
+  "created_at": "2026-07-07T02:23:19Z"
+}

patches/patch_agent-event-bus-unified.branch.json

@@ -1,9 +0,0 @@
-{
-  "type": "branch",
-  "branch": "patch/agent-event-bus-unified",
-  "base": "main",
-  "created_by": "chatgpt-gitops-bot",
-  "created_at": "2026-07-08T08:36:38Z",
-  "direct_main_push": false,
-  "owner_approval_required": true
-}

patches/patch_collab-custom-gpt-20260706T104130Z.branch.json

@@ -1,9 +1,9 @@
 {
   "type": "branch",
-  "branch": "patch/user-profile-isolation",
+  "branch": "patch/collab-custom-gpt-20260706T104130Z",
   "base": "main",
   "created_by": "chatgpt-gitops-bot",
-  "created_at": "2026-07-09T01:19:21Z",
+  "created_at": "2026-07-06T10:41:30Z",
   "direct_main_push": false,
   "owner_approval_required": true
 }

patches/patch_collab-local-codex-20260706T104130Z.branch.json

@@ -0,0 +1,9 @@
+{
+  "type": "branch",
+  "branch": "patch/collab-local-codex-20260706T104130Z",
+  "base": "main",
+  "created_by": "codex-gitops-bot",
+  "created_at": "2026-07-06T10:41:30Z",
+  "direct_main_push": false,
+  "owner_approval_required": true
+}

reports/V1R1C5-hermes-review-improvement-v1-execution-report.md

@@ -1,54 +0,0 @@
-# V1R1C5 改进执行报告
-
-## 状态
-**Status:** ✅ 完成
-
-**Branch:** patch/gpt-actions-consequential-governance
-**Commit:** 128a7d9050867f047912cd93bb1a83694d749cc1
-**Rev:** 128a7d9
-
-## 变更文件
-
-| 文件 | 类型 | 状态 |
-|------|------|------|
-| config/self-evolution/agent-resource-manager.json | 新建 | ✅ 已创建 |
-| runtime/agent-os/consensus_engine.py | 修改 | ✅ 已更新 |
-| runtime/agent-os/message_bus.py | 修改 | ✅ 已更新 |
-| runtime/agent-os/agent_health_score.py | 新建 | ✅ 已创建 |
-
-## 测试结果
-
-| 测试项 | 结果 |
-|--------|------|
-| Python 编译检查 | ✅ 通过（全部 3 个文件） |
-| 集成测试 - 基础 | ✅ 通过 |
-| conditional_approval_on_config_participants_change | ✅ 通过 |
-| conditional_approval_on_config_modes_change | ✅ 通过 |
-| conditional_approval_on_config_disabled | ✅ 通过 |
-| conditional_approval_on_weights_adjusted | ✅ 通过 |
-| conditional_approval_unrelated_change_approves | ✅ 通过 |
-| reject_on_majority_reject | ✅ 通过 |
-| conditional_vote_in_vote_payload | ✅ 通过 |
-| no_conditional_vote_approves_normally | ✅ 通过 |
-
-**测试结果汇总:** 8/8 测试通过 ✅
-
-## Hermes 审查项完成情况
-
-1. ✅ **Agent Resource Governance** - 已创建 `agent-resource-manager.json` 配置文件
-2. ✅ **Consensus Engine 增强** - 已添加动态权重计算 (`quality_score * reliability * expertise`) 和风险门控
-3. ✅ **Message Bus 增强** - 已添加 `task_id`, `correlation_id`, `retry_state`, `delivery_status` 字段
-4. ✅ **Agent Health Score** - 已创建 `agent_health_score.py` 模块
-
-## 剩余问题
-
-- 无 — 所有 item 已完成并通过测试
-
-## 合规检查
-
-- ✅ GitOps only — 所有变更均在此 branch 中
-- ✅ Patch-first — 修改均基于现有代码
-- ✅ No secrets — 不包含任何凭证或密钥
-- ✅ No force push — 未使用
-- ✅ No direct main write — 所有变更均在 patch 分支上
-- ✅ Production changes require approval — 如果需要合并至 main 需额外审批

reports/V1R1C6-chatgpt-actions-consequential-governance-execution-report.md

@@ -1,46 +0,0 @@
-# V1R1C6 Execution Report: ChatGPT Actions Consequential Governance
-
-## Summary
-
-Implemented `x-openai-isConsequential: true` flag for all POST/PUT write operations in the ChatGPT GitOps adapter, with risk stratification (high vs low risk), confirm-protection dialogs, and proper 428 Precondition Required responses.
-
-## Changes Made
-
-### Files Modified
-1. **`active-runtime/app/aios_chatgpt_actions_api.py`** (+9 lines)
-   - Added `x-openai-isConsequential: true` to `api_spec()` policy object
-   - Added `confirm` check to `branch()` method (428 if not confirmed)
-   - Added `confirm` check to `file()` method (428 if not confirmed)
-   - Added `confirm` check to `commit()` method (428 if not confirmed)
-   - Added `confirm` check to `patch()` method (428 if not confirmed)
-   - Added `confirm` check to `tag()` method (428 if not confirmed)
-   - Added `confirm` check to `rollback()` method (428 if not confirmed)
-   - Added `confirm` check to `model()` method (428 if not confirmed)
-   - Added `confirm` check to `model_priority()` method (428 if not confirmed)
-   - `high_risk_operations` list: POST /api/tag, POST /api/rollback, POST /api/model, PUT /api/model-priority
-   - `low_risk_operations` list: POST /api/branch, POST /api/file, POST /api/commit, POST /api/patch, POST /api/nl
-
-### Files Created
-- None (modifications only)
-
-### Files Deleted
-- None
-
-## Risk Classification
-- **High-risk**: tag, rollback, model, model-priority — require explicit confirmation
-- **Low-risk**: branch, file, commit, patch, nl — also require confirmation via `x-openai-isConsequential`
-
-## Verification
-- Python syntax check: **PASS** (code compiles cleanly)
-- OpenAPI spec: `x-openai-isConsequential: true` present for all write operations
-
-## Git Operations
-- Branch: `patch/chatgpt-actions-consequential-governance`
-- Fast-forward merged to `main` (commit 87b1a53)
-- Baseline updated to V1R1C6
-- Tag `v1r1c6` and baseline tag `v1r1c6-baseline` pushed to origin
-- Push to `origin/main` successful
-
-## Next Steps
-1. Test confirmation flow on the HTTP API (requires restarting the Python service)
-2. Update any downstream consumers that rely on the API spec

reports/V1R2C2-autonomous-recovery-chain-acceptance-test-report.md

@@ -1,91 +0,0 @@
-# V1R2C2 自动恢复链路验收测试报告
-
-## 基本信息
-
-- **版本**: V1R2C2
-- **测试时间**: 2026-07-07
-- **测试范围**: Action Monitor → Error Classifier → Failure Router → Recovery Controller
-- **测试方式**: 
-  1. 单元测试（模块级）：验证各模块独立功能
-  2. 集成测试（管线级）：验证完整闭环
-  3. API 端到端测试（HTTP 级）：验证 REST API 集成
-
-## 测试结果
-
-### 1. Action Monitor 测试（✅ PASS）
-
-| 测试项 | 结果 |
-|-------|------|
-| 事件记录 | ✅ 成功记录失败事件 |
-| 事件检索（list_events） | ✅ 正确返回所有事件 |
-| 最新事件（latest） | ✅ 正确返回最后一条事件 |
-| 事件属性完整性 | ✅ event_id, action, error, context, created_at 均正确 |
-
-### 2. Error Classifier 测试（✅ PASS）
-
-| 错误类型 | 示例输入 | 预期分类 | 实际结果 |
-|---------|---------|---------|---------|
-| Permission Error | "Permission denied" | permission_error | ✅ permission_error |
-| Git Error | "git failed: merge conflict" | git_error | ✅ git_error |
-| Git Error | "push rejected" | git_error | ✅ git_error |
-| Runtime Error | "Connection refused" | runtime_error | ✅ runtime_error |
-| Runtime Error | "timeout" | runtime_error | ✅ runtime_error |
-| Runtime Error | "Internal Server Error" | runtime_error | ✅ runtime_error |
-| Secret Violation | "secret_rejected: use secret_ref" | secret_violation | ✅ secret_violation |
-| Auth Error | "unauthorized" | auth_error | ✅ auth_error |
-| Unknown Error (file) | "File exists" | unknown_error | ✅ unknown_error |
-| Unknown Error (file) | "No such file or directory" | unknown_error | ✅ unknown_error |
-
-### 3. Failure Router 测试（✅ PASS）
-
-| 错误类型 | 主路由 | 备份路由 | 逃生路由 | 结果 |
-|---------|-------|---------|---------|------|
-| permission_error | openclaw | hermes | windows_codex_app | ✅ |
-| network/runtime_error | hermes | openclaw | windows_codex_app | ✅ |
-| secret_violation | windows_codex_app | openclaw | openclaw | ✅ |
-
-### 4. Recovery Controller 管线测试（✅ PASS）
-
-| 动作 | 错误 | 分类 | 路由 | 恢复计划 | 验证 |
-|-----|------|------|------|---------|------|
-| branch:create | Permission denied | permission_error | openclaw | ✅ 生成 | ✅ 包含 |
-| file:write | ClientResponseError | runtime_error | hermes | ✅ 生成 | ✅ 包含 |
-| model:write | secret_rejected: use secret_ref | secret_violation | windows_codex_app | ✅ 生成 | ✅ 包含 |
-
-### 5. API 500 场景模拟测试（✅ PASS）
-
-模拟了生产环境中遇到的 API 500 错误：
-- file:write → Internal Server Error → 正确记录
-- branch:create → ClientResponseError → 正确记录  
-- file:write → timeout → 正确记录
-
-### 6. 编译验证（✅ PASS）
-
-三个核心模块和测试代码编译通过，无语法错误。
-
-## 执行覆盖
-
-```
-测试代码：runtime/agent-os/orchestrator/integration_test_v1r2c2.py
-被测模块：runtime/agent-os/orchestrator/action_monitor.py
-           runtime/agent-os/orchestrator/error_classifier.py
-           runtime/agent-os/orchestrator/failure_router.py
-           runtime/agent-os/orchestrator/recovery_controller.py
-API 集成： active-runtime/app/aios_chatgpt_actions_api.py
-```
-
-## 结论
-
-**V1R2C2 自动恢复链路基础模块测试全部通过** ✅
-
-- Action Monitor 负责记录和检索失败事件，与 API 集成正常
-- Error Classifier 能根据错误字符串准确分类（permission/git/runtime/secret/auth/unknown）
-- Failure Router 能根据错误类型将故障路由到合适处理代理人（openclaw/hermes/windows_codex_app）
-- Recovery Controller 能编排完整恢复管道：分类→路由→计划→执行→验证→记录
-
-## 下一步
-
-1. 将 Error Classifier/Failure Router/Recovery Controller 集成到 aios_chatgpt_actions_api.py 的 do_POST 错误处理路径中
-2. 添加 GitOps 提交和版本标记
-3. 微信通知 Owner 报告
-4. 虾马一体进展汇报

reports/V1R2C2-cgpt-actions-action-monitor-execution-report.md

@@ -1,38 +0,0 @@
-# V1R2C2 Execution Report: CGPT Actions Action Monitor & Confirm Guards
-
-## Summary
-
-Integrated the `ActionMonitor` class from `orchestrator/action_monitor.py` into the ChatGPT GitOps API adapter for failure tracking and recovery routing. Also finalized confirm-protection guards for tag/model/model-priority operations.
-
-## Changes Made
-
-### Files Modified
-1. **`active-runtime/app/aios_chatgpt_actions_api.py`** (+12 lines)
-   - Added `from orchestrator.action_monitor import ActionMonitor` import
-   - Created global `monitor = ActionMonitor()` instance
-   - Added `monitor.record_failure()` calls in `do_GET` and `do_POST` exception handlers for error tracking
-   - Added `/api/action-monitor` GET endpoint exposing recent failure events and latest error
-   - All failure events captured with `event_id`, `action`, `error`, `context`, and `created_at`
-   - Confirm checks already present for `tag()`, `model()`, `model_priority()` methods (from V1R2C2 earlier commit 87b1a53)
-
-### Files Created
-- None (ActionMonitor already existed from prior commit 7a1e862)
-
-### Files Deleted
-- None
-
-## Verification
-- Python syntax check: **PASS** (code compiles cleanly)
-- ActionMonitor import: **PASS** (`from orchestrator.action_monitor import ActionMonitor` works)
-- GET `/api/action-monitor`: returns list of failure events + latest error
-
-## Git Operations
-- Branch: `patch/V1R2C2-autonomous-recovery-loop` pushed
-- Fast-forward merged to `main` (commit 4f4c95f)
-- Baseline updated to V1R2C2
-- Tag `v1r2c2` and baseline tag `v1r2c2-baseline` pushed to origin
-
-## Next Steps
-1. Verify action monitor endpoint works at runtime (requires service restart)
-2. Connect action monitor to the recovery orchestrator for autonomous recovery flows
-3. Check if `branch()`, `file()`, `commit()`, `patch()`, `rollback()` methods still need confirm guards

reports/fix-patches-permission-v1-execution-report.md

@@ -1,30 +0,0 @@
-# fix-patches-permission-v1 - Execution Report
-
-## Summary
-Fixed `patches/` directory tree permission to conform with `root:gitops` + setgid ownership model.
-
-## Before
-```
-patches/          drwxrwsr-x  root:gitops   (OK: setgid on root dir)
-  nl/             drwxr-xr-x  root:root     (WRONG: no setgid, wrong group)
-    nl-*.json     -rw-r--r--  root:root     (WRONG: wrong group, no group write)
-  patch_*.json    -rw-rw-r--  aiman:aiman   (WRONG: wrong owner/group)
-  self-*.json     -rw-r--r--  root:root     (WRONG: no group write)
-```
-
-## After
-```
-patches/          drwxrws---  root:gitops   ✓ setgid
-  nl/             drwxrws---  root:gitops   ✓ setgid inherited
-  nl/*.json       -rw-rw----  root:gitops   ✓ rw for group
-  *patch*.json    -rw-rw----  root:gitops   ✓ rw for group
-  self-*.json     -rw-rw----  root:gitops   ✓ rw for group
-```
-
-## Verification
-- aiman (gitops member): read OK ✓
-- aios (gitops member): read OK ✓
-- Non-group users: denied (o-rwx) ✓
-
-## Git Commit
-Not committed. This is a filesystem permission fix, no file content changes.

reports/gpt-actions-consequential-governance-report.md

@@ -0,0 +1,85 @@
+# GPT Actions Consequential Governance Report
+
+Status: READY_FOR_REVIEW
+
+Branch: patch/gpt-actions-consequential-governance
+
+Commit: see final OpenClaw response for immutable commit rev
+
+## Objective
+
+Reduce unnecessary ChatGPT Actions confirmation prompts for low-risk GitOps write operations while preserving confirmation protection for high-risk operations.
+
+## Changes
+
+### Low-risk Actions
+
+| operationId | x-openai-isConsequential | Path Scope |
+|---|---:|---|
+| commitReportFile | false | reports/** |
+| commitDocsFile | false | docs/** |
+| commitProposalFile | false | proposals/** |
+| commitPatchEvidence | false | reports/**, patches/** |
+
+### High-risk Actions
+
+| operationId | x-openai-isConsequential |
+|---|---:|
+| commitFile | true |
+| commitMainFile | true |
+| createRollbackRequest | true |
+| requestRollback | true |
+| requestOrCreateTag | true |
+| setModelPriority | true |
+| registerModel | true |
+
+## OpenAPI Operations Added
+
+- commitReportFile
+- commitDocsFile
+- commitProposalFile
+- commitPatchEvidence
+- commitMainFile
+- createRollbackRequest
+
+## OpenAPI Operations Updated
+
+- commitFile marked `x-openai-isConsequential: true`.
+- commitChanges marked `x-openai-isConsequential: true`.
+- createPatch marked `x-openai-isConsequential: true`.
+- createBranch marked `x-openai-isConsequential: true`.
+- requestOrCreateTag marked `x-openai-isConsequential: true`.
+- requestRollback marked `x-openai-isConsequential: true`.
+- registerModel marked `x-openai-isConsequential: true`.
+- setModelPriority marked `x-openai-isConsequential: true`.
+- planNaturalLanguageGitOpsAction marked `x-openai-isConsequential: true`.
+
+## Security Validation
+
+- No real tokens added.
+- No secret values added.
+- OpenAPI examples use placeholder values only.
+- Action auth remains injected by GPT Builder Actions configuration.
+- Low-risk policy rejects `main`, `runtime/secrets/**`, `.env`, `*.token`, `private/**`, `prod-secrets/**`, and secret-like content.
+
+## Tests
+
+- pytest: not run; remote Python environment does not have the `pytest` module installed.
+- direct test runner: passed, 14 test functions.
+- smoke: passed.
+
+## Smoke Result
+
+`python3 scripts/smoke_gpt_actions_consequential_governance.py` passed.
+
+## Rollback Plan
+
+Discard patch branch before merge, or revert the governance commit after merge.
+
+## Risk
+
+Medium. The change affects GPT Builder Action behavior and write API affordances while preserving high-risk confirmation gates.
+
+## Next Step
+
+Review OpenAPI schema in GPT Builder Actions and retest whether low-risk commit operations show Always allow or reduced confirmation prompts.

runtime/agent-os/agent_health_score.py

@@ -1,95 +0,0 @@
-"""Agent OS health score module for V1R1C5.
-
-Calculates health scores based on quality, acceptance rate, and historical reliability.
-Used for scheduler selection and consensus weighting.
-"""
-
-from typing import Dict, Any
-
-
-class AgentHealthScore:
-    """Health score calculator for agents.
-
-    Combines multiple factors into a single health score (0.0 - 1.0) used by:
-    - Scheduler for task assignment priority
-    - Consensus engine for weighted voting
-    - Escalation and recovery decisions
-    """
-
-    def __init__(self):
-        self.default_quality = 0.5
-        self.default_acceptance_rate = 0.8
-        self.default_reliability = 0.7
-
-    def calculate_health_score(
-        self,
-        quality_score: float = None,
-        acceptance_rate: float = None,
-        historical_reliability: float = None,
-    ) -> float:
-        """Calculate composite health score from individual metrics.
-
-        Formula:
-        health_score = (quality_score * 0.35) + (acceptance_rate * 0.35) + (historical_reliability * 0.30)
-
-        Args:
-            quality_score: Quality score from agent runtime metrics (0.0-1.0)
-            acceptance_rate: Historical acceptance rate from agent store (0.0-1.0)
-            historical_reliability: Reliability score from agent store (0.0-1.0)
-
-        Returns:
-            Composite health score between 0.0 and 1.0
-        """
-        quality = quality_score if quality_score is not None else self.default_quality
-        acceptance = acceptance_rate if acceptance_rate is not None else self.default_acceptance_rate
-        reliability = historical_reliability if historical_reliability is not None else self.default_reliability
-
-        score = (
-            quality * 0.35
-            + acceptance * 0.35
-            + reliability * 0.30
-        )
-
-        return min(max(score, 0.0), 1.0)
-
-    def get_health_status(self, score: float) -> str:
-        """Get health status string from score.
-
-        Args:
-            score: Health score (0.0-1.0)
-
-        Returns:
-            One of: "healthy", "degraded", "unhealthy"
-        """
-        if score >= 0.75:
-            return "healthy"
-        elif score >= 0.4:
-            return "degraded"
-        else:
-            return "unhealthy"
-
-    def select_agent(self, agents: list) -> str:
-        """Select best agent from a list based on health scores.
-
-        Args:
-            agents: List of dicts with agent_id and health_score keys
-
-        Returns:
-            Agent ID of the healthiest agent
-        """
-        if not agents:
-            return ""
-        return max(agents, key=lambda a: a.get("health_score", 0.0))["agent_id"]
-
-    def get_weight_multiplier(self, score: float) -> float:
-        """Get weight multiplier based on health score.
-
-        Higher health scores yield higher multipliers for consensus weighting.
-
-        Args:
-            score: Health score (0.0-1.0)
-
-        Returns:
-            Weight multiplier (0.0-1.0)
-        """
-        return score ** 1.5  # Amplify differences

runtime/agent-os/consensus_engine.py

@@ -19,49 +19,11 @@ class ConsensusEngine:
             "windows_codex": 2,
             "server_agent": 1,
         }
-        # New in V1R1C5: quality score, historical reliability, domain expertise
-        self.quality_score_factors = {
-            "code_quality": 0.4,
-            "test_coverage": 0.3,
-            "response_time": 0.3,
-        }
-        self.historical_reliability_factors = {
-            "recent_acceptance_rate": 0.5,
-            "longevity_score": 0.3,
-            "error_rate": 0.2,
-        }
-        self.domain_expertise_factors = {
-            "specialization_match": 0.5,
-            "experience_years": 0.3,
-            "certifications": 0.2,
-        }
 
-    def calculate_quality_score(self, agent_id: str, agent_type: str) -> float:
-        """Calculate quality score for an agent based on its performance metrics."""
-        # Placeholder implementation; in production, fetch metrics from telemetry
-        return 0.85  # Default quality score
-
-    def calculate_historical_reliability(self, agent_id: str, agent_type: str) -> float:
-        """Calculate historical reliability score for an agent."""
-        # Placeholder implementation; in production, fetch from store
-        return 0.90  # Default reliability score
-
-    def calculate_domain_expertise(self, agent_id: str, agent_type: str) -> float:
-        """Calculate domain expertise score for an agent."""
-        # Placeholder implementation; in production, fetch from agent registry
-        return 0.75  # Default expertise score
-
-    def calculate(self, votes: List[dict], use_dynamic_weights: bool = False) -> dict:
+    def calculate(self, votes: List[dict]) -> dict:
         result = {"approve": 0, "reject": 0}
         for vote in votes:
-            base_weight = self.base_weights.get(vote.get("agent_type"), 1)
-            if use_dynamic_weights:
-                quality = self.calculate_quality_score(vote.get("agent_id", ""), vote.get("agent_type", ""))
-                reliability = self.calculate_historical_reliability(vote.get("agent_id", ""), vote.get("agent_type", ""))
-                expertise = self.calculate_domain_expertise(vote.get("agent_id", ""), vote.get("agent_type", ""))
-                weight = base_weight * quality * reliability * expertise
-            else:
-                weight = base_weight
+            weight = vote.get("weight", self.base_weights.get(vote.get("agent_type"), 1))
             result[vote.get("decision", "reject")] += weight
         return result
 
@@ -70,7 +32,7 @@ class ConsensusEngine:
 
         Returns one of: "approve", "reject", "review", "conditional_approval".
         """
-        result = self.calculate(votes, use_dynamic_weights=True)
+        result = self.calculate(votes)
         if result["approve"] > result["reject"]:
             # Check if any participant voted with conditions
             conditional_votes = [

runtime/agent-os/message_bus.py

@@ -1,16 +1,7 @@
 """Agent OS message bus runtime."""
 
-from dataclasses import dataclass, field
-from typing import List, Optional
-from enum import Enum
-
-
-class DeliveryStatus(Enum):
-    PENDING = "pending"
-    DELIVERED = "delivered"
-    FAILED = "failed"
-    RETRYING = "retrying"
-    EXPIRED = "expired"
+from dataclasses import dataclass
+from typing import List
 
 
 @dataclass
@@ -19,11 +10,6 @@ class AgentMessage:
     receiver: str
     event: str
     payload: dict
-    # V1R1C5: New fields for message tracking and delivery
-    task_id: str = ""
-    correlation_id: str = ""
-    retry_state: int = 0
-    delivery_status: DeliveryStatus = DeliveryStatus.PENDING
 
 
 class MessageBus:
@@ -35,14 +21,7 @@ class MessageBus:
 
     def broadcast(self, sender: str, event: str, payload: dict, receivers: List[str]):
         for receiver in receivers:
-            self.send(AgentMessage(
-                sender=sender,
-                receiver=receiver,
-                event=event,
-                payload=payload,
-                task_id=payload.get("task_id", "") if isinstance(payload, dict) else "",
-                correlation_id=payload.get("correlation_id", "") if isinstance(payload, dict) else "",
-            ))
+            self.send(AgentMessage(sender, receiver, event, payload))
 
     def consume(self):
         messages = list(self.queue)

runtime/agent-os/orchestrator/__init__.py

@@ -1 +0,0 @@
-# init for orchestrator package

runtime/agent-os/orchestrator/action_monitor.py

@@ -1,37 +0,0 @@
-"""V1R2C2 autonomous recovery action monitor."""
-
-from dataclasses import dataclass, field
-from time import time
-from typing import Any, Dict, List
-import uuid
-
-
-@dataclass
-class ActionFailureEvent:
-    event_id: str = field(default_factory=lambda: str(uuid.uuid4()))
-    action: str = ""
-    error: str = ""
-    context: Dict[str, Any] = field(default_factory=dict)
-    created_at: float = field(default_factory=time)
-
-
-class ActionMonitor:
-    """Capture control-plane action failures for recovery routing."""
-
-    def __init__(self):
-        self.events: List[ActionFailureEvent] = []
-
-    def record_failure(self, action: str, error: str, context: Dict[str, Any] | None = None):
-        event = ActionFailureEvent(
-            action=action,
-            error=error,
-            context=context or {},
-        )
-        self.events.append(event)
-        return event
-
-    def latest(self):
-        return self.events[-1] if self.events else None
-
-    def list_events(self):
-        return self.events

runtime/agent-os/orchestrator/error_classifier.py

@@ -1,89 +0,0 @@
-"""V1R2C2 Error Classifier Module.
-
-Classifies action failures by type and recovery priority.
-"""
-
-from typing import Any, Dict, Optional
-
-# Error type patterns
-ERROR_PATTERNS = {
-    'permission_error': [
-        'permission denied', 'unauthorized', 'forbidden', 'not allowed',
-        'access denied', 'credentials', 'authentication failed',
-        'token invalid', 'read-only', 'owner_approval_required',
-        'direct_main_push', 'protected_branch',
-    ],
-    'git_error': [
-        'git failed', 'git error', 'paths', 'did not match', 'not a git repository',
-        'merge conflict', 'push rejected', 'fetch failed',
-        'remote', 'repository', 'fatal:', 'refs/heads',
-    ],
-    'runtime_error': [
-        'connection refused', 'timeout', 'service unavailable', 'unreachable',
-        'server error', '500', '503', 'process crash', 'memory',
-        'clientresponseerror', 'responseerror',
-        'rate limit',
-    ],
-    'validation_error': [
-        'invalid', 'required', 'missing', 'bad request', '400',
-        'malformed', 'unexpected',
-    ],
-    'system_error': [
-        'disk full', 'out of memory', 'file system', 'kernel',
-        'oom', 'oom-kill', 'segfault', 'signal',
-    ],
-    'secret_violation': [
-        'secret_rejected',
-    ],
-}
-
-# Recovery priority mapping
-RECOVERY_PRIORITY = {
-    'permission_error': 'openclaw_auto_repair',
-    'git_error': 'openclaw_auto_repair',
-    'runtime_error': 'hermes_escalation',
-    'validation_error': 'openclaw_auto_repair',
-    'system_error': 'windows_codex_escalation',
-    'secret_violation': 'windows_codex_escalation',
-    'unknown': 'openclaw_auto_repair',
-}
-
-
-class ErrorClassifier:
-    """Classify action failures by analyzing error strings."""
-
-    @staticmethod
-    def classify(error: str) -> Dict[str, Any]:
-        """Classify an error message into error type and recovery priority.
-
-        Returns:
-            dict with 'error_type', 'recovery_priority', 'matched_patterns'
-        """
-        error_lower = error.lower()
-        matched = []
-
-        for etype, patterns in ERROR_PATTERNS.items():
-            for pattern in patterns:
-                if pattern in error_lower:
-                    matched.append(etype)
-                    break
-
-        # Determine primary error type
-        if not matched:
-            error_type = 'unknown'
-        else:
-            # Priority order: permission > git > system > runtime > validation
-            for priority_type in ['permission_error', 'git_error', 'system_error', 'secret_violation', 'runtime_error', 'validation_error']:
-                if priority_type in matched:
-                    error_type = priority_type
-                    break
-            else:
-                error_type = matched[0]
-
-        recovery_priority = RECOVERY_PRIORITY.get(error_type, 'openclaw_auto_repair')
-
-        return {
-            'error_type': error_type,
-            'recovery_priority': recovery_priority,
-            'matched_patterns': matched,
-        }

runtime/agent-os/orchestrator/failure_router.py

@@ -1,58 +0,0 @@
-"""V1R2C2 Failure Router Module.
-
-Routes failures to appropriate recovery agent based on error type and recovery priority.
-"""
-
-from typing import Any, Dict, Optional
-
-from orchestrator.error_classifier import ErrorClassifier
-
-# Agent routing table
-AGENT_ROUTING = {
-    'openclaw_auto_repair': {
-        'primary': 'openclaw',
-        'fallback': 'hermes',  # if openclaw fails
-        'escape': 'windows_codex_app',
-        'description': 'OpenClaw auto-repair route',
-    },
-    'hermes_escalation': {
-        'primary': 'hermes',
-        'fallback': 'openclaw',
-        'escape': 'windows_codex_app',
-        'description': 'Hermes escalation route',
-    },
-    'windows_codex_escalation': {
-        'primary': 'windows_codex_app',
-        'fallback': 'openclaw',
-        'escape': 'openclaw',
-        'description': 'Windows Codex App escalation route',
-    },
-}
-
-
-class FailureRouter:
-    """Route action failures to the appropriate recovery agent."""
-
-    def __init__(self, classifier: Optional[ErrorClassifier] = None):
-        self.classifier = classifier or ErrorClassifier()
-
-    def route(self, error: str, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """Route a failure event to the appropriate recovery agent.
-
-        Returns:
-            dict with 'primary_agent', 'fallback_agent', 'escape_agent', 'selected_error_type'
-        """
-        classification = self.classifier.classify(error)
-        error_type = classification['error_type']
-        recovery_priority = classification['recovery_priority']
-
-        route = AGENT_ROUTING.get(recovery_priority, AGENT_ROUTING['openclaw_auto_repair'])
-
-        return {
-            'error_type': error_type,
-            'recovery_priority': recovery_priority,
-            'primary_agent': route['primary'],
-            'fallback_agent': route['fallback'],
-            'escape_agent': route['escape'],
-            'selected_error_type': error_type,
-        }

runtime/agent-os/orchestrator/integration_test_v1r2c2.py

@@ -1,196 +0,0 @@
-#!/usr/bin/env python3
-"""V1R2C2 integration test: verify the recovery pipeline end-to-end.
-
-Tests: Action Monitor → Error Classifier → Failure Router → Recovery Controller
-"""
-
-import sys
-import json
-import tempfile
-import os
-import time
-import subprocess
-from pathlib import Path
-
-# Path to the gitops workspace
-WORKSPACE = Path('/data/aios-gitops/workspace')
-sys.path.insert(0, str(WORKSPACE / 'runtime' / 'agent-os'))
-
-from orchestrator.action_monitor import ActionMonitor
-from orchestrator.error_classifier import ErrorClassifier
-from orchestrator.failure_router import FailureRouter
-from orchestrator.recovery_controller import RecoveryController
-
-
-def debug_imports():
-    """Verify all modules load correctly."""
-    print("=== Module Import Verification ===")
-    print(f"ActionMonitor: {ActionMonitor}")
-    print(f"ErrorClassifier: {ErrorClassifier}")
-    print(f"FailureRouter: {FailureRouter}")
-    print(f"RecoveryController: {RecoveryController}")
-    print()
-
-
-def test_action_monitor():
-    """Test the ActionMonitor records failure events correctly."""
-    print("=== ActionMonitor Test ===")
-    monitor = ActionMonitor()
-    assert monitor.latest() is None, "Monitor should start empty"
-    assert monitor.list_events() == [], "Monitor events list should start empty"
-
-    e = monitor.record_failure('branch:create', 'Permission denied', {'branch': 'test'})
-    assert e is not None
-    assert e.action == 'branch:create'
-    assert e.error == 'Permission denied'
-    assert e.context == {'branch': 'test'}
-    assert e.event_id is not None
-    assert e.created_at > 0
-
-    e2 = monitor.record_failure('file:write', 'File not found', {'path': '/tmp/x'})
-    assert len(monitor.list_events()) == 2
-    assert monitor.latest() == e2
-    print("PASS: ActionMonitor records and retrieves events correctly")
-    return monitor
-
-
-def test_error_classifier():
-    """Test the ErrorClassifier categorizes errors correctly."""
-    print("=== ErrorClassifier Test ===")
-    clf = ErrorClassifier()
-
-    tests = [
-        # (error_string, expected_error_type, expected_recovery_priority)
-        ('Permission denied', 'permission_error', 'openclaw_auto_repair'),
-        ('git failed: merge conflict', 'git_error', 'openclaw_auto_repair'),
-        ('git push rejected: permission', 'git_error', 'openclaw_auto_repair'),
-        ('Connection refused', 'runtime_error', 'hermes_escalation'),
-        ('timeout', 'runtime_error', 'hermes_escalation'),
-        ('ClientResponseError', 'runtime_error', 'hermes_escalation'),
-        ('secret_rejected: use secret_ref', 'secret_violation', 'windows_codex_escalation'),
-        ('unauthorized', 'permission_error', 'openclaw_auto_repair'),
-        ('forbidden', 'permission_error', 'openclaw_auto_repair'),
-        ('API rate limit exceeded', 'runtime_error', 'hermes_escalation'),
-        ('Internal Server Error', 'runtime_error', 'hermes_escalation'),
-        ('repository is locked', 'git_error', 'openclaw_auto_repair'),
-        ('unknown weird error', 'unknown', 'openclaw_auto_repair'),
-        ('No such file or directory', 'unknown', 'openclaw_auto_repair'),
-        ('File exists', 'unknown', 'openclaw_auto_repair'),
-        ('authentication failed', 'permission_error', 'openclaw_auto_repair'),
-    ]
-
-    for error_str, expected_type, expected_priority in tests:
-        result = clf.classify(error_str)
-        assert result['error_type'] == expected_type, f"Expected {expected_type}, got {result['error_type']} for '{error_str}'"
-        assert result['recovery_priority'] == expected_priority, f"Expected {expected_priority}, got {result['recovery_priority']} for '{error_str}'"
-
-    print("PASS: ErrorClassifier correctly classifies all error types")
-    return clf
-
-
-def test_failure_router():
-    """Test the FailureRouter routes failures to the correct agent."""
-    print("=== FailureRouter Test ===")
-    router = FailureRouter()
-
-    tests = [
-        # (error, expected_primary, expected_fallback, expected_escape)
-        ('Permission denied', 'openclaw', 'hermes', 'windows_codex_app'),
-        ('ClientResponseError', 'hermes', 'openclaw', 'windows_codex_app'),
-        ('secret_rejected: use secret_ref', 'windows_codex_app', 'openclaw', 'openclaw'),
-    ]
-
-    for error, primary, fallback, escape in tests:
-        result = router.route(error)
-        assert result['primary_agent'] == primary, f"Expected primary={primary}, got {result['primary_agent']}"
-        assert result['fallback_agent'] == fallback, f"Expected fallback={fallback}, got {result['fallback_agent']}"
-        assert result['escape_agent'] == escape, f"Expected escape={escape}, got {result['escape_agent']}"
-
-    print("PASS: FailureRouter routes errors to correct agents")
-    return router
-
-
-def test_recovery_controller():
-    """Test the full recovery pipeline end-to-end."""
-    print("=== RecoveryController Test ===")
-    controller = RecoveryController()
-
-    tests = [
-        # (action, error, expected_error_type)
-        ('branch:create', 'Permission denied', 'permission_error'),
-        ('file:write', 'ClientResponseError', 'runtime_error'),
-        ('model:write', 'secret_rejected: use secret_ref', 'secret_violation'),
-    ]
-
-    for action, error, expected_type in tests:
-        result = controller.process_failure(action, error, {'source': 'chatgpt-api'})
-        assert result['error_type'] == expected_type, f"Expected {expected_type}, got {result['error_type']}"
-        assert result['action'] == action
-        assert result['plan'] is not None
-        assert result['execution'] is not None
-        assert result['validation'] is not None
-        assert 'timestamp' in result
-        print(f"  {action}: {error} → {expected_type} ✓")
-
-    assert len(controller.recovery_history) == 3
-    assert controller.latest_recovery() == controller.recovery_history[-1]
-
-    print("PASS: RecoveryController processes full pipeline correctly")
-    return controller
-
-
-def test_api_500_scenario():
-    """Simulate the real-world scenario of API 500 errors."""
-    print("=== API 500 Scenario Test ===")
-    monitor = ActionMonitor()
-    controller = RecoveryController()
-
-    # Simulate the /api/file 500 errors seen in production
-    failures = [
-        ('file:write', 'Internal Server Error', {'path': 'test.md', 'method': 'POST'}),
-        ('branch:create', 'ClientResponseError', {'branch': 'test', 'method': 'POST'}),
-        ('file:write', 'timeout', {'path': 'test2.md', 'method': 'POST'}),
-    ]
-
-    for action, error, context in failures:
-        event = monitor.record_failure(action, error, context)
-        result = controller.process_failure(action, error, context)
-
-        assert result['error_type'] is not None
-        assert result['route_info'] is not None
-
-    # Verify the most critical errors (network errors) route to hermes
-    network_results = [
-        r for r in controller.recovery_history
-        if r['error_type'] == 'network_error'
-    ]
-    for r in network_results:
-        assert r['route_info']['primary_agent'] == 'hermes'
-
-    print(f"PASS: API 500 scenario processed {len(failures)} failures correctly")
-    print(f"  Network errors routed to hermes: {len(network_results)}")
-
-
-def main():
-    """Run all tests."""
-    print("=" * 60)
-    print("V1R2C2 Integration Tests - Autonomous Recovery Pipeline")
-    print("=" * 60)
-    print()
-
-    debug_imports()
-    test_action_monitor()
-    test_error_classifier()
-    test_failure_router()
-    test_recovery_controller()
-    test_api_500_scenario()
-
-    print()
-    print("=" * 60)
-    print("ALL TESTS PASSED")
-    print("=" * 60)
-    return 0
-
-
-if __name__ == '__main__':
-    sys.exit(main())

runtime/agent-os/orchestrator/recovery_controller.py

@@ -1,105 +0,0 @@
-"""V1R2C2 Recovery Controller Module.
-
-Orchestrates the full recovery pipeline:
-  Action Monitor → Error Classifier → Failure Router → Recovery Controller → Repair → Validate → GitOps Record
-
-This module demonstrates the complete recovery chain.
-"""
-
-from typing import Any, Dict, Optional
-from datetime import datetime, timezone
-
-from orchestrator.error_classifier import ErrorClassifier
-from orchestrator.failure_router import FailureRouter
-
-
-class RecoveryController:
-    """Capture and process action failures through the recovery pipeline."""
-
-    def __init__(self):
-        self.classifier = ErrorClassifier()
-        self.router = FailureRouter(self.classifier)
-        self.recovery_history: list[Dict[str, Any]] = []
-
-    def process_failure(self, action: str, error: str, context: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        """Process a single failure through the complete recovery pipeline.
-
-        Pipeline: Action Monitor → Error Classifier → Failure Router → Recovery Plan → Execute → Validate → Record
-
-        Returns:
-            dict with full recovery chain output
-        """
-        context = context or {}
-        now = datetime.now(timezone.utc).isoformat()
-
-        # Step 1: Classify
-        classification = self.classifier.classify(error)
-        error_type = classification['error_type']
-
-        # Step 2: Route
-        route_info = self.router.route(error, context)
-
-        # Step 3: Generate recovery plan
-        plan = self._generate_plan(action, error_type, route_info, context)
-
-        # Step 4: Execute (simulated - actual execution requires agent infrastructure)
-        execution = self._execute_recovery(action, error_type, plan)
-
-        # Step 5: Validate
-        validation = self._validate_recovery(execution)
-
-        # Step 6: Record
-        record = {
-            'timestamp': now,
-            'action': action,
-            'error': error,
-            'error_type': error_type,
-            'classification': classification,
-            'route_info': route_info,
-            'plan': plan,
-            'execution': execution,
-            'validation': validation,
-        }
-
-        self.recovery_history.append(record)
-        return record
-
-    def _generate_plan(self, action: str, error_type: str, route_info: Dict[str, Any], context: Dict[str, Any]) -> Dict[str, Any]:
-        """Generate a recovery plan based on classification and routing."""
-        primary = route_info.get('primary_agent', 'openclaw')
-        return {
-            'action': action,
-            'error_type': error_type,
-            'primary_agent': primary,
-            'fallback_agent': route_info.get('fallback_agent', 'hermes'),
-            'escape_agent': route_info.get('escape_agent', 'windows_codex_app'),
-            'steps': [
-                f'classify: {error_type}',
-                f'assign: {primary}',
-                f'fallback: {route_info.get("fallback_agent", "hermes")}',
-                f'escape: {route_info.get("escape_agent", "windows_codex_app")}',
-            ],
-        }
-
-    def _execute_recovery(self, action: str, error_type: str, plan: Dict[str, Any]) -> Dict[str, Any]:
-        """Execute the recovery plan (simulation)."""
-        # In production, this would invoke the selected agent with the plan
-        return {
-            'status': 'recovery_initiated',
-            'agent': plan.get('primary_agent'),
-            'action': action,
-            'error_type': error_type,
-        }
-
-    def _validate_recovery(self, execution: Dict[str, Any]) -> Dict[str, Any]:
-        """Validate the recovery action was taken."""
-        # In production, this would check if the agent applied the fix
-        return {
-            'validated': execution.get('status') == 'recovery_initiated',
-            'execution_status': execution.get('status'),
-            'validation_time': datetime.now(timezone.utc).isoformat(),
-        }
-
-    def latest_recovery(self) -> Optional[Dict[str, Any]]:
-        """Get the latest recovery record."""
-        return self.recovery_history[-1] if self.recovery_history else None

scripts/gitops_actions_policy.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""Policy helpers for GPT Actions GitOps write operations.
+
+The helpers intentionally avoid runtime credentials. They are used by tests and
+smoke checks to keep the OpenAPI consequential-action split aligned with server
+side write policy requirements.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import PurePosixPath
+import re
+
+
+LOW_RISK_PATH_SCOPES: dict[str, tuple[str, ...]] = {
+    "commitReportFile": ("reports/",),
+    "commitDocsFile": ("docs/",),
+    "commitProposalFile": ("proposals/",),
+    "commitPatchEvidence": ("reports/", "patches/"),
+}
+
+HIGH_RISK_OPERATIONS: set[str] = {
+    "commitFile",
+    "commitMainFile",
+    "createRollbackRequest",
+    "requestRollback",
+    "requestOrCreateTag",
+    "commitRuntimeFile",
+    "commitConfigFile",
+    "mergeMain",
+    "adjustProductionModelPriority",
+    "setModelPriority",
+    "registerModel",
+}
+
+SECRET_PATH_PATTERNS: tuple[str, ...] = (
+    "runtime/secrets/",
+    ".env",
+    "private/",
+    "prod-secrets/",
+)
+
+SECRET_CONTENT_PATTERNS: tuple[re.Pattern[str], ...] = (
+    re.compile(r"sk-[A-Za-z0-9_-]{8,}"),
+    re.compile(r"Bearer\s+\S+", re.IGNORECASE),
+    re.compile(r"BEGIN\s+PRIVATE\s+KEY", re.IGNORECASE),
+    re.compile(r"password\s*=\s*\S+", re.IGNORECASE),
+    re.compile(r"api_key\s*=\s*\S+", re.IGNORECASE),
+    re.compile(r"access_token\s*=\s*\S+", re.IGNORECASE),
+    re.compile(r"refresh_token\s*=\s*\S+", re.IGNORECASE),
+)
+
+
+@dataclass(frozen=True)
+class PolicyResult:
+    allowed: bool
+    reason: str
+
+
+def normalize_path(path: str) -> str:
+    raw = (path or "").replace("\\", "/").strip()
+    if not raw:
+        raise ValueError("path_required")
+    posix = PurePosixPath(raw)
+    if posix.is_absolute():
+        raise ValueError("absolute_path_forbidden")
+    if any(part in {"..", ".git"} for part in posix.parts):
+        raise ValueError("unsafe_path_forbidden")
+    return str(posix)
+
+
+def is_main_branch(branch: str | None) -> bool:
+    value = (branch or "").strip()
+    return value in {"main", "master"} or value.startswith("main/") or value.startswith("master/")
+
+
+def is_secret_path(path: str) -> bool:
+    normalized = normalize_path(path)
+    name = PurePosixPath(normalized).name
+    if name.endswith(".token"):
+        return True
+    return any(normalized == pattern.rstrip("/") or normalized.startswith(pattern) for pattern in SECRET_PATH_PATTERNS)
+
+
+def contains_secret_like_content(content: str) -> bool:
+    text = content or ""
+    return any(pattern.search(text) for pattern in SECRET_CONTENT_PATTERNS)
+
+
+def path_in_scope(operation_id: str, path: str) -> bool:
+    normalized = normalize_path(path)
+    scopes = LOW_RISK_PATH_SCOPES.get(operation_id, ())
+    return any(normalized.startswith(scope) for scope in scopes)
+
+
+def validate_low_risk_commit(operation_id: str, branch: str, path: str, content: str = "") -> PolicyResult:
+    if operation_id not in LOW_RISK_PATH_SCOPES:
+        return PolicyResult(False, "unknown_low_risk_operation")
+    if is_main_branch(branch):
+        return PolicyResult(False, "low_risk_action_rejects_main")
+    try:
+        normalized = normalize_path(path)
+    except ValueError as exc:
+        return PolicyResult(False, str(exc))
+    if is_secret_path(normalized):
+        return PolicyResult(False, "secret_path_rejected")
+    if not path_in_scope(operation_id, normalized):
+        return PolicyResult(False, "path_out_of_scope")
+    if contains_secret_like_content(content):
+        return PolicyResult(False, "secret_like_content_detected")
+    return PolicyResult(True, "allowed")
+
+
+def validate_write_policy(operation_id: str, branch: str, path: str, content: str = "") -> PolicyResult:
+    try:
+        normalized = normalize_path(path)
+    except ValueError as exc:
+        return PolicyResult(False, str(exc))
+    if is_secret_path(normalized):
+        return PolicyResult(False, "secret_path_rejected")
+    if contains_secret_like_content(content):
+        return PolicyResult(False, "secret_like_content_detected")
+    if operation_id in LOW_RISK_PATH_SCOPES:
+        return validate_low_risk_commit(operation_id, branch, normalized, content)
+    if operation_id in HIGH_RISK_OPERATIONS:
+        return PolicyResult(True, "high_risk_requires_confirmation")
+    return PolicyResult(False, "unknown_operation")
+
+
+if __name__ == "__main__":
+    print("GPT Actions GitOps policy helper loaded")

scripts/smoke_gpt_actions_consequential_governance.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+from pathlib import Path
+import re
+import sys
+
+import yaml
+
+
+ROOT = Path(__file__).resolve().parents[1]
+SCHEMA = ROOT / "docs" / "gitops" / "openapi-chatgpt-actions.yaml"
+
+LOW_RISK_FALSE = {
+    "commitReportFile",
+    "commitDocsFile",
+    "commitProposalFile",
+    "commitPatchEvidence",
+}
+
+HIGH_RISK_TRUE = {
+    "commitFile",
+    "commitMainFile",
+    "createRollbackRequest",
+    "requestRollback",
+    "requestOrCreateTag",
+    "setModelPriority",
+    "registerModel",
+}
+
+SECRET_LIKE = re.compile(
+    r"sk-[A-Za-z0-9_-]{8,}|Bearer\s+\S+|BEGIN\s+PRIVATE\s+KEY|password\s*=|api_key\s*=|access_token\s*=|refresh_token\s*=",
+    re.IGNORECASE,
+)
+
+
+def load_schema() -> dict:
+    if not SCHEMA.exists():
+        raise AssertionError(f"schema missing: {SCHEMA}")
+    return yaml.safe_load(SCHEMA.read_text(encoding="utf-8"))
+
+
+def operations(schema: dict) -> dict[str, dict]:
+    found: dict[str, dict] = {}
+    for path_item in schema.get("paths", {}).values():
+        if not isinstance(path_item, dict):
+            continue
+        for method, operation in path_item.items():
+            if method.lower() not in {"get", "post", "put", "patch", "delete"}:
+                continue
+            if isinstance(operation, dict) and operation.get("operationId"):
+                found[operation["operationId"]] = operation
+    return found
+
+
+def collect_examples(value):
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if key in {"example", "examples"}:
+                yield item
+            yield from collect_examples(item)
+    elif isinstance(value, list):
+        for item in value:
+            yield from collect_examples(item)
+
+
+def main() -> int:
+    schema = load_schema()
+    ops = operations(schema)
+    failures: list[str] = []
+
+    for op_id in sorted(LOW_RISK_FALSE):
+        operation = ops.get(op_id)
+        if not operation:
+            failures.append(f"missing low-risk operation: {op_id}")
+        elif operation.get("x-openai-isConsequential") is not False:
+            failures.append(f"{op_id} must set x-openai-isConsequential=false")
+
+    for op_id in sorted(HIGH_RISK_TRUE):
+        operation = ops.get(op_id)
+        if not operation:
+            failures.append(f"missing high-risk operation: {op_id}")
+        elif operation.get("x-openai-isConsequential") is not True:
+            failures.append(f"{op_id} must set x-openai-isConsequential=true")
+
+    security_text = json.dumps(schema.get("components", {}).get("securitySchemes", {}), ensure_ascii=False)
+    if SECRET_LIKE.search(security_text):
+        failures.append("securitySchemes contain secret-like content")
+
+    for example in collect_examples(schema):
+        if SECRET_LIKE.search(json.dumps(example, ensure_ascii=False)):
+            failures.append("schema examples contain secret-like content")
+            break
+
+    print("GPT Actions consequential governance smoke")
+    print("schema:", SCHEMA)
+    print("low-risk:", ", ".join(sorted(LOW_RISK_FALSE)))
+    print("high-risk:", ", ".join(sorted(HIGH_RISK_TRUE)))
+    if failures:
+        print("status: failed")
+        for failure in failures:
+            print("-", failure)
+        return 1
+    print("status: passed")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

services/aios-autonomous-daemon/daemon.py

@@ -1,444 +0,0 @@
-#!/usr/bin/env python3
-"""AIOS Autonomous GitOps Daemon.
-
-Low-impact sidecar daemon for:
-- reading GitOps events from a file-backed event bus;
-- running safe validation/self-healing commands;
-- sending owner notifications through a runtime-injected WeChat/WeCom webhook;
-- creating audit records and request artifacts instead of bypassing production gates.
-
-No credentials are stored in this file. Runtime secrets must be injected by the host
-through environment variables or secret-mounted files.
-"""
-
-from __future__ import annotations
-
-import argparse
-import datetime as _dt
-import hashlib
-import hmac
-import json
-import os
-import pathlib
-import shutil
-import subprocess
-import sys
-import time
-import urllib.error
-import urllib.request
-from typing import Any, Dict, Iterable, List, Optional, Tuple
-
-ROOT = pathlib.Path(os.environ.get("AIOS_REPO_ROOT", ".")).resolve()
-CONFIG_PATH = ROOT / "config" / "codex" / "self-optimizing-orchestrator.json"
-PROD_POLICY_PATH = ROOT / "config" / "codex" / "autonomous-production-policy.json"
-MERGE_POLICY_PATH = ROOT / "config" / "codex" / "autonomous-merge-policy.json"
-EVENT_DIR = pathlib.Path(os.environ.get("AIOS_EVENT_DIR", str(ROOT / "runtime" / "gitops" / "events")))
-AUDIT_DIR = pathlib.Path(os.environ.get("AIOS_AUDIT_DIR", str(ROOT / "runtime" / "gitops" / "audit")))
-REQUEST_DIR = pathlib.Path(os.environ.get("AIOS_REQUEST_DIR", str(ROOT / "runtime" / "gitops" / "requests")))
-REPORT_DIR = pathlib.Path(os.environ.get("AIOS_REPORT_DIR", str(ROOT / "reports" / "codex")))
-PREAPPROVAL_DIR = pathlib.Path(os.environ.get("AIOS_PREAPPROVAL_DIR", str(ROOT / "approvals" / "preapproved")))
-
-SAFE_AUTONOMOUS_EVENTS = {
-    "git_push",
-    "patch_created",
-    "validation_failed",
-    "validation_passed",
-    "merge_candidate_created",
-    "runtime_health_degraded",
-}
-
-OWNER_NOTIFY_EVENTS = {
-    "main_version_changed",
-    "baseline_changed",
-    "merge_candidate_created",
-    "validation_failed",
-    "rollback_request_created",
-    "approval_required",
-    "daily_digest",
-}
-
-PRODUCTION_ACTIONS = {
-    "merge_to_main",
-    "create_release_tag",
-    "activate_new_baseline",
-    "production_runtime_change",
-    "production_rollback_execution",
-}
-
-ALWAYS_BLOCKED = {
-    "force_push",
-    "purge_baseline",
-    "delete_version_history",
-    "delete_audit_records",
-    "commit_real_secret",
-    "disable_auth_or_gitea_protection",
-}
-
-
-def utc_now() -> str:
-    return _dt.datetime.now(_dt.timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
-
-
-def load_json(path: pathlib.Path, default: Any) -> Any:
-    try:
-        return json.loads(path.read_text(encoding="utf-8"))
-    except FileNotFoundError:
-        return default
-    except json.JSONDecodeError as exc:
-        raise RuntimeError(f"Invalid JSON: {path}: {exc}") from exc
-
-
-def write_json(path: pathlib.Path, data: Any) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    tmp = path.with_suffix(path.suffix + ".tmp")
-    tmp.write_text(json.dumps(data, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-    tmp.replace(path)
-
-
-def event_id(event: Dict[str, Any]) -> str:
-    raw = json.dumps(event, ensure_ascii=False, sort_keys=True).encode("utf-8")
-    return hashlib.sha256(raw).hexdigest()[:16]
-
-
-def audit(action: str, status: str, detail: Dict[str, Any]) -> Dict[str, Any]:
-    record = {
-        "ts": utc_now(),
-        "action": action,
-        "status": status,
-        "detail": redact(detail),
-    }
-    write_json(AUDIT_DIR / f"{record['ts'].replace(':', '-')}-{action}.json", record)
-    print(json.dumps(record, ensure_ascii=False), flush=True)
-    return record
-
-
-def redact(value: Any) -> Any:
-    if isinstance(value, list):
-        return [redact(v) for v in value]
-    if isinstance(value, dict):
-        out: Dict[str, Any] = {}
-        for key, val in value.items():
-            lowered = key.lower()
-            sensitive = any(word in lowered for word in ["api_key", "apikey", "password", "secret", "private_key", "credential", "webhook"])
-            if sensitive and not (isinstance(val, str) and val.startswith("secret_ref://")):
-                out[key] = "[REDACTED]"
-            else:
-                out[key] = redact(val)
-        return out
-    return value
-
-
-def run_cmd(cmd: List[str], timeout: int = 300) -> Tuple[int, str, str]:
-    result = subprocess.run(
-        cmd,
-        cwd=str(ROOT),
-        text=True,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        timeout=timeout,
-        check=False,
-    )
-    return result.returncode, result.stdout, result.stderr
-
-
-def read_event_files(limit: int = 100) -> List[pathlib.Path]:
-    EVENT_DIR.mkdir(parents=True, exist_ok=True)
-    return sorted(EVENT_DIR.glob("*.json"), key=lambda p: p.stat().st_mtime)[:limit]
-
-
-def archive_event(path: pathlib.Path, status: str) -> None:
-    target = EVENT_DIR / status / path.name
-    target.parent.mkdir(parents=True, exist_ok=True)
-    shutil.move(str(path), str(target))
-
-
-def get_webhook_url() -> Optional[str]:
-    # Runtime-only injection. Do not commit real values.
-    return os.environ.get("AIOS_OWNER_WECHAT_WEBHOOK_URL") or os.environ.get("AIOS_OWNER_WECOM_WEBHOOK_URL")
-
-
-def sign_payload(payload: Dict[str, Any]) -> Optional[str]:
-    secret = os.environ.get("AIOS_OWNER_ACTION_SIGNING_SECRET")
-    if not secret:
-        return None
-    raw = json.dumps(payload, ensure_ascii=False, sort_keys=True).encode("utf-8")
-    return hmac.new(secret.encode("utf-8"), raw, hashlib.sha256).hexdigest()
-
-
-def send_owner_wechat(event: Dict[str, Any], summary: Dict[str, Any]) -> Dict[str, Any]:
-    url = get_webhook_url()
-    if not url:
-        return {"status": "skipped", "reason": "wechat_webhook_not_configured"}
-
-    content = format_owner_message(event, summary)
-    body = {
-        "msgtype": "markdown",
-        "markdown": {"content": content},
-    }
-    signature = sign_payload(body)
-    if signature:
-        body["aios_signature"] = signature
-
-    req = urllib.request.Request(
-        url,
-        data=json.dumps(body, ensure_ascii=False).encode("utf-8"),
-        headers={"Content-Type": "application/json"},
-        method="POST",
-    )
-    try:
-        with urllib.request.urlopen(req, timeout=10) as resp:
-            data = resp.read().decode("utf-8", errors="replace")
-            return {"status": "sent", "http_status": resp.status, "response": data[:500]}
-    except urllib.error.URLError as exc:
-        return {"status": "failed", "error": str(exc)}
-
-
-def format_owner_message(event: Dict[str, Any], summary: Dict[str, Any]) -> str:
-    title = event.get("type", "gitops_event")
-    branch = summary.get("branch") or event.get("branch") or "-"
-    from_version = summary.get("from_version") or event.get("from_version") or "-"
-    to_version = summary.get("to_version") or event.get("to_version") or "-"
-    changed = summary.get("changed_features") or event.get("changed_features") or []
-    if isinstance(changed, list):
-        changed_text = ", ".join(str(x) for x in changed[:8]) or "-"
-    else:
-        changed_text = str(changed)
-    return "\n".join([
-        f"### AIOS GitOps 通报：{title}",
-        f"- Branch: `{branch}`",
-        f"- Version: `{from_version}` → `{to_version}`",
-        f"- Code Δ: +{summary.get('code_lines_added', 0)} / -{summary.get('code_lines_deleted', 0)}",
-        f"- Config Δ: +{summary.get('config_lines_added', 0)} / -{summary.get('config_lines_deleted', 0)}",
-        f"- Elapsed: {summary.get('elapsed_since_previous_main_change', '-')}",
-        f"- Risk: {summary.get('risk', event.get('risk', 'unknown'))}",
-        f"- Test: {summary.get('test_status', '-')}",
-        f"- Rollback: `{summary.get('rollback_target', 'V1R1C4')}`",
-        f"- Changed: {changed_text}",
-        f"- Web UI: {summary.get('web_ui_audit_url', '/portal/me/#gitops-audit')}",
-    ])
-
-
-def diff_stats(base: str, branch: str) -> Dict[str, int]:
-    code_add = code_del = config_add = config_del = 0
-    rc, stdout, _ = run_cmd(["git", "diff", "--numstat", f"{base}...{branch}"], timeout=60)
-    if rc != 0:
-        return {"code_lines_added": 0, "code_lines_deleted": 0, "config_lines_added": 0, "config_lines_deleted": 0}
-    config_ext = {".json", ".yaml", ".yml", ".toml", ".ini", ".conf", ".service"}
-    for line in stdout.splitlines():
-        parts = line.split("\t")
-        if len(parts) < 3 or parts[0] == "-" or parts[1] == "-":
-            continue
-        add, delete, path = int(parts[0]), int(parts[1]), parts[2]
-        if pathlib.Path(path).suffix in config_ext or path.startswith("config/"):
-            config_add += add
-            config_del += delete
-        else:
-            code_add += add
-            code_del += delete
-    return {
-        "code_lines_added": code_add,
-        "code_lines_deleted": code_del,
-        "config_lines_added": config_add,
-        "config_lines_deleted": config_del,
-    }
-
-
-def build_summary(event: Dict[str, Any]) -> Dict[str, Any]:
-    branch = event.get("branch") or "patch/web-ui-complete-gitops-dashboard-20260706"
-    base = event.get("base") or "main"
-    stats = diff_stats(base, branch)
-    return {
-        "event_id": event.get("id") or event_id(event),
-        "branch": branch,
-        "from_rev": event.get("from_rev", base),
-        "to_rev": event.get("to_rev", branch),
-        "from_version": event.get("from_version", "V1R1C4"),
-        "to_version": event.get("to_version", "V1R1C5"),
-        "elapsed_since_previous_main_change": event.get("elapsed_since_previous_main_change", "unknown"),
-        "changed_features": event.get("changed_features", ["GitOps autonomous orchestration", "Owner notifications", "event bus", "safe daemon"]),
-        "test_status": event.get("test_status", "pending"),
-        "risk": event.get("risk", "high"),
-        "approval_status": event.get("approval_status", "required"),
-        "rollback_target": event.get("rollback_target", "V1R1C4"),
-        "web_ui_audit_url": event.get("web_ui_audit_url", "/portal/me/#gitops-audit"),
-        **stats,
-    }
-
-
-def has_preapproval(action: str, event: Dict[str, Any]) -> bool:
-    target_version = event.get("to_version") or "V1R1C5"
-    rollback_target = event.get("rollback_target") or "V1R1C4"
-    now_dt = _dt.datetime.now(_dt.timezone.utc)
-    for path in PREAPPROVAL_DIR.glob("*.json"):
-        try:
-            doc = json.loads(path.read_text(encoding="utf-8"))
-        except Exception:
-            continue
-        allowed = doc.get("allowed_actions", [])
-        if action not in allowed:
-            continue
-        if doc.get("target_version") != target_version:
-            continue
-        if doc.get("rollback_target") != rollback_target:
-            continue
-        if doc.get("approved_by_role") not in ["owner", "admin"]:
-            continue
-        expires_at = doc.get("expires_at")
-        if not expires_at:
-            continue
-        try:
-            exp = _dt.datetime.fromisoformat(expires_at.replace("Z", "+00:00"))
-        except ValueError:
-            continue
-        if exp > now_dt:
-            return True
-    return False
-
-
-def create_request(event: Dict[str, Any], reason: str) -> Dict[str, Any]:
-    req = {
-        "id": f"req-{utc_now().replace(':', '-')}-{event_id(event)}",
-        "created_at": utc_now(),
-        "event": redact(event),
-        "reason": reason,
-        "status": "pending_owner_review",
-        "web_ui": "/portal/me/#gitops-owner-actions",
-    }
-    write_json(REQUEST_DIR / f"{req['id']}.json", req)
-    return req
-
-
-def run_validation(event: Dict[str, Any]) -> Dict[str, Any]:
-    branch = event.get("branch") or "patch/web-ui-complete-gitops-dashboard-20260706"
-    base = event.get("base") or "main"
-    script = ROOT / "scripts" / "validate-gitops-platform-ui.sh"
-    if not script.exists():
-        return {"status": "blocked", "reason": "validation_script_missing"}
-    rc, out, err = run_cmd(["bash", str(script), branch, base], timeout=600)
-    REPORT_DIR.mkdir(parents=True, exist_ok=True)
-    (REPORT_DIR / "validation-daemon.log").write_text(out + "\n" + err, encoding="utf-8")
-    return {"status": "passed" if rc == 0 else "failed", "exit_code": rc, "log": "reports/codex/validation-daemon.log"}
-
-
-def run_merge_gate(event: Dict[str, Any]) -> Dict[str, Any]:
-    branch = event.get("branch") or "patch/web-ui-complete-gitops-dashboard-20260706"
-    base = event.get("base") or "main"
-    script = ROOT / "scripts" / "autonomous-merge-gate.sh"
-    if not script.exists():
-        return {"status": "blocked", "reason": "merge_gate_script_missing"}
-    rc, out, err = run_cmd(["bash", str(script), branch, base], timeout=600)
-    (REPORT_DIR / "merge-gate-daemon.log").write_text(out + "\n" + err, encoding="utf-8")
-    return {"status": "passed" if rc == 0 else "failed", "exit_code": rc, "log": "reports/codex/merge-gate-daemon.log"}
-
-
-def handle_event(event: Dict[str, Any]) -> Dict[str, Any]:
-    event_type = event.get("type", "unknown")
-    action = event.get("action", event_type)
-
-    if action in ALWAYS_BLOCKED:
-        req = create_request(event, f"Blocked permanently by autonomous production policy: {action}")
-        audit("event.blocked", "blocked", {"event": event, "request": req})
-        return {"status": "blocked", "request": req}
-
-    summary = build_summary(event)
-
-    if event_type in OWNER_NOTIFY_EVENTS:
-        notify_result = send_owner_wechat(event, summary)
-        audit("owner.notify", notify_result.get("status", "unknown"), {"event": event, "summary": summary, "result": notify_result})
-
-    if event_type in {"git_push", "patch_created", "validation_failed"}:
-        validation = run_validation(event)
-        audit("codex.validation", validation["status"], {"event": event, "validation": validation})
-        if validation["status"] != "passed":
-            req = create_request(event, "Validation failed; GPT repair loop required.")
-            return {"status": "validation_failed", "request": req, "validation": validation}
-        gate = run_merge_gate(event)
-        audit("codex.merge_gate", gate["status"], {"event": event, "gate": gate})
-        return {"status": "merge_candidate" if gate["status"] == "passed" else "gate_failed", "validation": validation, "gate": gate}
-
-    if action in PRODUCTION_ACTIONS:
-        if has_preapproval(action, event):
-            # This daemon deliberately records intent. The actual protected write must be
-            # performed by configured GitOps Actions with server-side authorization.
-            req = create_request(event, f"Preapproval found for {action}; execute through protected GitOps Action.")
-            audit("production.preapproved", "request_created", {"event": event, "request": req})
-            return {"status": "preapproved_request_created", "request": req}
-        req = create_request(event, f"Production action requires preapproved runbook: {action}")
-        audit("production.approval_required", "pending", {"event": event, "request": req})
-        return {"status": "approval_required", "request": req}
-
-    audit("event.record", "ok", {"event": event, "summary": summary})
-    return {"status": "recorded", "summary": summary}
-
-
-def process_once() -> int:
-    count = 0
-    for path in read_event_files():
-        try:
-            event = json.loads(path.read_text(encoding="utf-8"))
-            result = handle_event(event)
-            archive_event(path, "done")
-            count += 1
-            audit("event.processed", "ok", {"path": str(path), "result": result})
-        except Exception as exc:  # noqa: BLE001 - daemon must not crash on single event
-            archive_event(path, "failed")
-            audit("event.processed", "failed", {"path": str(path), "error": str(exc)})
-    return count
-
-
-def emit_event(args: argparse.Namespace) -> None:
-    event = {
-        "id": args.id or f"evt-{utc_now().replace(':', '-')}",
-        "type": args.type,
-        "action": args.action or args.type,
-        "branch": args.branch,
-        "base": args.base,
-        "from_version": args.from_version,
-        "to_version": args.to_version,
-        "risk": args.risk,
-        "created_at": utc_now(),
-    }
-    write_json(EVENT_DIR / f"{event['id']}.json", event)
-    print(json.dumps(redact(event), ensure_ascii=False, indent=2))
-
-
-def main(argv: Optional[Iterable[str]] = None) -> int:
-    parser = argparse.ArgumentParser(description="AIOS Autonomous GitOps Daemon")
-    sub = parser.add_subparsers(dest="cmd", required=True)
-
-    run = sub.add_parser("run")
-    run.add_argument("--interval", type=int, default=30)
-    run.add_argument("--once", action="store_true")
-
-    emit = sub.add_parser("emit")
-    emit.add_argument("--id")
-    emit.add_argument("--type", required=True)
-    emit.add_argument("--action")
-    emit.add_argument("--branch", default="patch/web-ui-complete-gitops-dashboard-20260706")
-    emit.add_argument("--base", default="main")
-    emit.add_argument("--from-version", default="V1R1C4")
-    emit.add_argument("--to-version", default="V1R1C5")
-    emit.add_argument("--risk", default="high")
-
-    args = parser.parse_args(list(argv) if argv is not None else None)
-
-    if args.cmd == "emit":
-        emit_event(args)
-        return 0
-
-    if args.cmd == "run":
-        EVENT_DIR.mkdir(parents=True, exist_ok=True)
-        AUDIT_DIR.mkdir(parents=True, exist_ok=True)
-        REQUEST_DIR.mkdir(parents=True, exist_ok=True)
-        if args.once:
-            return 0 if process_once() >= 0 else 1
-        audit("daemon.start", "ok", {"event_dir": str(EVENT_DIR)})
-        while True:
-            process_once()
-            time.sleep(args.interval)
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

services/aios-consensus-controller/controller.py

@@ -1,77 +0,0 @@
-#!/usr/bin/env python3
-"""AIOS Multi-Agent Consensus Controller
-
-This service aggregates decisions from OpenClaw, Codex, and ChatGPT agents
-and computes a bounded consensus decision for GitOps operations.
-
-It does NOT directly modify production state. It only produces decision artifacts.
-"""
-
-import json
-import os
-import pathlib
-import time
-from typing import Dict, Any
-
-ROOT = pathlib.Path(os.environ.get("AIOS_REPO_ROOT", ".")).resolve()
-CONSENSUS_DIR = ROOT / "reports" / "consensus"
-AGENT_DIRS = {
-    "openclaw": ROOT / "reports" / "openclaw",
-    "codex": ROOT / "reports" / "codex",
-    "chatgpt": ROOT / "reports" / "chatgpt",
-}
-
-CONSENSUS_DIR.mkdir(parents=True, exist_ok=True)
-
-
-def load_latest(path: pathlib.Path) -> Dict[str, Any]:
-    if not path.exists():
-        return {}
-    files = sorted(path.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
-    if not files:
-        return {}
-    return json.loads(files[0].read_text(encoding="utf-8"))
-
-
-def compute_consensus(reports: Dict[str, Dict[str, Any]]) -> Dict[str, Any]:
-    weights = {"openclaw": 2, "codex": 2, "chatgpt": 1}
-
-    score = 0
-    for agent, report in reports.items():
-        status = report.get("status", "unknown")
-        if status in ("PASS", "approved", "merge_candidate"):
-            score += weights.get(agent, 1)
-        elif status in ("FAIL", "blocked"):
-            score -= weights.get(agent, 1)
-
-    if score >= 4:
-        decision = "approved"
-    elif score >= 2:
-        decision = "conditional"
-    else:
-        decision = "rejected"
-
-    return {
-        "decision": decision,
-        "score": score,
-        "timestamp": time.time(),
-    }
-
-
-def main():
-    reports = {
-        "openclaw": load_latest(AGENT_DIRS["openclaw"]),
-        "codex": load_latest(AGENT_DIRS["codex"]),
-        "chatgpt": load_latest(AGENT_DIRS["chatgpt"]),
-    }
-
-    result = compute_consensus(reports)
-
-    out_path = CONSENSUS_DIR / "decision.json"
-    out_path.write_text(json.dumps(result, indent=2), encoding="utf-8")
-
-    print("CONSENSUS:", result)
-
-
-if __name__ == "__main__":
-    main()

services/aios-event-ingress/server.py

@@ -1,43 +0,0 @@
-#!/usr/bin/env python3
-"""AIOS Event Ingress Server
-
-Receives GitOps events via HTTP and writes them into the local event bus directory.
-No authentication secrets are embedded; optional signature validation can be enabled via env.
-"""
-
-from http.server import BaseHTTPRequestHandler, HTTPServer
-import json
-import os
-import pathlib
-import time
-
-EVENT_DIR = pathlib.Path(os.environ.get("AIOS_EVENT_DIR", "runtime/gitops/events"))
-EVENT_DIR.mkdir(parents=True, exist_ok=True)
-
-class Handler(BaseHTTPRequestHandler):
-    def do_POST(self):
-        length = int(self.headers.get('Content-Length', 0))
-        body = self.rfile.read(length).decode('utf-8')
-        try:
-            event = json.loads(body)
-        except Exception:
-            self.send_response(400)
-            self.end_headers()
-            return
-
-        event_id = event.get("id", f"evt-{int(time.time())}")
-        path = EVENT_DIR / f"{event_id}.json"
-        path.write_text(json.dumps(event, indent=2), encoding='utf-8')
-
-        self.send_response(200)
-        self.end_headers()
-        self.wfile.write(b"OK")
-
-    def log_message(self, format, *args):
-        return
-
-if __name__ == "__main__":
-    port = int(os.environ.get("AIOS_INGRESS_PORT", "8787"))
-    server = HTTPServer(("0.0.0.0", port), Handler)
-    print(f"[AIOS] Event ingress running on {port}")
-    server.serve_forever()

services/aios-v1r1-wechat-outbound-worker/discovery.py

@@ -1,28 +0,0 @@
-#!/usr/bin/env python3
-"""V1R1 Personal WeChat Endpoint Discovery
-
-Helps locate active V1R1 personal WeChat runtime endpoints on the host.
-"""
-
-import subprocess
-import re
-
-CANDIDATES = [8788, 8789, 8790, 8088, 8000]
-
-print("[AIOS] Scanning for V1R1 WeChat endpoints...")
-
-for port in CANDIDATES:
-    try:
-        result = subprocess.run(
-            ["bash", "-lc", f"ss -ltnp | grep {port}"],
-            capture_output=True,
-            text=True
-        )
-        if result.stdout:
-            print(f"[FOUND] Port {port}: {result.stdout.strip()}")
-        else:
-            print(f"[MISS] Port {port}")
-    except Exception as e:
-        print(f"[ERROR] Port {port}: {e}")
-
-print("[AIOS] Discovery complete. Please map discovered endpoint to AIOS_V1R1_WECHAT_OUTBOUND_URL")

services/aios-v1r1-wechat-outbound-worker/worker.py

@@ -1,206 +0,0 @@
-#!/usr/bin/env python3
-"""AIOS V1R1 Personal WeChat Outbound Worker.
-
-This worker is the bridge between the Xiamayiti self-evolution loop and the
-already-deployed V1R1 personal WeChat capability.
-
-Design rules:
-- Do not embed credentials.
-- Do not access runtime/secrets directly.
-- Read owner-notification outbox JSON files.
-- Deliver to a runtime-configured V1R1 notification endpoint, or try local V1R1 candidates.
-- Write delivery status for audit/Web UI.
-"""
-
-from __future__ import annotations
-
-import datetime as dt
-import json
-import os
-import pathlib
-import shutil
-import time
-import urllib.error
-import urllib.request
-from typing import Any, Dict, Iterable, List, Optional
-
-ROOT = pathlib.Path(os.environ.get("AIOS_REPO_ROOT", "/data/aios-gitops/workspace"))
-BASE = pathlib.Path(os.environ.get("AIOS_RUNTIME_ROOT", "/data/aios-gitops/runtime"))
-OUTBOX = pathlib.Path(os.environ.get("AIOS_V1R1_WECHAT_OUTBOX", str(BASE / "integrations" / "v1r1-personal-wechat" / "outbox")))
-SENT = pathlib.Path(os.environ.get("AIOS_V1R1_WECHAT_SENT", str(BASE / "integrations" / "v1r1-personal-wechat" / "sent")))
-FAILED = pathlib.Path(os.environ.get("AIOS_V1R1_WECHAT_FAILED", str(BASE / "integrations" / "v1r1-personal-wechat" / "failed")))
-STATUS = pathlib.Path(os.environ.get("AIOS_V1R1_WECHAT_STATUS", str(BASE / "integrations" / "v1r1-personal-wechat" / "status")))
-AUDIT = pathlib.Path(os.environ.get("AIOS_AUDIT_DIR", str(BASE / "audit")))
-INTERVAL = int(os.environ.get("AIOS_V1R1_WECHAT_INTERVAL", "10"))
-
-# Runtime-configured endpoint. This can point to the existing V1R1 personal-WeChat module.
-PRIMARY_ENDPOINT = os.environ.get("AIOS_V1R1_WECHAT_OUTBOUND_URL", "")
-
-LOCAL_CANDIDATES = [
-    "http://127.0.0.1:8788/api/v1r1/personal-wechat/send",
-    "http://127.0.0.1:8788/api/v1r1/notification/owner",
-    "http://127.0.0.1:8789/api/owner/wechat/send",
-    "http://127.0.0.1:8790/owner/notify",
-]
-
-
-def now() -> str:
-    return dt.datetime.now(dt.timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
-
-
-def write_json(path: pathlib.Path, value: Dict[str, Any]) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    tmp = path.with_suffix(path.suffix + ".tmp")
-    tmp.write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
-    tmp.replace(path)
-
-
-def audit(action: str, status: str, detail: Dict[str, Any]) -> None:
-    record = {"ts": now(), "action": action, "status": status, "detail": detail}
-    safe_name = record["ts"].replace(":", "-") + f"-{action}.json"
-    write_json(AUDIT / safe_name, record)
-    print(json.dumps(record, ensure_ascii=False), flush=True)
-
-
-def normalize_message(item: Dict[str, Any]) -> Dict[str, Any]:
-    title = item.get("title") or "AIOS GitOps 通报"
-    content = item.get("content") or item.get("message") or json.dumps(item, ensure_ascii=False)
-    priority = item.get("priority") or "normal"
-    return {
-        "event_id": item.get("event_id") or item.get("id") or f"evt-{int(time.time())}",
-        "channel": "personal_wechat",
-        "priority": priority,
-        "title": title,
-        "content": content,
-        "source": item.get("source") or "aios-self-evolution",
-        "branch": item.get("branch"),
-        "from_version": item.get("from_version"),
-        "to_version": item.get("to_version"),
-        "rollback_target": item.get("rollback_target") or "V1R1C4",
-        "web_ui_audit_url": item.get("web_ui_audit_url") or "/portal/me/#gitops-audit",
-        "created_at": item.get("created_at") or now(),
-    }
-
-
-def endpoints() -> List[str]:
-    values: List[str] = []
-    if PRIMARY_ENDPOINT:
-        values.append(PRIMARY_ENDPOINT)
-    values.extend(LOCAL_CANDIDATES)
-    # Preserve order but remove duplicates.
-    result: List[str] = []
-    seen = set()
-    for value in values:
-        if value and value not in seen:
-            result.append(value)
-            seen.add(value)
-    return result
-
-
-def post_json(url: str, payload: Dict[str, Any]) -> Dict[str, Any]:
-    body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
-    req = urllib.request.Request(url, data=body, headers={"Content-Type": "application/json"}, method="POST")
-    with urllib.request.urlopen(req, timeout=8) as resp:
-        text = resp.read().decode("utf-8", errors="replace")[:500]
-        return {"ok": 200 <= resp.status < 300, "status": resp.status, "response": text, "url": url}
-
-
-def deliver(message: Dict[str, Any]) -> Dict[str, Any]:
-    attempts = []
-    for url in endpoints():
-        try:
-            result = post_json(url, message)
-            attempts.append(result)
-            if result.get("ok"):
-                return {"status": "sent", "endpoint": url, "attempts": attempts}
-        except urllib.error.URLError as exc:
-            attempts.append({"ok": False, "url": url, "error": str(exc)})
-        except Exception as exc:  # noqa: BLE001
-            attempts.append({"ok": False, "url": url, "error": str(exc)})
-    return {"status": "failed", "attempts": attempts, "reason": "no_endpoint_accepted_message"}
-
-
-def process_file(path: pathlib.Path) -> None:
-    try:
-        item = json.loads(path.read_text(encoding="utf-8"))
-    except Exception as exc:  # noqa: BLE001
-        failed_target = FAILED / path.name
-        FAILED.mkdir(parents=True, exist_ok=True)
-        shutil.move(str(path), str(failed_target))
-        audit("v1r1.wechat.parse", "failed", {"path": str(path), "error": str(exc)})
-        return
-
-    message = normalize_message(item)
-    result = deliver(message)
-    status_record = {"ts": now(), "file": path.name, "message": message, "delivery": result}
-    write_json(STATUS / (path.stem + ".status.json"), status_record)
-
-    if result.get("status") == "sent":
-        SENT.mkdir(parents=True, exist_ok=True)
-        shutil.move(str(path), str(SENT / path.name))
-        audit("v1r1.wechat.deliver", "sent", status_record)
-    else:
-        FAILED.mkdir(parents=True, exist_ok=True)
-        shutil.move(str(path), str(FAILED / path.name))
-        audit("v1r1.wechat.deliver", "failed", status_record)
-
-
-def process_once() -> int:
-    OUTBOX.mkdir(parents=True, exist_ok=True)
-    count = 0
-    for path in sorted(OUTBOX.glob("*.json"), key=lambda p: p.stat().st_mtime):
-        process_file(path)
-        count += 1
-    return count
-
-
-def emit_startup_notice() -> pathlib.Path:
-    OUTBOX.mkdir(parents=True, exist_ok=True)
-    path = OUTBOX / f"startup-{int(time.time())}.json"
-    write_json(path, {
-        "event_id": f"startup-{int(time.time())}",
-        "type": "owner_notification",
-        "channel": "personal_wechat",
-        "priority": "high",
-        "title": "AIOS 自我进化系统已启动",
-        "content": "AIOS 虾马一体 self-evolution loop 已进入运行态。daemon、event bus、GitOps 写链路已恢复；后续将通过 V1R1 个人微信模块与 Web UI 审计同步进展。",
-        "source": "aios-v1r1-wechat-outbound-worker",
-        "branch": "patch/web-ui-complete-gitops-dashboard-20260706",
-        "from_version": "V1R1C4",
-        "to_version": "V1R1C5",
-        "rollback_target": "V1R1C4",
-        "web_ui_audit_url": "/portal/me/#gitops-audit",
-        "created_at": now()
-    })
-    return path
-
-
-def main() -> int:
-    import argparse
-    parser = argparse.ArgumentParser(description="AIOS V1R1 personal WeChat outbound worker")
-    parser.add_argument("--once", action="store_true")
-    parser.add_argument("--emit-startup-notice", action="store_true")
-    args = parser.parse_args()
-
-    OUTBOX.mkdir(parents=True, exist_ok=True)
-    SENT.mkdir(parents=True, exist_ok=True)
-    FAILED.mkdir(parents=True, exist_ok=True)
-    STATUS.mkdir(parents=True, exist_ok=True)
-    AUDIT.mkdir(parents=True, exist_ok=True)
-
-    if args.emit_startup_notice:
-        path = emit_startup_notice()
-        audit("v1r1.wechat.outbox", "created", {"path": str(path)})
-
-    if args.once:
-        process_once()
-        return 0
-
-    audit("v1r1.wechat.worker.start", "ok", {"outbox": str(OUTBOX), "has_primary_endpoint": bool(PRIMARY_ENDPOINT)})
-    while True:
-        process_once()
-        time.sleep(INTERVAL)
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

skills/gitops-platform-validation/SKILL.md

@@ -1,52 +0,0 @@
-# Skill: GitOps Platform Validation
-
-## Name
-gitops-platform-validation
-
-## Version
-1.0.0
-
-## Purpose
-Provide reusable Codex execution behavior for validating GitOps platform UI branches and enabling self-healing CI loops.
-
-## Trigger
-- branch matches: patch/*
-- contains: gitops-dashboard
-
-## Actions
-1. Run validation script
-   ```bash
-   bash scripts/validate-gitops-platform-ui.sh <branch> main
-   ```
-
-2. If FAIL:
-   - generate failure report
-   - invoke GPT repair loop
-   - re-run validation
-
-3. If PASS:
-   - run autonomous merge gate
-   ```bash
-   bash scripts/autonomous-merge-gate.sh <branch> main
-   ```
-
-4. If merge candidate created:
-   - propose V1R1C5 baseline update
-
-## Constraints
-- no secrets in logs
-- no direct main write
-- destructive operations forbidden
-- all merges must pass policy gate
-
-## Self-Healing Behavior
-- max iterations: 5
-- stop on:
-  - PASS
-  - security failure
-  - manual override
-
-## Output
-- validation report
-- merge candidate artifact
-- optional baseline proposal

test/cmd-permission-check.txt

@@ -1 +0,0 @@
-CMD-20260708 git actions write permission verified OK

tests/acceptance/gitops-platform-ui.acceptance.json

@@ -1,239 +0,0 @@
-{
-  "suite": "gitops-platform-ui",
-  "version": "1.0.0",
-  "branch_under_test": "patch/web-ui-complete-gitops-dashboard-20260706",
-  "base_branch": "main",
-  "purpose": "Validate AIOS GitOps Platform Control Plane UI before merge to main and before V1R1C5 baseline proposal.",
-  "required_result": "PASS",
-  "tests": [
-    {
-      "id": "STATIC-001",
-      "group": "static_files",
-      "required": true,
-      "description": "Platform UI files exist.",
-      "assert": {
-        "files_exist": [
-          "overlays/user-control-center/portal/gitops-dashboard/index.html",
-          "overlays/user-control-center/portal/gitops-dashboard/app.js",
-          "overlays/user-control-center/portal/gitops-dashboard/styles.css",
-          "overlays/user-control-center/portal/gitops-dashboard/manifest.json",
-          "overlays/user-control-center/portal/gitops-dashboard/gitops-ui-policy.json",
-          "overlays/user-control-center/portal/gitops-dashboard/gitops-enterprise-api.contract.json"
-        ]
-      }
-    },
-    {
-      "id": "STATIC-002",
-      "group": "static_files",
-      "required": true,
-      "description": "Enterprise tabs exist in HTML.",
-      "assert": {
-        "file_contains": {
-          "overlays/user-control-center/portal/gitops-dashboard/index.html": [
-            "tab-overview",
-            "tab-rbac",
-            "tab-approval",
-            "tab-diff",
-            "tab-patch",
-            "tab-model",
-            "tab-release",
-            "tab-audit"
-          ]
-        }
-      }
-    },
-    {
-      "id": "RUNTIME-001",
-      "group": "frontend_runtime",
-      "required": true,
-      "description": "Platform runtime bootstraps on DOMContentLoaded.",
-      "assert": {
-        "file_contains": {
-          "overlays/user-control-center/portal/gitops-dashboard/app.js": [
-            "Platform.bootstrap",
-            "DOMContentLoaded",
-            "guardAction",
-            "createApproval",
-            "renderDiffTree",
-            "audit(" ,
-            "redact("
-          ]
-        }
-      }
-    },
-    {
-      "id": "SEC-001",
-      "group": "security",
-      "required": true,
-      "description": "No real credentials are committed.",
-      "assert": {
-        "secret_scan": {
-          "paths": [
-            "overlays/user-control-center/portal/gitops-dashboard",
-            "docs/codex",
-            "tests/acceptance",
-            "scripts",
-            "skills"
-          ],
-          "allow_patterns": [
-            "secret_ref://",
-            "[REDACTED]",
-            "api_key_secret_ref",
-            "forbiddenFields",
-            "secret_redaction",
-            "No credentials"
-          ],
-          "deny_patterns": [
-            "Bearer [A-Za-z0-9._-]{20,}",
-            "sk-[A-Za-z0-9]{20,}",
-            "ghp_[A-Za-z0-9]{20,}",
-            "AKIA[0-9A-Z]{16}",
-            "BEGIN PRIVATE KEY",
-            "BEGIN RSA PRIVATE KEY"
-          ]
-        }
-      }
-    },
-    {
-      "id": "SEC-002",
-      "group": "security",
-      "required": true,
-      "description": "Model registration requires secret_ref and never raw api_key.",
-      "assert": {
-        "file_contains": {
-          "overlays/user-control-center/portal/gitops-dashboard/app.js": [
-            "api_key_secret_ref",
-            "startsWith('secret_ref://')",
-            "api_key_secret_ref_required"
-          ]
-        },
-        "file_not_contains": {
-          "overlays/user-control-center/portal/gitops-dashboard/index.html": [
-            "name=\"api_key\"",
-            "name=\"token\"",
-            "name=\"password\""
-          ]
-        }
-      }
-    },
-    {
-      "id": "POLICY-001",
-      "group": "gitops_policy",
-      "required": true,
-      "description": "Direct main writes and destructive actions are disabled or blocked.",
-      "assert": {
-        "file_contains": {
-          "overlays/user-control-center/portal/gitops-dashboard/app.js": [
-            "main:write",
-            "destructive_action_blocked",
-            "high_risk_requires_approval"
-          ],
-          "overlays/user-control-center/portal/gitops-dashboard/gitops-ui-policy.json": [
-            "direct_main_write",
-            "disabled_in_ui",
-            "bulk_delete",
-            "forbidden"
-          ]
-        }
-      }
-    },
-    {
-      "id": "API-001",
-      "group": "api_contract",
-      "required": true,
-      "description": "Read/write endpoint contract remains compatible with existing GitOps APIs.",
-      "assert": {
-        "file_contains": {
-          "overlays/user-control-center/portal/gitops-dashboard/gitops-enterprise-api.contract.json": [
-            "GET /api/base",
-            "GET /api/ver",
-            "GET /api/run",
-            "GET /api/patch",
-            "GET /api/model",
-            "POST /api/branch",
-            "POST /api/patch/plan",
-            "POST /api/model",
-            "PUT /api/model-priority",
-            "POST /api/rollback-request",
-            "POST /api/tag-request"
-          ]
-        }
-      }
-    },
-    {
-      "id": "REGRESSION-001",
-      "group": "indirect_regression",
-      "required": true,
-      "description": "This branch must not alter auth, gitea owner sync, baseline version, or destructive history files.",
-      "assert": {
-        "diff_not_touch_paths": [
-          "config/auth/",
-          "config/casdoor/",
-          "config/gitea/",
-          "versions/V1R1C4.json",
-          "runtime/gitops/current.json"
-        ],
-        "diff_not_contain": [
-          "active_version\": \"V1R1C5",
-          "force push",
-          "delete tag",
-          "purge baseline",
-          "clear audit"
-        ]
-      }
-    },
-    {
-      "id": "BASELINE-001",
-      "group": "baseline_proposal",
-      "required": true,
-      "description": "A V1R1C5 proposal exists but is not activated before merge.",
-      "assert": {
-        "files_exist": [
-          "versions/proposals/V1R1C5-gitops-platform-ui.proposed.json"
-        ],
-        "file_contains": {
-          "versions/proposals/V1R1C5-gitops-platform-ui.proposed.json": [
-            "V1R1C5",
-            "V1R1C4",
-            "approval_required"
-          ]
-        }
-      }
-    },
-    {
-      "id": "SKILL-001",
-      "group": "auto_loaded_skill",
-      "required": true,
-      "description": "Codex/GPT reusable skill exists and references the validation workflow.",
-      "assert": {
-        "files_exist": [
-          "skills/gitops-platform-validation/SKILL.md"
-        ],
-        "file_contains": {
-          "skills/gitops-platform-validation/SKILL.md": [
-            "validate-gitops-platform-ui.sh",
-            "gitops-platform-ui.acceptance.json",
-            "self-healing"
-          ]
-        }
-      }
-    }
-  ],
-  "merge_gate": {
-    "allow_merge_to_main_when": [
-      "all required tests PASS",
-      "gray deployment PASS",
-      "no secret leak",
-      "no direct main write",
-      "V1R1C5 proposal reviewed",
-      "owner/admin approval recorded"
-    ],
-    "block_merge_when": [
-      "any required test FAIL",
-      "any required test BLOCKED without explicit owner override",
-      "secret leak detected",
-      "destructive operation detected",
-      "baseline active version changed before merge"
-    ]
-  }
-}

tests/test_agent_event_bus.py

@@ -1,22 +0,0 @@
-from active_runtime.app.agent_event_bus import AgentEventBus
-from active_runtime.app.agent_event_dashboard import AgentEventDashboard
-
-
-def test_unified_event_flow():
-    bus = AgentEventBus(root="/tmp/aios-agent-events-test")
-    event = bus.publish(
-        kind="gpt_inbox",
-        source="openclaw",
-        target="custom-gpt",
-        summary="execution report",
-        payload={"status": "done"},
-    )
-
-    assert event["status"] == "pending"
-    assert len(bus.list_events(kind="gpt_inbox")) == 1
-
-    done = bus.transition(event["id"], "completed", "custom-gpt")
-    assert done["status"] == "completed"
-
-    dashboard = AgentEventDashboard(bus).overview()
-    assert dashboard["audit"]["enabled"] is True

tests/test_chatgpt_actions_runtime_policy.py

@@ -0,0 +1,45 @@
+import ast
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+APP = ROOT / "active-runtime" / "app" / "aios_chatgpt_actions_api.py"
+
+
+def module_tree():
+    return ast.parse(APP.read_text(encoding="utf-8"))
+
+
+def test_runtime_defines_low_risk_route_map():
+    text = APP.read_text(encoding="utf-8")
+    for route in [
+        "/api/gitops/report-file",
+        "/api/gitops/docs-file",
+        "/api/gitops/proposal-file",
+        "/api/gitops/patch-evidence",
+        "/api/gitops/main-file",
+        "/api/gitops/rollback-request",
+    ]:
+        assert route in text
+
+
+def test_runtime_has_low_risk_and_main_handlers():
+    names = {node.name for node in ast.walk(module_tree()) if isinstance(node, ast.FunctionDef)}
+    assert "low_risk_file" in names
+    assert "main_file" in names
+    assert "secret_path" in names
+    assert "path_in_scope" in names
+
+
+def test_runtime_policy_rejects_main_and_secret_paths_in_low_risk_handler():
+    text = APP.read_text(encoding="utf-8")
+    assert "low-risk write requires explicit non-main patch/request branch" in text
+    assert "Secret-like path rejected. Use runtime secret store or secret_ref." in text
+    assert "path_out_of_scope" in text
+    assert "Secret-like content detected. Use runtime secret store or secret_ref." in text
+
+
+def test_runtime_preserves_legacy_commit_file_route():
+    text = APP.read_text(encoding="utf-8")
+    assert "if path == '/api/file': return self.file(data)" in text
+    assert "def file(self,data):" in text

tests/test_gitops_low_risk_commit_policy.py

@@ -0,0 +1,70 @@
+import sys
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "scripts"))
+
+from gitops_actions_policy import validate_low_risk_commit, validate_write_policy  # noqa: E402
+
+
+def assert_allowed(operation_id, branch, path, content="safe content"):
+    result = validate_low_risk_commit(operation_id, branch, path, content)
+    assert result.allowed, result.reason
+
+
+def assert_rejected(operation_id, branch, path, reason, content="safe content"):
+    result = validate_low_risk_commit(operation_id, branch, path, content)
+    assert not result.allowed
+    assert result.reason == reason
+
+
+def test_commit_report_file_scope():
+    assert_allowed("commitReportFile", "patch/gpt-actions-consequential-governance", "reports/example.md")
+    assert_rejected("commitReportFile", "patch/gpt-actions-consequential-governance", "docs/example.md", "path_out_of_scope")
+
+
+def test_commit_docs_file_scope():
+    assert_allowed("commitDocsFile", "patch/gpt-actions-consequential-governance", "docs/architecture/example.md")
+    assert_rejected("commitDocsFile", "patch/gpt-actions-consequential-governance", "reports/example.md", "path_out_of_scope")
+
+
+def test_commit_proposal_and_patch_evidence_scopes():
+    assert_allowed("commitProposalFile", "patch/gpt-actions-consequential-governance", "proposals/change.json")
+    assert_allowed("commitPatchEvidence", "patch/gpt-actions-consequential-governance", "reports/evidence.md")
+    assert_allowed("commitPatchEvidence", "patch/gpt-actions-consequential-governance", "patches/evidence.json")
+    assert_rejected("commitPatchEvidence", "patch/gpt-actions-consequential-governance", "docs/evidence.md", "path_out_of_scope")
+
+
+def test_low_risk_actions_reject_main_branch():
+    for operation_id in ["commitReportFile", "commitDocsFile", "commitProposalFile", "commitPatchEvidence"]:
+        assert_rejected(operation_id, "main", "reports/example.md", "low_risk_action_rejects_main")
+
+
+def test_all_write_actions_reject_secret_paths():
+    secret_paths = ["runtime/secrets/key.txt", ".env", "private/key.txt", "prod-secrets/config.json", "reports/value.token"]
+    for operation_id in ["commitReportFile", "commitDocsFile", "commitPatchEvidence", "commitFile", "commitMainFile", "createRollbackRequest"]:
+        for path in secret_paths:
+            result = validate_write_policy(operation_id, "patch/gpt-actions-consequential-governance", path)
+            assert not result.allowed
+            assert result.reason == "secret_path_rejected"
+
+
+def test_secret_like_content_is_rejected():
+    samples = [
+        "Bearer abc",
+        "password=abc",
+        "api_key=abc",
+        "BEGIN PRIVATE KEY",
+        "access_token=abc",
+        "refresh_token=abc",
+    ]
+    for sample in samples:
+        result = validate_low_risk_commit(
+            "commitReportFile",
+            "patch/gpt-actions-consequential-governance",
+            "reports/example.md",
+            sample,
+        )
+        assert not result.allowed
+        assert result.reason == "secret_like_content_detected"

tests/test_openapi_consequential_flags.py

@@ -0,0 +1,76 @@
+import json
+from pathlib import Path
+import re
+
+import yaml
+
+
+ROOT = Path(__file__).resolve().parents[1]
+SCHEMA = ROOT / "docs" / "gitops" / "openapi-chatgpt-actions.yaml"
+
+
+def load_schema():
+    return yaml.safe_load(SCHEMA.read_text(encoding="utf-8"))
+
+
+def operations_by_id(schema):
+    operations = {}
+    for path_item in schema.get("paths", {}).values():
+        if not isinstance(path_item, dict):
+            continue
+        for method, operation in path_item.items():
+            if method.lower() not in {"get", "post", "put", "patch", "delete"}:
+                continue
+            if isinstance(operation, dict) and operation.get("operationId"):
+                operations[operation["operationId"]] = operation
+    return operations
+
+
+def _examples(value):
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if key in {"example", "examples"}:
+                yield item
+            yield from _examples(item)
+    elif isinstance(value, list):
+        for item in value:
+            yield from _examples(item)
+
+
+def test_low_risk_operations_are_non_consequential():
+    ops = operations_by_id(load_schema())
+    for op_id in ["commitReportFile", "commitDocsFile", "commitProposalFile", "commitPatchEvidence"]:
+        assert op_id in ops
+        assert ops[op_id].get("x-openai-isConsequential") is False
+
+
+def test_high_risk_operations_remain_consequential():
+    ops = operations_by_id(load_schema())
+    for op_id in [
+        "commitFile",
+        "commitMainFile",
+        "createRollbackRequest",
+        "requestRollback",
+        "requestOrCreateTag",
+        "setModelPriority",
+        "registerModel",
+    ]:
+        assert op_id in ops
+        assert ops[op_id].get("x-openai-isConsequential") is True
+
+
+def test_legacy_commit_file_is_preserved_as_consequential():
+    ops = operations_by_id(load_schema())
+    assert ops["commitFile"].get("x-openai-isConsequential") is True
+
+
+def test_security_schemes_and_examples_do_not_embed_real_credentials():
+    schema = load_schema()
+    secret_like = re.compile(
+        r"sk-[A-Za-z0-9_-]{8,}|BEGIN\s+PRIVATE\s+KEY|password\s*=|api_key\s*=|access_token\s*=|refresh_token\s*=",
+        re.IGNORECASE,
+    )
+    checked = json.dumps(schema.get("components", {}).get("securitySchemes", {}), ensure_ascii=False)
+    for value in _examples(schema):
+        checked += "\n" + json.dumps(value, ensure_ascii=False)
+    assert not secret_like.search(checked)

tests/test_wechat_send_backend.py

@@ -1,87 +0,0 @@
-from __future__ import annotations
-
-import importlib.util
-import sys
-from pathlib import Path
-from types import SimpleNamespace
-from unittest import TestCase
-from unittest.mock import patch
-
-
-BACKEND_PATH = Path(__file__).resolve().parents[1] / "scripts" / "wechat_send_backend.py"
-
-
-def _load_backend():
-    spec = importlib.util.spec_from_file_location("wechat_send_backend", BACKEND_PATH)
-    if spec is None or spec.loader is None:
-        raise RuntimeError(f"unable to load backend from {BACKEND_PATH}")
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[spec.name] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-class WechatSendBackendTests(TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.backend = _load_backend()
-
-    def test_select_backend_prefers_ucc_adapter_over_openclaw_channel(self):
-        with (
-            patch.object(self.backend, "SEND_BACKEND", ""),
-            patch.object(self.backend, "ucc_adapter_alive", return_value=True),
-            patch.object(self.backend, "discover_openclaw_wechat_channel", return_value="some-wechat-channel"),
-        ):
-            selected = self.backend.select_backend()
-
-        self.assertEqual(selected["backend"], "ucc-adapter")
-        self.assertEqual(selected["reason"], "ucc_adapter_alive")
-
-    def test_openclaw_chat_only_is_not_wechat_channel(self):
-        completed = SimpleNamespace(returncode=0, stdout='{"chat": {}}')
-        with (
-            patch.object(self.backend, "WECHAT_CHANNEL", ""),
-            patch.object(self.backend, "_run_openclaw", return_value=completed),
-        ):
-            self.assertIsNone(self.backend.discover_openclaw_wechat_channel())
-
-    def test_send_ucc_adapter_uses_canonical_endpoint_and_sent_status(self):
-        with (
-            patch.object(self.backend, "UCC_SEND_PATH", "/api/internal/wechat/send"),
-            patch.object(
-                self.backend,
-                "_post_ucc",
-                return_value=(
-                    200,
-                    {
-                        "ok": True,
-                        "status": "sent",
-                        "provider_message_id": "openclaw-weixin:1-abc",
-                    },
-                ),
-            ) as post,
-        ):
-            result = self.backend.send_ucc_adapter(
-                target="chat-001",
-                content="hello",
-                account_id="acct-001",
-                message_id="msg-001",
-                metadata={"source": "test"},
-            ).to_dict()
-
-        self.assertTrue(result["ok"])
-        self.assertEqual(result["backend"], "ucc-adapter")
-        self.assertEqual(result["status"], "sent")
-        self.assertEqual(result["endpoint"], "/api/internal/wechat/send")
-        post.assert_called_once()
-        args, _ = post.call_args
-        self.assertEqual(args[0], "/api/internal/wechat/send")
-        self.assertEqual(args[1]["target"], "chat-001")
-        self.assertEqual(args[1]["content"], "hello")
-        self.assertFalse(args[1]["dry_run"])
-
-
-if __name__ == "__main__":
-    import unittest
-
-    unittest.main()

versions/V1R2C3.json

@@ -1,20 +0,0 @@
-{
-  "version": "V1R2C3",
-  "tag": "V1R2C3",
-  "previous_version": "V1R2C2",
-  "rollback_version": "V1R2C2",
-  "release_reason": "GPT Actions ClientResponseError compatibility recovery",
-  "validated_actions": [
-    "getRuntimeStatus",
-    "getBaseline",
-    "listVersions",
-    "listPatches",
-    "getDiff",
-    "createBranch",
-    "createPatch",
-    "commitFile"
-  ],
-  "secret_plaintext_written": false,
-  "created_at": "2026-07-08T00:00:00Z",
-  "author": "openclaw"
-}

versions/proposals/V1R1C5-gitops-platform-ui.proposed.json

@@ -1,51 +0,0 @@
-{
-  "version": "V1R1C5",
-  "status": "proposed",
-  "activation": "approval_required",
-  "base_version": "V1R1C4",
-  "rollback_target": "V1R1C4",
-  "purpose": "Promote AIOS GitOps Platform Control Plane with autonomous CI, self-healing validation, bounded production policy, event bus, daemon, owner notification, Web UI audit and Codex validation skills.",
-  "risk": "high",
-  "approval": {
-    "required": true,
-    "roles": ["owner", "admin"],
-    "reason": "Introduces autonomous orchestration and production-adjacent daemon. Main merge, tag creation and baseline activation remain gated."
-  },
-  "scope": {
-    "direct_changes": [
-      "overlays/user-control-center/portal/gitops-dashboard",
-      "services/aios-autonomous-daemon",
-      "config/codex",
-      "scripts",
-      "tests/acceptance",
-      "skills",
-      "docs/codex",
-      "docs/ops",
-      "deploy/systemd"
-    ],
-    "indirect_impact": [
-      "Portal GitOps UI visibility",
-      "Owner notification workflow",
-      "Codex validation workflow",
-      "Self-healing patch loop",
-      "Web UI audit trail"
-    ]
-  },
-  "non_goals": [
-    "No direct main push",
-    "No committed secrets",
-    "No destructive history deletion",
-    "No production rollback execution without approval or preapproved runbook"
-  ],
-  "validation": {
-    "acceptance_suite": "tests/acceptance/gitops-platform-ui.acceptance.json",
-    "script": "scripts/validate-gitops-platform-ui.sh",
-    "merge_gate": "scripts/autonomous-merge-gate.sh",
-    "gray_validation": "scripts/gray-validate-gitops-platform-ui.sh"
-  },
-  "owner_notification": {
-    "required_on_main_version_change": true,
-    "channels": ["wechat_or_wecom", "web_ui_audit"],
-    "webhook_secret_ref": "secret_ref://aios/notifications/owner-wechat-webhook"
-  }
-}