test: add bounded getDiff payload

active-runtime/app/aios_agent_task_api.py

@@ -1,315 +0,0 @@
-#!/usr/bin/env python3
-"""HTTP API for AIOS external-agent online task distribution.
-
-The service is intended to bind to loopback and be published through the
-existing TLS reverse proxy. Control operations use a server-managed control
-Bearer token. Agents receive individual Bearer tokens at registration; only
-token hashes are persisted.
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass
-import hmac
-import json
-import os
-from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from pathlib import Path
-import re
-from typing import Any, Mapping
-from urllib.parse import urlparse
-
-from aios_agent_task_protocol import TaskProtocolError, TaskStore
-
-
-MAX_BODY = 1024 * 1024
-TASK_ID_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:-]{2,179}$")
-
-
-@dataclass(frozen=True, slots=True)
-class APIConfig:
-    db_path: Path
-    control_token_path: Path
-    host: str = "127.0.0.1"
-    port: int = 18940
-    token_pepper: str = ""
-
-    @classmethod
-    def from_env(cls) -> "APIConfig":
-        return cls(
-            db_path=Path(os.getenv(
-                "AIOS_AGENT_TASK_DB",
-                "/var/lib/aios-agent-task/state.sqlite3",
-            )),
-            control_token_path=Path(os.getenv(
-                "AIOS_AGENT_TASK_CONTROL_TOKEN_FILE",
-                "/run/credentials/aios-agent-task-api.service/control_token",
-            )),
-            host=os.getenv("AIOS_AGENT_TASK_HOST", "127.0.0.1"),
-            port=int(os.getenv("AIOS_AGENT_TASK_PORT", "18940")),
-            token_pepper=os.getenv("AIOS_AGENT_TASK_TOKEN_PEPPER", ""),
-        )
-
-
-class AgentTaskApplication:
-    def __init__(self, config: APIConfig) -> None:
-        self.config = config
-        self.store = TaskStore(
-            config.db_path,
-            token_pepper=config.token_pepper,
-        )
-
-    def _control_token(self) -> str:
-        path = self.config.control_token_path
-        if path.is_symlink() or not path.is_file():
-            raise TaskProtocolError("CONTROL_CREDENTIAL_UNAVAILABLE", 503)
-        value = path.read_text(encoding="utf-8").strip()
-        if len(value) < 32:
-            raise TaskProtocolError("CONTROL_CREDENTIAL_INVALID", 503)
-        return value
-
-    @staticmethod
-    def _bearer(headers: Mapping[str, str]) -> str:
-        value = str(headers.get("Authorization") or "")
-        if not value.startswith("Bearer "):
-            return ""
-        return value[7:].strip()
-
-    def authenticate_control(self, headers: Mapping[str, str]) -> None:
-        supplied = self._bearer(headers)
-        expected = self._control_token()
-        if not supplied or not hmac.compare_digest(supplied, expected):
-            raise TaskProtocolError("UNAUTHORIZED", 401)
-
-    def authenticate_agent(self, headers: Mapping[str, str]) -> dict[str, Any]:
-        return self.store.authenticate_agent(self._bearer(headers))
-
-    def principal(self, headers: Mapping[str, str]) -> tuple[str, dict[str, Any] | None]:
-        supplied = self._bearer(headers)
-        if not supplied:
-            raise TaskProtocolError("UNAUTHORIZED", 401)
-        try:
-            expected = self._control_token()
-        except TaskProtocolError:
-            expected = ""
-        if expected and hmac.compare_digest(supplied, expected):
-            return "control", None
-        return "agent", self.store.authenticate_agent(supplied)
-
-    def health(self) -> dict[str, Any]:
-        return {
-            "status": "ok",
-            "schema": "aios.agent-task.v1",
-            "task_states": [
-                "QUEUED", "CLAIMED", "RUNNING", "VERIFYING",
-                "SUCCEEDED", "FAILED", "EXPIRED", "CANCELLED",
-            ],
-            "lease_recovery": True,
-            "atomic_claim": True,
-            "idempotent_result_submission": True,
-            "server_side_verification_required": True,
-            "plaintext_credentials_persisted": False,
-        }
-
-    def register_agent(self, headers: Mapping[str, str], body: Mapping[str, Any]) -> dict[str, Any]:
-        self.authenticate_control(headers)
-        return self.store.register_agent(
-            agent_id=str(body.get("agent_id") or ""),
-            agent_type=str(body.get("agent_type") or ""),
-            agent_version=str(body.get("agent_version") or ""),
-            capabilities=body.get("capabilities") or [],
-            metadata=body.get("metadata") if isinstance(body.get("metadata"), Mapping) else {},
-        )
-
-    def create_task(self, headers: Mapping[str, str], body: Mapping[str, Any]) -> dict[str, Any]:
-        self.authenticate_control(headers)
-        return self.store.create_task(
-            task_id=str(body.get("task_id") or "") or None,
-            goal=str(body.get("goal") or ""),
-            instructions=str(body.get("instructions") or ""),
-            success_criteria=body.get("success_criteria"),
-            required_capabilities=body.get("required_capabilities") or [],
-            constraints=body.get("constraints") if isinstance(body.get("constraints"), Mapping) else {},
-            metadata=body.get("metadata") if isinstance(body.get("metadata"), Mapping) else {},
-            deadline=str(body.get("deadline") or "") or None,
-            priority=body.get("priority", 0),
-            max_attempts=body.get("max_attempts", 3),
-            idempotency_key=str(body.get("idempotency_key") or ""),
-        )
-
-    def poll(self, headers: Mapping[str, str], body: Mapping[str, Any]) -> dict[str, Any]:
-        agent = self.authenticate_agent(headers)
-        tasks = self.store.poll_tasks(
-            agent_id=agent["agent_id"],
-            limit=int(body.get("limit", 20)),
-        )
-        return {"agent_id": agent["agent_id"], "tasks": tasks}
-
-    def claim(self, task_id: str, headers: Mapping[str, str], body: Mapping[str, Any]) -> dict[str, Any]:
-        agent = self.authenticate_agent(headers)
-        return self.store.claim_task(
-            task_id=task_id,
-            agent_id=agent["agent_id"],
-            lease_seconds=int(body.get("lease_seconds", 300)),
-        )
-
-    def heartbeat(self, task_id: str, headers: Mapping[str, str], body: Mapping[str, Any]) -> dict[str, Any]:
-        agent = self.authenticate_agent(headers)
-        return self.store.heartbeat(
-            task_id=task_id,
-            agent_id=agent["agent_id"],
-            lease_token=str(body.get("lease_token") or ""),
-            progress=body.get("progress") if isinstance(body.get("progress"), Mapping) else {},
-            lease_seconds=int(body.get("lease_seconds", 300)),
-        )
-
-    def result(self, task_id: str, headers: Mapping[str, str], body: Mapping[str, Any]) -> dict[str, Any]:
-        agent = self.authenticate_agent(headers)
-        result = body.get("result")
-        if not isinstance(result, Mapping):
-            raise TaskProtocolError("RESULT_INVALID", 400)
-        return self.store.submit_result(
-            task_id=task_id,
-            agent_id=agent["agent_id"],
-            lease_token=str(body.get("lease_token") or ""),
-            idempotency_key=str(body.get("idempotency_key") or ""),
-            result=result,
-        )
-
-    def verify(self, task_id: str, headers: Mapping[str, str], body: Mapping[str, Any]) -> dict[str, Any]:
-        self.authenticate_control(headers)
-        return self.store.verify_task(
-            task_id=task_id,
-            decision=str(body.get("decision") or ""),
-            verification=body.get("verification") if isinstance(body.get("verification"), Mapping) else {},
-        )
-
-    def cancel(self, task_id: str, headers: Mapping[str, str], body: Mapping[str, Any]) -> dict[str, Any]:
-        self.authenticate_control(headers)
-        return self.store.cancel_task(task_id=task_id, reason=str(body.get("reason") or ""))
-
-    def get_task(self, task_id: str, headers: Mapping[str, str]) -> dict[str, Any]:
-        kind, agent = self.principal(headers)
-        task = self.store.get_task(task_id)
-        if kind == "agent" and task.get("claimed_by") != agent["agent_id"]:
-            raise TaskProtocolError("FORBIDDEN", 403)
-        return task
-
-    def events(self, task_id: str, headers: Mapping[str, str]) -> dict[str, Any]:
-        self.authenticate_control(headers)
-        return {"task_id": task_id, "events": self.store.get_events(task_id)}
-
-
-class Handler(BaseHTTPRequestHandler):
-    app: AgentTaskApplication | None = None
-    server_version = "AIOSAgentTaskAPI/1"
-
-    def log_message(self, _format: str, *_args: Any) -> None:
-        return
-
-    def _headers(self) -> dict[str, str]:
-        return {key: value for key, value in self.headers.items()}
-
-    def _json(self, value: Any, status: int = 200) -> None:
-        payload = json.dumps(value, ensure_ascii=False, sort_keys=True).encode("utf-8")
-        self.send_response(status)
-        self.send_header("Content-Type", "application/json; charset=utf-8")
-        self.send_header("Cache-Control", "no-store")
-        self.send_header("Content-Length", str(len(payload)))
-        self.end_headers()
-        self.wfile.write(payload)
-
-    def _body(self) -> dict[str, Any]:
-        try:
-            size = int(self.headers.get("Content-Length", "0"))
-        except ValueError as exc:
-            raise TaskProtocolError("CONTENT_LENGTH_INVALID", 400) from exc
-        if size < 0 or size > MAX_BODY:
-            raise TaskProtocolError("REQUEST_TOO_LARGE", 413)
-        raw = self.rfile.read(size) if size else b"{}"
-        try:
-            value = json.loads(raw.decode("utf-8"))
-        except (UnicodeDecodeError, json.JSONDecodeError) as exc:
-            raise TaskProtocolError("JSON_INVALID", 400) from exc
-        if not isinstance(value, dict):
-            raise TaskProtocolError("JSON_OBJECT_REQUIRED", 400)
-        return value
-
-    @staticmethod
-    def _task_route(path: str) -> tuple[str, str | None]:
-        match = re.fullmatch(
-            r"/v1/tasks/([A-Za-z0-9][A-Za-z0-9._:-]{2,179})(?:/(claim|heartbeat|result|verify|cancel|events))?",
-            path,
-        )
-        if match:
-            return match.group(1), match.group(2)
-        return "", None
-
-    def _run(self, callback) -> None:
-        try:
-            callback()
-        except TaskProtocolError as exc:
-            self._json({"error": exc.code}, exc.http_status)
-        except Exception as exc:
-            self._json({"error": "INTERNAL_ERROR", "detail": type(exc).__name__}, 500)
-
-    def do_GET(self) -> None:
-        def action() -> None:
-            if self.app is None:
-                raise TaskProtocolError("SERVICE_UNAVAILABLE", 503)
-            path = urlparse(self.path).path.rstrip("/") or "/"
-            if path == "/health":
-                self._json(self.app.health())
-                return
-            task_id, suffix = self._task_route(path)
-            if task_id and suffix is None:
-                self._json(self.app.get_task(task_id, self._headers()))
-                return
-            if task_id and suffix == "events":
-                self._json(self.app.events(task_id, self._headers()))
-                return
-            self._json({"error": "NOT_FOUND"}, 404)
-        self._run(action)
-
-    def do_POST(self) -> None:
-        def action() -> None:
-            if self.app is None:
-                raise TaskProtocolError("SERVICE_UNAVAILABLE", 503)
-            path = urlparse(self.path).path.rstrip("/") or "/"
-            body = self._body()
-            if path == "/v1/agents/register":
-                self._json(self.app.register_agent(self._headers(), body), 201)
-                return
-            if path == "/v1/tasks":
-                self._json(self.app.create_task(self._headers(), body), 201)
-                return
-            if path == "/v1/tasks/poll":
-                self._json(self.app.poll(self._headers(), body))
-                return
-            task_id, suffix = self._task_route(path)
-            if not task_id:
-                self._json({"error": "NOT_FOUND"}, 404)
-                return
-            if suffix == "claim":
-                self._json(self.app.claim(task_id, self._headers(), body))
-            elif suffix == "heartbeat":
-                self._json(self.app.heartbeat(task_id, self._headers(), body))
-            elif suffix == "result":
-                self._json(self.app.result(task_id, self._headers(), body))
-            elif suffix == "verify":
-                self._json(self.app.verify(task_id, self._headers(), body))
-            elif suffix == "cancel":
-                self._json(self.app.cancel(task_id, self._headers(), body))
-            else:
-                self._json({"error": "NOT_FOUND"}, 404)
-        self._run(action)
-
-
-def serve(config: APIConfig | None = None) -> None:
-    config = config or APIConfig.from_env()
-    application = AgentTaskApplication(config)
-    Handler.app = application
-    ThreadingHTTPServer((config.host, config.port), Handler).serve_forever()
-
-
-if __name__ == "__main__":
-    serve()

active-runtime/app/aios_agent_task_protocol.py

@@ -1,829 +0,0 @@
-#!/usr/bin/env python3
-"""Durable online task protocol for external AIOS agents.
-
-The store is deliberately independent from Git/Gitea mutation. It provides a
-small durable state machine for publishing work, atomic claim/lease ownership,
-heartbeat, idempotent result submission, explicit server-side verification,
-lease recovery, and audit events.
-
-No plaintext agent credential or task lease token is persisted.
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass
-from datetime import datetime, timedelta, timezone
-import hashlib
-import hmac
-import json
-from pathlib import Path
-import secrets
-import sqlite3
-from typing import Any, Callable, Iterable, Mapping
-import uuid
-
-from aios_capability_contract import has_capabilities
-
-
-TERMINAL_STATES = frozenset({"SUCCEEDED", "FAILED", "EXPIRED", "CANCELLED"})
-ACTIVE_LEASE_STATES = frozenset({"CLAIMED", "RUNNING"})
-TASK_STATES = frozenset({
-    "QUEUED", "CLAIMED", "RUNNING", "VERIFYING",
-    "SUCCEEDED", "FAILED", "EXPIRED", "CANCELLED",
-})
-VERIFY_DECISIONS = frozenset({"SUCCEEDED", "NEEDS_REWORK", "FAILED"})
-
-
-class TaskProtocolError(RuntimeError):
-    def __init__(self, code: str, http_status: int = 409) -> None:
-        super().__init__(code)
-        self.code = code
-        self.http_status = http_status
-
-
-@dataclass(frozen=True, slots=True)
-class Principal:
-    kind: str
-    identifier: str
-
-
-def utcnow() -> datetime:
-    return datetime.now(timezone.utc)
-
-
-def iso(value: datetime) -> str:
-    return value.astimezone(timezone.utc).isoformat()
-
-
-def parse_time(value: str | None) -> datetime | None:
-    if not value:
-        return None
-    parsed = datetime.fromisoformat(value)
-    if parsed.tzinfo is None:
-        parsed = parsed.replace(tzinfo=timezone.utc)
-    return parsed.astimezone(timezone.utc)
-
-
-def canonical_json(value: Any) -> str:
-    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
-
-
-def digest_json(value: Any) -> str:
-    return hashlib.sha256(canonical_json(value).encode("utf-8")).hexdigest()
-
-
-def _string_list(value: Iterable[object] | None, field: str, *, max_items: int = 128) -> list[str]:
-    if value is None:
-        return []
-    if isinstance(value, (str, bytes)) or not isinstance(value, Iterable):
-        raise TaskProtocolError(field.upper() + "_INVALID", 400)
-    result: list[str] = []
-    for item in value:
-        text = str(item).strip()
-        if not text or len(text) > 160:
-            raise TaskProtocolError(field.upper() + "_INVALID", 400)
-        result.append(text)
-        if len(result) > max_items:
-            raise TaskProtocolError(field.upper() + "_TOO_LARGE", 400)
-    return sorted(set(result))
-
-
-def _json_object(value: object | None, field: str, *, max_bytes: int = 128 * 1024) -> dict[str, Any]:
-    if value is None:
-        return {}
-    if not isinstance(value, Mapping):
-        raise TaskProtocolError(field.upper() + "_INVALID", 400)
-    result = dict(value)
-    if len(canonical_json(result).encode("utf-8")) > max_bytes:
-        raise TaskProtocolError(field.upper() + "_TOO_LARGE", 413)
-    return result
-
-
-def _criteria(value: object | None) -> list[Any]:
-    if value is None:
-        return []
-    if isinstance(value, (str, bytes)) or not isinstance(value, list):
-        raise TaskProtocolError("SUCCESS_CRITERIA_INVALID", 400)
-    if len(value) > 128:
-        raise TaskProtocolError("SUCCESS_CRITERIA_TOO_LARGE", 413)
-    if len(canonical_json(value).encode("utf-8")) > 128 * 1024:
-        raise TaskProtocolError("SUCCESS_CRITERIA_TOO_LARGE", 413)
-    return list(value)
-
-
-class TaskStore:
-    """SQLite-backed durable task store.
-
-    SQLite BEGIN IMMEDIATE serializes claims so two agents cannot successfully
-    claim the same queued task. WAL mode allows concurrent readers.
-    """
-
-    def __init__(
-        self,
-        path: str | Path,
-        *,
-        now: Callable[[], datetime] = utcnow,
-        token_pepper: str = "",
-    ) -> None:
-        self.path = Path(path)
-        self.path.parent.mkdir(parents=True, exist_ok=True)
-        self.now = now
-        self.token_pepper = token_pepper
-        self._initialize()
-
-    def _connect(self) -> sqlite3.Connection:
-        connection = sqlite3.connect(self.path, timeout=10, isolation_level=None)
-        connection.row_factory = sqlite3.Row
-        connection.execute("PRAGMA foreign_keys=ON")
-        connection.execute("PRAGMA journal_mode=WAL")
-        connection.execute("PRAGMA synchronous=FULL")
-        connection.execute("PRAGMA busy_timeout=10000")
-        return connection
-
-    def _initialize(self) -> None:
-        with self._connect() as connection:
-            connection.executescript(
-                """
-                CREATE TABLE IF NOT EXISTS agents (
-                    agent_id TEXT PRIMARY KEY,
-                    agent_type TEXT NOT NULL,
-                    agent_version TEXT NOT NULL,
-                    capabilities_json TEXT NOT NULL,
-                    metadata_json TEXT NOT NULL,
-                    token_hash TEXT NOT NULL UNIQUE,
-                    status TEXT NOT NULL,
-                    created_at TEXT NOT NULL,
-                    last_seen_at TEXT NOT NULL
-                );
-
-                CREATE TABLE IF NOT EXISTS tasks (
-                    task_id TEXT PRIMARY KEY,
-                    goal TEXT NOT NULL,
-                    instructions TEXT NOT NULL,
-                    success_criteria_json TEXT NOT NULL,
-                    required_capabilities_json TEXT NOT NULL,
-                    constraints_json TEXT NOT NULL,
-                    metadata_json TEXT NOT NULL,
-                    deadline TEXT,
-                    priority INTEGER NOT NULL,
-                    max_attempts INTEGER NOT NULL,
-                    attempt INTEGER NOT NULL DEFAULT 0,
-                    status TEXT NOT NULL,
-                    claimed_by TEXT,
-                    lease_token_hash TEXT,
-                    lease_expires_at TEXT,
-                    result_json TEXT,
-                    result_digest TEXT,
-                    result_idempotency_key TEXT,
-                    verification_json TEXT,
-                    revision INTEGER NOT NULL DEFAULT 1,
-                    created_at TEXT NOT NULL,
-                    updated_at TEXT NOT NULL,
-                    FOREIGN KEY(claimed_by) REFERENCES agents(agent_id)
-                );
-
-                CREATE TABLE IF NOT EXISTS idempotency (
-                    scope TEXT NOT NULL,
-                    key TEXT NOT NULL,
-                    payload_digest TEXT NOT NULL,
-                    response_json TEXT NOT NULL,
-                    created_at TEXT NOT NULL,
-                    PRIMARY KEY(scope, key)
-                );
-
-                CREATE TABLE IF NOT EXISTS events (
-                    event_id INTEGER PRIMARY KEY AUTOINCREMENT,
-                    task_id TEXT,
-                    agent_id TEXT,
-                    event_type TEXT NOT NULL,
-                    payload_json TEXT NOT NULL,
-                    created_at TEXT NOT NULL
-                );
-
-                CREATE INDEX IF NOT EXISTS idx_tasks_queue
-                ON tasks(status, priority DESC, created_at);
-
-                CREATE INDEX IF NOT EXISTS idx_tasks_lease
-                ON tasks(status, lease_expires_at);
-
-                CREATE INDEX IF NOT EXISTS idx_events_task
-                ON events(task_id, event_id);
-                """
-            )
-
-    def _token_hash(self, token: str) -> str:
-        return hashlib.sha256((self.token_pepper + "\0" + token).encode("utf-8")).hexdigest()
-
-    @staticmethod
-    def _row_task(row: sqlite3.Row, *, include_result: bool = True) -> dict[str, Any]:
-        value: dict[str, Any] = {
-            "task_id": row["task_id"],
-            "goal": row["goal"],
-            "instructions": row["instructions"],
-            "success_criteria": json.loads(row["success_criteria_json"]),
-            "required_capabilities": json.loads(row["required_capabilities_json"]),
-            "constraints": json.loads(row["constraints_json"]),
-            "metadata": json.loads(row["metadata_json"]),
-            "deadline": row["deadline"],
-            "priority": row["priority"],
-            "max_attempts": row["max_attempts"],
-            "attempt": row["attempt"],
-            "status": row["status"],
-            "claimed_by": row["claimed_by"],
-            "lease_expires_at": row["lease_expires_at"],
-            "revision": row["revision"],
-            "created_at": row["created_at"],
-            "updated_at": row["updated_at"],
-        }
-        if include_result:
-            value["result"] = json.loads(row["result_json"]) if row["result_json"] else None
-            value["verification"] = (
-                json.loads(row["verification_json"]) if row["verification_json"] else None
-            )
-        return value
-
-    def _event(
-        self,
-        connection: sqlite3.Connection,
-        event_type: str,
-        *,
-        task_id: str | None = None,
-        agent_id: str | None = None,
-        payload: Mapping[str, Any] | None = None,
-    ) -> None:
-        connection.execute(
-            "INSERT INTO events(task_id,agent_id,event_type,payload_json,created_at)"
-            " VALUES(?,?,?,?,?)",
-            (task_id, agent_id, event_type, canonical_json(dict(payload or {})), iso(self.now())),
-        )
-
-    def register_agent(
-        self,
-        *,
-        agent_id: str,
-        agent_type: str,
-        agent_version: str,
-        capabilities: Iterable[object],
-        metadata: Mapping[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        agent_id = agent_id.strip()
-        agent_type = agent_type.strip()
-        agent_version = agent_version.strip()
-        if not agent_id or len(agent_id) > 160 or not agent_type or not agent_version:
-            raise TaskProtocolError("AGENT_IDENTITY_INVALID", 400)
-        caps = _string_list(capabilities, "capabilities")
-        meta = _json_object(metadata, "metadata")
-        token = "agt_" + secrets.token_urlsafe(32)
-        now = iso(self.now())
-        try:
-            with self._connect() as connection:
-                connection.execute("BEGIN IMMEDIATE")
-                connection.execute(
-                    "INSERT INTO agents(agent_id,agent_type,agent_version,capabilities_json,"
-                    "metadata_json,token_hash,status,created_at,last_seen_at)"
-                    " VALUES(?,?,?,?,?,?,?,?,?)",
-                    (
-                        agent_id,
-                        agent_type,
-                        agent_version,
-                        canonical_json(caps),
-                        canonical_json(meta),
-                        self._token_hash(token),
-                        "ACTIVE",
-                        now,
-                        now,
-                    ),
-                )
-                self._event(
-                    connection,
-                    "AGENT_REGISTERED",
-                    agent_id=agent_id,
-                    payload={"agent_type": agent_type, "agent_version": agent_version},
-                )
-                connection.commit()
-        except sqlite3.IntegrityError as exc:
-            raise TaskProtocolError("AGENT_ALREADY_EXISTS", 409) from exc
-        return {
-            "agent_id": agent_id,
-            "agent_type": agent_type,
-            "agent_version": agent_version,
-            "capabilities": caps,
-            "agent_token": token,
-            "credential_returned_once": True,
-        }
-
-    def authenticate_agent(self, token: str) -> dict[str, Any]:
-        if not token:
-            raise TaskProtocolError("UNAUTHORIZED", 401)
-        token_hash = self._token_hash(token)
-        with self._connect() as connection:
-            row = connection.execute(
-                "SELECT * FROM agents WHERE token_hash=? AND status='ACTIVE'",
-                (token_hash,),
-            ).fetchone()
-            if row is None:
-                raise TaskProtocolError("UNAUTHORIZED", 401)
-            connection.execute(
-                "UPDATE agents SET last_seen_at=? WHERE agent_id=?",
-                (iso(self.now()), row["agent_id"]),
-            )
-            return {
-                "agent_id": row["agent_id"],
-                "agent_type": row["agent_type"],
-                "agent_version": row["agent_version"],
-                "capabilities": json.loads(row["capabilities_json"]),
-                "metadata": json.loads(row["metadata_json"]),
-            }
-
-    def _idempotent_lookup(
-        self,
-        connection: sqlite3.Connection,
-        *,
-        scope: str,
-        key: str,
-        payload_digest: str,
-    ) -> dict[str, Any] | None:
-        row = connection.execute(
-            "SELECT payload_digest,response_json FROM idempotency WHERE scope=? AND key=?",
-            (scope, key),
-        ).fetchone()
-        if row is None:
-            return None
-        if not hmac.compare_digest(row["payload_digest"], payload_digest):
-            raise TaskProtocolError("IDEMPOTENCY_CONFLICT", 409)
-        return json.loads(row["response_json"])
-
-    def _idempotent_store(
-        self,
-        connection: sqlite3.Connection,
-        *,
-        scope: str,
-        key: str,
-        payload_digest: str,
-        response: Mapping[str, Any],
-    ) -> None:
-        connection.execute(
-            "INSERT INTO idempotency(scope,key,payload_digest,response_json,created_at)"
-            " VALUES(?,?,?,?,?)",
-            (scope, key, payload_digest, canonical_json(dict(response)), iso(self.now())),
-        )
-
-    def create_task(
-        self,
-        *,
-        task_id: str | None,
-        goal: str,
-        instructions: str,
-        success_criteria: object | None,
-        required_capabilities: Iterable[object] | None = None,
-        constraints: Mapping[str, Any] | None = None,
-        metadata: Mapping[str, Any] | None = None,
-        deadline: str | None = None,
-        priority: int = 0,
-        max_attempts: int = 3,
-        idempotency_key: str,
-    ) -> dict[str, Any]:
-        task_id = (task_id or ("task-" + uuid.uuid4().hex)).strip()
-        goal = goal.strip()
-        instructions = instructions.strip()
-        idempotency_key = idempotency_key.strip()
-        if not task_id or len(task_id) > 180 or not goal or not instructions:
-            raise TaskProtocolError("TASK_BINDING_INVALID", 400)
-        if not idempotency_key or len(idempotency_key) > 160:
-            raise TaskProtocolError("IDEMPOTENCY_KEY_INVALID", 400)
-        if not isinstance(priority, int) or isinstance(priority, bool) or not -100 <= priority <= 100:
-            raise TaskProtocolError("PRIORITY_INVALID", 400)
-        if not isinstance(max_attempts, int) or isinstance(max_attempts, bool) or not 1 <= max_attempts <= 20:
-            raise TaskProtocolError("MAX_ATTEMPTS_INVALID", 400)
-        parsed_deadline = parse_time(deadline)
-        if parsed_deadline and parsed_deadline <= self.now():
-            raise TaskProtocolError("DEADLINE_INVALID", 400)
-        criteria = _criteria(success_criteria)
-        required = _string_list(required_capabilities, "required_capabilities")
-        constraints_value = _json_object(constraints, "constraints")
-        metadata_value = _json_object(metadata, "metadata")
-        payload = {
-            "task_id": task_id,
-            "goal": goal,
-            "instructions": instructions,
-            "success_criteria": criteria,
-            "required_capabilities": required,
-            "constraints": constraints_value,
-            "metadata": metadata_value,
-            "deadline": iso(parsed_deadline) if parsed_deadline else None,
-            "priority": priority,
-            "max_attempts": max_attempts,
-        }
-        payload_digest = digest_json(payload)
-        now = iso(self.now())
-        with self._connect() as connection:
-            connection.execute("BEGIN IMMEDIATE")
-            replay = self._idempotent_lookup(
-                connection,
-                scope="create_task",
-                key=idempotency_key,
-                payload_digest=payload_digest,
-            )
-            if replay is not None:
-                connection.commit()
-                return {**replay, "idempotent": True}
-            try:
-                connection.execute(
-                    "INSERT INTO tasks(task_id,goal,instructions,success_criteria_json,"
-                    "required_capabilities_json,constraints_json,metadata_json,deadline,priority,"
-                    "max_attempts,attempt,status,revision,created_at,updated_at)"
-                    " VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)",
-                    (
-                        task_id,
-                        goal,
-                        instructions,
-                        canonical_json(criteria),
-                        canonical_json(required),
-                        canonical_json(constraints_value),
-                        canonical_json(metadata_value),
-                        payload["deadline"],
-                        priority,
-                        max_attempts,
-                        0,
-                        "QUEUED",
-                        1,
-                        now,
-                        now,
-                    ),
-                )
-            except sqlite3.IntegrityError as exc:
-                raise TaskProtocolError("TASK_ID_CONFLICT", 409) from exc
-            row = connection.execute("SELECT * FROM tasks WHERE task_id=?", (task_id,)).fetchone()
-            result = self._row_task(row)
-            self._idempotent_store(
-                connection,
-                scope="create_task",
-                key=idempotency_key,
-                payload_digest=payload_digest,
-                response=result,
-            )
-            self._event(connection, "TASK_CREATED", task_id=task_id, payload={"priority": priority})
-            connection.commit()
-            return result
-
-    def _expire_locked(self, connection: sqlite3.Connection) -> None:
-        now_dt = self.now()
-        now = iso(now_dt)
-        rows = connection.execute(
-            "SELECT * FROM tasks WHERE status IN ('QUEUED','CLAIMED','RUNNING')"
-        ).fetchall()
-        for row in rows:
-            deadline = parse_time(row["deadline"])
-            if deadline is not None and deadline <= now_dt:
-                connection.execute(
-                    "UPDATE tasks SET status='EXPIRED',lease_token_hash=NULL,"
-                    "lease_expires_at=NULL,revision=revision+1,updated_at=? WHERE task_id=?",
-                    (now, row["task_id"]),
-                )
-                self._event(connection, "TASK_EXPIRED", task_id=row["task_id"])
-                continue
-            if row["status"] in ACTIVE_LEASE_STATES:
-                lease_expires = parse_time(row["lease_expires_at"])
-                if lease_expires is not None and lease_expires <= now_dt:
-                    if row["attempt"] >= row["max_attempts"]:
-                        next_state = "FAILED"
-                    else:
-                        next_state = "QUEUED"
-                    if next_state == "FAILED":
-                        connection.execute(
-                            "UPDATE tasks SET status=?,lease_token_hash=NULL,"
-                            "lease_expires_at=NULL,revision=revision+1,updated_at=? WHERE task_id=?",
-                            (next_state, now, row["task_id"]),
-                        )
-                    else:
-                        connection.execute(
-                            "UPDATE tasks SET status=?,claimed_by=NULL,lease_token_hash=NULL,"
-                            "lease_expires_at=NULL,revision=revision+1,updated_at=? WHERE task_id=?",
-                            (next_state, now, row["task_id"]),
-                        )
-                    self._event(
-                        connection,
-                        "LEASE_EXPIRED",
-                        task_id=row["task_id"],
-                        agent_id=row["claimed_by"],
-                        payload={"next_state": next_state, "attempt": row["attempt"]},
-                    )
-
-    def expire_leases(self) -> int:
-        with self._connect() as connection:
-            connection.execute("BEGIN IMMEDIATE")
-            before = connection.total_changes
-            self._expire_locked(connection)
-            changed = connection.total_changes - before
-            connection.commit()
-            return changed
-
-    def poll_tasks(self, *, agent_id: str, limit: int = 20) -> list[dict[str, Any]]:
-        if not 1 <= int(limit) <= 100:
-            raise TaskProtocolError("LIMIT_INVALID", 400)
-        with self._connect() as connection:
-            connection.execute("BEGIN IMMEDIATE")
-            self._expire_locked(connection)
-            agent = connection.execute(
-                "SELECT capabilities_json FROM agents WHERE agent_id=? AND status='ACTIVE'",
-                (agent_id,),
-            ).fetchone()
-            if agent is None:
-                raise TaskProtocolError("AGENT_NOT_FOUND", 404)
-            capabilities = json.loads(agent["capabilities_json"])
-            rows = connection.execute(
-                "SELECT * FROM tasks WHERE status='QUEUED' ORDER BY priority DESC,created_at ASC"
-            ).fetchall()
-            result = []
-            for row in rows:
-                required = json.loads(row["required_capabilities_json"])
-                if has_capabilities(capabilities, required):
-                    result.append(self._row_task(row, include_result=False))
-                    if len(result) >= int(limit):
-                        break
-            connection.commit()
-            return result
-
-    def _agent_capabilities(self, connection: sqlite3.Connection, agent_id: str) -> set[str]:
-        row = connection.execute(
-            "SELECT capabilities_json FROM agents WHERE agent_id=? AND status='ACTIVE'",
-            (agent_id,),
-        ).fetchone()
-        if row is None:
-            raise TaskProtocolError("AGENT_NOT_FOUND", 404)
-        return set(json.loads(row["capabilities_json"]))
-
-    def claim_task(
-        self,
-        *,
-        task_id: str,
-        agent_id: str,
-        lease_seconds: int = 300,
-    ) -> dict[str, Any]:
-        if not isinstance(lease_seconds, int) or isinstance(lease_seconds, bool) or not 30 <= lease_seconds <= 3600:
-            raise TaskProtocolError("LEASE_SECONDS_INVALID", 400)
-        lease_token = "lease_" + secrets.token_urlsafe(32)
-        with self._connect() as connection:
-            connection.execute("BEGIN IMMEDIATE")
-            self._expire_locked(connection)
-            row = connection.execute("SELECT * FROM tasks WHERE task_id=?", (task_id,)).fetchone()
-            if row is None:
-                raise TaskProtocolError("TASK_NOT_FOUND", 404)
-            if row["status"] != "QUEUED":
-                raise TaskProtocolError("TASK_NOT_CLAIMABLE", 409)
-            capabilities = self._agent_capabilities(connection, agent_id)
-            required = json.loads(row["required_capabilities_json"])
-            if not has_capabilities(capabilities, required):
-                raise TaskProtocolError("AGENT_CAPABILITY_MISMATCH", 403)
-            attempt = int(row["attempt"]) + 1
-            if attempt > int(row["max_attempts"]):
-                raise TaskProtocolError("TASK_ATTEMPTS_EXHAUSTED", 409)
-            expires = self.now() + timedelta(seconds=lease_seconds)
-            now = iso(self.now())
-            updated = connection.execute(
-                "UPDATE tasks SET status='CLAIMED',claimed_by=?,lease_token_hash=?,"
-                "lease_expires_at=?,attempt=?,revision=revision+1,updated_at=? "
-                "WHERE task_id=? AND status='QUEUED'",
-                (
-                    agent_id,
-                    self._token_hash(lease_token),
-                    iso(expires),
-                    attempt,
-                    now,
-                    task_id,
-                ),
-            )
-            if updated.rowcount != 1:
-                raise TaskProtocolError("TASK_CLAIM_CONFLICT", 409)
-            self._event(
-                connection,
-                "TASK_CLAIMED",
-                task_id=task_id,
-                agent_id=agent_id,
-                payload={"attempt": attempt, "lease_expires_at": iso(expires)},
-            )
-            row = connection.execute("SELECT * FROM tasks WHERE task_id=?", (task_id,)).fetchone()
-            connection.commit()
-            return {
-                **self._row_task(row, include_result=False),
-                "lease_token": lease_token,
-                "lease_token_returned_once": True,
-            }
-
-    def _validate_lease(
-        self,
-        connection: sqlite3.Connection,
-        *,
-        task_id: str,
-        agent_id: str,
-        lease_token: str,
-        allowed_states: frozenset[str] = ACTIVE_LEASE_STATES,
-    ) -> sqlite3.Row:
-        self._expire_locked(connection)
-        row = connection.execute("SELECT * FROM tasks WHERE task_id=?", (task_id,)).fetchone()
-        if row is None:
-            raise TaskProtocolError("TASK_NOT_FOUND", 404)
-        if row["status"] not in allowed_states:
-            raise TaskProtocolError("TASK_LEASE_NOT_ACTIVE", 409)
-        if row["claimed_by"] != agent_id:
-            raise TaskProtocolError("TASK_LEASE_OWNER_MISMATCH", 403)
-        if not row["lease_token_hash"] or not hmac.compare_digest(
-            row["lease_token_hash"], self._token_hash(lease_token)
-        ):
-            raise TaskProtocolError("TASK_LEASE_TOKEN_INVALID", 403)
-        expires = parse_time(row["lease_expires_at"])
-        if expires is None or expires <= self.now():
-            raise TaskProtocolError("TASK_LEASE_EXPIRED", 409)
-        return row
-
-    def heartbeat(
-        self,
-        *,
-        task_id: str,
-        agent_id: str,
-        lease_token: str,
-        progress: Mapping[str, Any] | None = None,
-        lease_seconds: int = 300,
-    ) -> dict[str, Any]:
-        if not 30 <= int(lease_seconds) <= 3600:
-            raise TaskProtocolError("LEASE_SECONDS_INVALID", 400)
-        progress_value = _json_object(progress, "progress", max_bytes=64 * 1024)
-        with self._connect() as connection:
-            connection.execute("BEGIN IMMEDIATE")
-            self._validate_lease(
-                connection,
-                task_id=task_id,
-                agent_id=agent_id,
-                lease_token=lease_token,
-            )
-            expires = self.now() + timedelta(seconds=int(lease_seconds))
-            now = iso(self.now())
-            connection.execute(
-                "UPDATE tasks SET status='RUNNING',lease_expires_at=?,revision=revision+1,"
-                "updated_at=? WHERE task_id=?",
-                (iso(expires), now, task_id),
-            )
-            self._event(
-                connection,
-                "TASK_HEARTBEAT",
-                task_id=task_id,
-                agent_id=agent_id,
-                payload={"progress": progress_value, "lease_expires_at": iso(expires)},
-            )
-            row = connection.execute("SELECT * FROM tasks WHERE task_id=?", (task_id,)).fetchone()
-            connection.commit()
-            return self._row_task(row, include_result=False)
-
-    def submit_result(
-        self,
-        *,
-        task_id: str,
-        agent_id: str,
-        lease_token: str,
-        idempotency_key: str,
-        result: Mapping[str, Any],
-    ) -> dict[str, Any]:
-        idempotency_key = idempotency_key.strip()
-        if not idempotency_key or len(idempotency_key) > 160:
-            raise TaskProtocolError("IDEMPOTENCY_KEY_INVALID", 400)
-        result_value = _json_object(result, "result", max_bytes=1024 * 1024)
-        result_digest = digest_json(result_value)
-        with self._connect() as connection:
-            connection.execute("BEGIN IMMEDIATE")
-            row = connection.execute("SELECT * FROM tasks WHERE task_id=?", (task_id,)).fetchone()
-            if row is None:
-                raise TaskProtocolError("TASK_NOT_FOUND", 404)
-            if row["result_idempotency_key"] == idempotency_key:
-                if not row["result_digest"] or not hmac.compare_digest(row["result_digest"], result_digest):
-                    raise TaskProtocolError("IDEMPOTENCY_CONFLICT", 409)
-                connection.commit()
-                return {**self._row_task(row), "idempotent": True}
-            self._validate_lease(
-                connection,
-                task_id=task_id,
-                agent_id=agent_id,
-                lease_token=lease_token,
-            )
-            now = iso(self.now())
-            connection.execute(
-                "UPDATE tasks SET status='VERIFYING',result_json=?,result_digest=?,"
-                "result_idempotency_key=?,lease_token_hash=NULL,lease_expires_at=NULL,"
-                "revision=revision+1,updated_at=? WHERE task_id=?",
-                (
-                    canonical_json(result_value),
-                    result_digest,
-                    idempotency_key,
-                    now,
-                    task_id,
-                ),
-            )
-            self._event(
-                connection,
-                "RESULT_SUBMITTED",
-                task_id=task_id,
-                agent_id=agent_id,
-                payload={"result_digest": result_digest, "idempotency_key": idempotency_key},
-            )
-            row = connection.execute("SELECT * FROM tasks WHERE task_id=?", (task_id,)).fetchone()
-            connection.commit()
-            return self._row_task(row)
-
-    def verify_task(
-        self,
-        *,
-        task_id: str,
-        decision: str,
-        verification: Mapping[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        decision = decision.strip().upper()
-        if decision not in VERIFY_DECISIONS:
-            raise TaskProtocolError("VERIFICATION_DECISION_INVALID", 400)
-        verification_value = _json_object(verification, "verification")
-        verification_value = {"decision": decision, **verification_value}
-        with self._connect() as connection:
-            connection.execute("BEGIN IMMEDIATE")
-            row = connection.execute("SELECT * FROM tasks WHERE task_id=?", (task_id,)).fetchone()
-            if row is None:
-                raise TaskProtocolError("TASK_NOT_FOUND", 404)
-            if row["status"] != "VERIFYING":
-                raise TaskProtocolError("TASK_NOT_VERIFYING", 409)
-            if decision == "SUCCEEDED":
-                next_state = "SUCCEEDED"
-            elif decision == "FAILED":
-                next_state = "FAILED"
-            elif int(row["attempt"]) >= int(row["max_attempts"]):
-                next_state = "FAILED"
-                verification_value["reason"] = verification_value.get(
-                    "reason", "MAX_ATTEMPTS_EXHAUSTED"
-                )
-            else:
-                next_state = "QUEUED"
-            now = iso(self.now())
-            if next_state in {"SUCCEEDED", "FAILED"}:
-                connection.execute(
-                    "UPDATE tasks SET status=?,lease_token_hash=NULL,"
-                    "lease_expires_at=NULL,verification_json=?,revision=revision+1,updated_at=? "
-                    "WHERE task_id=?",
-                    (next_state, canonical_json(verification_value), now, task_id),
-                )
-            else:
-                connection.execute(
-                    "UPDATE tasks SET status=?,claimed_by=NULL,lease_token_hash=NULL,"
-                    "lease_expires_at=NULL,verification_json=?,revision=revision+1,updated_at=? "
-                    "WHERE task_id=?",
-                    (next_state, canonical_json(verification_value), now, task_id),
-                )
-            self._event(
-                connection,
-                "TASK_VERIFIED",
-                task_id=task_id,
-                agent_id=row["claimed_by"],
-                payload={"decision": decision, "next_state": next_state},
-            )
-            updated = connection.execute("SELECT * FROM tasks WHERE task_id=?", (task_id,)).fetchone()
-            connection.commit()
-            return self._row_task(updated)
-
-    def cancel_task(self, *, task_id: str, reason: str = "") -> dict[str, Any]:
-        with self._connect() as connection:
-            connection.execute("BEGIN IMMEDIATE")
-            row = connection.execute("SELECT * FROM tasks WHERE task_id=?", (task_id,)).fetchone()
-            if row is None:
-                raise TaskProtocolError("TASK_NOT_FOUND", 404)
-            if row["status"] in TERMINAL_STATES:
-                connection.commit()
-                return self._row_task(row)
-            connection.execute(
-                "UPDATE tasks SET status='CANCELLED',lease_token_hash=NULL,"
-                "lease_expires_at=NULL,revision=revision+1,updated_at=? WHERE task_id=?",
-                (iso(self.now()), task_id),
-            )
-            self._event(connection, "TASK_CANCELLED", task_id=task_id, payload={"reason": reason})
-            updated = connection.execute("SELECT * FROM tasks WHERE task_id=?", (task_id,)).fetchone()
-            connection.commit()
-            return self._row_task(updated)
-
-    def get_task(self, task_id: str) -> dict[str, Any]:
-        self.expire_leases()
-        with self._connect() as connection:
-            row = connection.execute("SELECT * FROM tasks WHERE task_id=?", (task_id,)).fetchone()
-            if row is None:
-                raise TaskProtocolError("TASK_NOT_FOUND", 404)
-            return self._row_task(row)
-
-    def get_events(self, task_id: str, *, limit: int = 200) -> list[dict[str, Any]]:
-        with self._connect() as connection:
-            rows = connection.execute(
-                "SELECT * FROM events WHERE task_id=? ORDER BY event_id DESC LIMIT ?",
-                (task_id, max(1, min(int(limit), 1000))),
-            ).fetchall()
-            return [
-                {
-                    "event_id": row["event_id"],
-                    "task_id": row["task_id"],
-                    "agent_id": row["agent_id"],
-                    "event_type": row["event_type"],
-                    "payload": json.loads(row["payload_json"]),
-                    "created_at": row["created_at"],
-                }
-                for row in reversed(rows)
-            ]

active-runtime/app/aios_branch_binding.py

@@ -1,20 +0,0 @@
-"""Shared exact branch-name validation for governed Git operations."""
-
-from __future__ import annotations
-
-import re
-
-
-# Keep the existing governed branch envelope. Validation rejects invalid input;
-# it never shortens or normalizes a caller's branch string.
-BRANCH_RE = re.compile(r"^agent/[A-Za-z0-9][A-Za-z0-9._/-]{2,179}$")
-
-
-def is_valid_governed_branch(value: object) -> bool:
-    return isinstance(value, str) and BRANCH_RE.fullmatch(value) is not None
-
-
-def require_exact_governed_branch(value: object, *, field: str = "target_branch") -> str:
-    if not is_valid_governed_branch(value):
-        raise ValueError(f"{field}_invalid")
-    return value

active-runtime/app/aios_capability_contract.py

@@ -1,159 +0,0 @@
-"""Canonical fail-closed capability semantics for task eligibility."""
-
-from __future__ import annotations
-
-from collections.abc import Iterable
-
-
-_TASK_ALIASES: dict[str, frozenset[str]] = {
-    "repository_read": frozenset({"repo.read"}),
-    "git.read": frozenset({"repo.read"}),
-    "repo.read": frozenset({"repo.read"}),
-    "test_execution": frozenset({"test.execute"}),
-    "git.test": frozenset({"test.execute"}),
-    "test.execute": frozenset({"test.execute"}),
-    "governed_git_write": frozenset({"governed.git.write.branch", "governed.git.write.file"}),
-    "governed.git.write": frozenset({"governed.git.write.branch", "governed.git.write.file"}),
-    "governed.write.branch": frozenset({"governed.git.write.branch"}),
-    "governed.write.file": frozenset({"governed.git.write.file"}),
-    "shell": frozenset({"runtime.shell"}),
-    "git": frozenset({"runtime.git"}),
-    "python": frozenset({"runtime.python"}),
-    "code.read": frozenset({"legacy.code.read"}),
-    "code.review": frozenset({"legacy.code.review"}),
-    "code.write": frozenset({"legacy.code.write"}),
-    "code.write.patch": frozenset({"legacy.code.write.patch"}),
-    "test.python": frozenset({"legacy.test.python"}),
-    "test.shell.allowlisted": frozenset({"legacy.test.shell.allowlisted"}),
-    "git.commit": frozenset({"legacy.git.commit"}),
-    "git.diff.read": frozenset({"legacy.git.diff.read"}),
-    "git.force_push": frozenset({"legacy.git.force_push"}),
-    "deploy.production": frozenset({"legacy.deploy.production"}),
-    "secret.transform": frozenset({"legacy.secret.transform"}),
-    "secure_file_transformer": frozenset({"legacy.secure_file_transformer"}),
-    "runtime.shadow": frozenset({"legacy.runtime.shadow"}),
-    "review.security": frozenset({"legacy.review.security"}),
-    "review.api-contract": frozenset({"legacy.review.api-contract"}),
-    "gpu.train": frozenset({"legacy.gpu.train"}),
-}
-
-_WORKER_ALIASES: dict[str, frozenset[str]] = {
-    "git.read": frozenset({"repo.read"}),
-    "repo.read": frozenset({"repo.read"}),
-    "repository_read": frozenset({"repo.read"}),
-    "git.test": frozenset({"test.execute"}),
-    "test.execute": frozenset({"test.execute"}),
-    "test_execution": frozenset({"test.execute"}),
-    "governed.write.branch": frozenset({"governed.git.write.branch"}),
-    "governed.git.write.branch": frozenset({"governed.git.write.branch"}),
-    "governed.write.file": frozenset({"governed.git.write.file"}),
-    "governed.git.write.file": frozenset({"governed.git.write.file"}),
-    "shell": frozenset({"runtime.shell"}),
-    "git": frozenset({"runtime.git"}),
-    "python": frozenset({"runtime.python"}),
-    "code.read": frozenset({"legacy.code.read"}),
-    "code.review": frozenset({"legacy.code.review"}),
-    "code.write": frozenset({"legacy.code.write"}),
-    "code.write.patch": frozenset({"legacy.code.write.patch"}),
-    "test.python": frozenset({"legacy.test.python"}),
-    "test.shell.allowlisted": frozenset({"legacy.test.shell.allowlisted"}),
-    "git.commit": frozenset({"legacy.git.commit"}),
-    "git.diff.read": frozenset({"legacy.git.diff.read"}),
-    "git.force_push": frozenset({"legacy.git.force_push"}),
-    "deploy.production": frozenset({"legacy.deploy.production"}),
-    "secret.transform": frozenset({"legacy.secret.transform"}),
-    "secure_file_transformer": frozenset({"legacy.secure_file_transformer"}),
-    "runtime.shadow": frozenset({"legacy.runtime.shadow"}),
-    "review.security": frozenset({"legacy.review.security"}),
-    "review.api-contract": frozenset({"legacy.review.api-contract"}),
-    "gpu.train": frozenset({"legacy.gpu.train"}),
-}
-
-_UNKNOWN_PREFIX = "exact:"
-
-
-def _clean(value: object) -> str:
-    if not isinstance(value, str):
-        raise ValueError("capability must be a string")
-    text = value.strip().lower()
-    if not text:
-        raise ValueError("capability must not be empty")
-    return text
-
-
-def normalize_required_capabilities(values: Iterable[object]) -> frozenset[str]:
-    """Map task-facing names to one semantic vocabulary.
-
-    Unknown names remain explicit exact requirements. They are never treated
-    as wildcards or granted by a failed normalization.
-    """
-
-    result: set[str] = set()
-    for value in values:
-        text = _clean(value)
-        if "*" in text:
-            result.add(_UNKNOWN_PREFIX + text)
-        else:
-            result.update(_TASK_ALIASES.get(text, frozenset({_UNKNOWN_PREFIX + text})))
-    return frozenset(result)
-
-
-def normalize_worker_capabilities(values: Iterable[object]) -> frozenset[str]:
-    """Map registered worker names to effective semantic capabilities."""
-
-    result: set[str] = set()
-    for value in values:
-        text = _clean(value)
-        if "*" in text:
-            continue
-        mapped = _WORKER_ALIASES.get(text)
-        if mapped is not None:
-            result.update(mapped)
-    if {
-        "governed.git.write.branch",
-        "governed.git.write.file",
-    }.issubset(result):
-        result.add("governed.git.write")
-    return frozenset(result)
-
-
-def has_capabilities(
-    worker_capabilities: Iterable[object],
-    required_capabilities: Iterable[object],
-) -> bool:
-    """Return the single eligibility decision used by poll and claim."""
-
-    required = normalize_required_capabilities(required_capabilities)
-    effective = normalize_worker_capabilities(worker_capabilities)
-    if any(value.startswith(_UNKNOWN_PREFIX) for value in required):
-        return False
-    return required.issubset(effective)
-
-
-def required_capabilities_subset(
-    granted_requirements: Iterable[object],
-    required_requirements: Iterable[object],
-) -> bool:
-    """Check semantic capability containment for delegation constraints."""
-    granted = normalize_required_capabilities(granted_requirements)
-    required = normalize_required_capabilities(required_requirements)
-    if any(value.startswith(_UNKNOWN_PREFIX) for value in granted | required):
-        return False
-    return required.issubset(granted)
-
-
-def normalized_capability_matrix(
-    worker_capabilities: Iterable[object],
-    required_capabilities: Iterable[object],
-) -> dict[str, object]:
-    """Expose non-secret decision evidence for tests and diagnostics."""
-
-    worker_values = tuple(worker_capabilities)
-    required_values = tuple(required_capabilities)
-    worker = normalize_worker_capabilities(worker_values)
-    required = normalize_required_capabilities(required_values)
-    return {
-        "worker_effective": sorted(worker),
-        "task_required": sorted(required),
-        "eligible": has_capabilities(worker_values, required_values),
-    }

active-runtime/app/aios_chatgpt_actions_api.py

@@ -22,6 +22,7 @@ from gitea_tag_publication import (
     TagPublisher,
     redact,
     validate_version,
+    validate_gitea_api_url,
 )
 from orchestrator.action_monitor import ActionMonitor
 from silent_release_hardening import (
@@ -308,8 +309,7 @@ def resolve_commit_oid(value: str | None, field: str = 'target_oid') -> str:
         raise ValueError(f'{field} does not resolve to the exact approved commit') from exc
 
 def existing_tag_target(tag: str) -> str | None:
-    if not re.fullmatch(r'V\d+R\d+C\d+(?:-[A-Za-z0-9_.-]+)?$', str(tag or '')):
-        raise ValueError('invalid release version')
+    validate_version(tag)
     try:
         result = run_authoritative_git(
             ['rev-parse', '--verify', f'refs/tags/{tag}^{{commit}}'],
@@ -510,7 +510,15 @@ class H(BaseHTTPRequestHandler):
                     return self.sendj({'error':redact(exc)},413)
                 except (AuthoritativeGitError, RuntimeError) as exc:
                     return self.sendj({'error':redact(exc)},503)
-                return self.sendj({'from':frm,'to':to,'diff':diff})
+                payload = {'from': frm, 'to': to, 'diff': diff}
+                payload.update({
+                    key: diff[key]
+                    for key in (
+                        'from_oid', 'to_oid', 'changed_paths', 'stats',
+                        'total_size_bytes', 'truncated', 'patch_limit_bytes',
+                    )
+                })
+                return self.sendj(payload)
             if path in ('/api/patch','/api/patches','/api/branches','/patch'):
                 snapshot = repository_snapshot(
                     git_dir=AUTHORITATIVE_GIT_DIR,
@@ -773,7 +781,10 @@ class H(BaseHTTPRequestHandler):
         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)
+        try:
+            validate_version(ver)
+        except ValueError:
+            return self.sendj({'error':'version must match VxRxCx'},400)
         if not data.get('target_oid') or not data.get('evidence_closure_oid') or not data.get('approval_plan_id'):
             return self.sendj({
                 'error':'production_tag_evidence_required',
@@ -947,6 +958,7 @@ def api_spec():
     return {'version':'V1R1C0-chatgpt-actions','openapi':'/api/openapi.yaml','read':['GET /api/base','GET /api/ver','GET /api/diff','GET /api/patch','GET /api/model','GET /api/run','GET /getReleaseCandidate','GET /getApprovalEnvelope','GET /getReleaseSaga','GET /admin/ai-evolution'],'write':['POST /api/branch','POST /api/file','POST /api/commit','POST /api/patch','POST /api/tag','POST /api/rollback','POST /api/model','PUT /api/model-priority','POST /api/nl','POST /createReleaseCandidate','POST /submitOwnerApproval','POST /startDeployment'],'policy':{'bearer_required_for_write':True,'direct_main_push':False,'delete_tag':False,'owner_approval_required_for_v_level':True,'api_keys_in_git':False,'git_secret_field':'secret_ref','online_git_sync':True,'silent_release_execution_enabled':SILENT_RELEASE_EXECUTION_ENABLED,'silent_release_shadow_default':True}}
 
 def main():
+    validate_gitea_api_url(os.getenv('AIOS_GITOPS_GITEA_API_URL', ''))
     print(f'AIOS ChatGPT GitOps adapter listening on {HOST}:{PORT}')
     ThreadingHTTPServer((HOST,PORT), H).serve_forever()
 if __name__ == '__main__': main()

active-runtime/app/aios_chatgpt_bridge_v2.py

@@ -46,6 +46,75 @@ OPERATION_REQUIRED_FIELDS = {
     "getControlPlaneSnapshot": (),
 }
 
+_OPERATION_PATHS = {
+    "createGovernedTask": "/v2/governed-task",
+    "acquireWriterLease": "/v2/writer-lease",
+    "commitFileGoverned": "/v2/commit-file",
+    "commitFilesGoverned": "/v2/commit-files",
+    "getGitOpsJob": "/v2/job",
+    "resumeGitOpsJob": "/v2/job/resume",
+    "reconcileGitOpsJob": "/v2/job/reconcile",
+    "getTagPublicationStatus": "/v2/tag/status",
+    "getReleaseConsistency": "/v2/release/consistency",
+    "runReleaseAcceptance": "/v2/release/acceptance",
+}
+
+
+def operation_contracts() -> dict[str, dict[str, object]]:
+    """Return the runtime contract consumed by adapters and schema tooling."""
+    return {
+        operation: {
+            "method": "POST",
+            "path": _OPERATION_PATHS.get(operation),
+            "required_fields": list(fields),
+        }
+        for operation, fields in OPERATION_REQUIRED_FIELDS.items()
+    }
+
+
+def render_openapi_contract_fragment() -> str:
+    required = "\n".join(
+        f"                - {field}"
+        for field in OPERATION_REQUIRED_FIELDS["commitFilesGoverned"]
+    )
+    return (
+        "  /v2/commit-files:\n"
+        "    post:\n"
+        "      operationId: commitFilesGoverned\n"
+        "      summary: Submit one atomic governed commit containing multiple files\n"
+        "      requestBody:\n"
+        "        required: true\n"
+        "        content:\n"
+        "          application/json:\n"
+        "            schema:\n"
+        "              type: object\n"
+        "              additionalProperties: false\n"
+        "              required:\n"
+        f"{required}\n"
+        "              properties:\n"
+        "                task_id: {type: string}\n"
+        "                repository: {type: string, example: aios/aios}\n"
+        "                expected_branch_oid: {type: string, pattern: '^[0-9a-f]{40}$'}\n"
+        "                target_branch: {type: string, pattern: '^agent/[A-Za-z0-9._/-]+$'}\n"
+        "                generation: {type: integer, minimum: 1}\n"
+        "                idempotency_key: {type: string}\n"
+        "                files:\n"
+        "                  type: array\n"
+        "                  minItems: 1\n"
+        "                  items:\n"
+        "                    type: object\n"
+        "                    additionalProperties: false\n"
+        "                    required: [path, content_base64]\n"
+        "                    properties:\n"
+        "                      path: {type: string, minLength: 1, maxLength: 512}\n"
+        "                      content_base64: {type: string}\n"
+        "                message: {type: string, minLength: 1, maxLength: 200}\n"
+        "      responses:\n"
+        "        '200': {description: Governed commit job and verified branch result}\n"
+        "        '400': {description: Contract or policy rejection}\n"
+        "        '409': {description: Branch CAS or idempotency conflict}\n"
+    )
+
 
 class RuntimeDriftError(RuntimeError):
     pass
@@ -122,6 +191,7 @@ class BridgeV2Adapter:
             "legacy_writes_enabled": False,
             "governed_writes_enabled": True,
             "operations": list(BRIDGE_OPERATIONS),
+            "operation_contracts": operation_contracts(),
             "force_push": False,
             "main_write": False,
             "tag_write": False,

active-runtime/app/aios_chatgpt_bridge_v2_server.py

@@ -13,12 +13,12 @@ import sqlite3
 from typing import Any, Mapping
 
 from aios_authority_git_executor import AuthorityGitExecutor
-from aios_branch_binding import require_exact_governed_branch
 from aios_chatgpt_bridge_v2 import BridgeV2Adapter, BridgeV2Error, OPERATION_REQUIRED_FIELDS
+from gitea_tag_publication import validate_gitea_api_url
 from aios_continuation_executor import AuthorityGitAdapter, ContinuationCommit, ContinuationExecutor, ContinuationPermissions, ContinuationRuntimeBinding, DetachedGitWorkspace, GiteaContinuationRemote, ServerSideCredentialProjection
 from aios_continuation_lease import WriterLeaseRequestV2
 from aios_control_plane_snapshot import build_control_plane_snapshot
-from aios_gitops_job_controller import GitOpsJobController, JobStore
+from aios_gitops_job_controller import GitOpsJobController, JobState, JobStore, _RECOVERABLE
 from aios_governed_task_bootstrap import BootstrapError, GovernedTaskBootstrap
 from governed_production_release import build_executor_config
 
@@ -53,7 +53,7 @@ class RuntimeConfig:
     ssh_key_path: Path
     remote_name: str = "gitea-http"
     repository: str = "aios/aios"
-    api_base: str = "https://g.cnnetmkt.top/git/api/v1"
+    api_base: str = ""
     v2_task_id: str = "TASK-P0-CHATGPT-BRIDGE-V2-CONTROL-PLANE-CONVERGENCE-20260809"
     v2_branch: str = "agent/p0-chatgpt-bridge-v2-control-plane-convergence-20260809"
     target_version: str = "V2R2C1"
@@ -115,13 +115,8 @@ class GovernedRuntime:
     def _runtime(self, request: Mapping[str, Any]) -> tuple[Any, GitOpsJobController, ContinuationExecutor]:
         key = (str(request["task_id"]), int(request["generation"]))
         if key in self.runtimes: return self.runtimes[key]
-        requested_target_branch = request.get("target_branch")
-        if not isinstance(requested_target_branch, str):
-            raise RuntimeError("LEASE_BINDING_CONFLICT")
-        lease = WriterLeaseRequestV2(task_id=str(request["task_id"]), repository=str(request["repository"]), branch_mode=str(request.get("branch_mode", "CONTINUE_EXISTING")), base_oid=str(request["base_oid"]), expected_branch_oid=str(request["expected_branch_oid"]), target_branch=requested_target_branch, generation=int(request["generation"]), lease_seconds=int(request.get("lease_seconds", 900)))
+        lease = WriterLeaseRequestV2(task_id=str(request["task_id"]), repository=str(request["repository"]), branch_mode=str(request.get("branch_mode", "CONTINUE_EXISTING")), base_oid=str(request["base_oid"]), expected_branch_oid=str(request["expected_branch_oid"]), target_branch=str(request["target_branch"]), generation=int(request["generation"]), lease_seconds=int(request.get("lease_seconds", 900)))
         lease.validate(AuthorityGitAdapter(self.authority))
-        if lease.target_branch != requested_target_branch:
-            raise RuntimeError("LEASE_BINDING_CONFLICT")
         worktree_path = self.config.state_root / "worktrees" / _safe(lease.task_id)
         if worktree_path.exists():
             workspace = DetachedGitWorkspace(worktree_path)
@@ -139,8 +134,6 @@ class GovernedRuntime:
     def acquire_lease(self, request: Mapping[str, Any]) -> dict[str, Any]:
         binding, _, _ = self._runtime(request)
         req = binding.request
-        if request.get("target_branch") != req.target_branch:
-            raise RuntimeError("LEASE_BINDING_CONFLICT")
         return {"schema": WriterLeaseRequestV2.schema, "task_id": req.task_id, "repository": req.repository, "branch_mode": req.branch_mode, "base_oid": req.base_oid, "expected_branch_oid": req.expected_branch_oid, "target_branch": req.target_branch, "generation": req.generation, "lease_seconds": req.lease_seconds, "create_target_branch": req.branch_mode == "CREATE_NEW", "worktree_mode": "detached_at_base_oid" if req.branch_mode == "CREATE_NEW" else "detached_at_expected_head", "cas_ref_update_required": True}
 
     @staticmethod
@@ -153,12 +146,7 @@ class GovernedRuntime:
         runtime = self.runtimes.get((str(request["task_id"]), int(request["generation"])))
         if runtime is None: raise RuntimeError("LEASE_NOT_FOUND")
         binding, _, executor = runtime
-        if (
-            request["repository"] != binding.request.repository
-            or request["target_branch"] != binding.request.target_branch
-            or request["expected_branch_oid"] != binding.request.expected_branch_oid
-        ):
-            raise RuntimeError("LEASE_BINDING_CONFLICT")
+        if request["target_branch"] != binding.request.target_branch or request["expected_branch_oid"] != binding.request.expected_branch_oid: raise RuntimeError("LEASE_BINDING_CONFLICT")
         commit = ContinuationCommit(idempotency_key=str(request["idempotency_key"]), files=self._files(request), message=str(request["message"]))
         executor.workspace.materialize_files(commit.files)
         return executor.execute(binding, commit)
@@ -200,16 +188,7 @@ class GovernedRuntime:
         task_id = str(binding.get("task_id") or binding.get("campaign_id") or "").strip()
         repository = str(binding.get("repository") or "").strip()
         operation = str(binding.get("operation") or row.get("operation") or "").strip()
-        branch_values = [
-            value for value in (binding.get("branch"), binding.get("target_branch"), row.get("branch"))
-            if value is not None
-        ]
-        if not branch_values or any(not isinstance(value, str) or value != branch_values[0] for value in branch_values):
-            raise RuntimeError("TARGET_BRANCH_BINDING_CONFLICT")
-        try:
-            branch = require_exact_governed_branch(branch_values[0])
-        except ValueError as exc:
-            raise RuntimeError("DURABLE_BINDING_INVALID") from exc
+        branch = str(binding.get("target_branch") or binding.get("branch") or row.get("branch") or "").strip()
         expected = str(binding.get("expected_branch_oid") or row.get("expected_branch_oid") or "").strip()
         base = binding.get("base_oid") or binding.get("lineage_anchor_oid")
         if not base:
@@ -302,6 +281,8 @@ class GovernedRuntime:
             return controller.store._receipt(row, duplicate=True).as_dict()
         if action == "resume":
             return controller.resume(job_id).as_dict()
+        if JobState(row["state"]) not in _RECOVERABLE:
+            return controller.store._receipt(row, duplicate=True).as_dict()
         return self._executor_from_row(row, controller).reconcile(job_id)
 
     def _snapshot_task(self) -> dict[str, Any]:
@@ -440,7 +421,7 @@ def main() -> None:
         token_path,
         ssh_key_path,
         remote_name=os.environ.get("AIOS_GITEA_REMOTE", "gitea-http"),
-        api_base=os.environ.get("AIOS_GITEA_API_BASE", "https://g.cnnetmkt.top/git/api/v1"),
+        api_base=validate_gitea_api_url(os.environ.get("AIOS_GITEA_API_BASE", "")),
         target_version=os.environ.get("AIOS_CONTROL_PLANE_TARGET_VERSION", "V2R2C1"),
     )
     runtime = GovernedRuntime(config)

active-runtime/app/aios_continuation_executor.py

@@ -444,7 +444,6 @@ class ContinuationExecutor:
             "repository": request.repository,
             "operation": "CONTINUATION_COMMIT_FILES",
             "branch": request.target_branch,
-            "target_branch": request.target_branch,
             "expected_branch_oid": request.expected_branch_oid,
             "base_oid": request.base_oid,
             "branch_mode": request.branch_mode,

active-runtime/app/aios_continuation_lease.py

@@ -12,8 +12,6 @@ from datetime import datetime, timedelta, timezone
 import re
 from typing import Protocol
 
-from aios_branch_binding import BRANCH_RE
-
 
 OID_RE = re.compile(r"^[0-9a-f]{40}$")
 TARGET_BRANCH = "agent/autonomous-release-campaign-v1-20260807"
@@ -62,8 +60,6 @@ class WriterLeaseRequestV2:
             raise ContinuationError("branch_mode_invalid")
         _oid(self.base_oid, "base_oid")
         _oid(self.expected_branch_oid, "expected_branch_oid")
-        if not isinstance(self.target_branch, str) or BRANCH_RE.fullmatch(self.target_branch) is None:
-            raise ContinuationError("target_branch_invalid")
         if self.target_branch in {"main", "master"} or self.target_branch.startswith(("refs/", "tags/")):
             raise ContinuationError("protected_branch_rejected")
         if not isinstance(self.generation, int) or isinstance(self.generation, bool) or self.generation < 1:

active-runtime/app/aios_gitops_job_controller.py

@@ -18,8 +18,6 @@ import tempfile
 from datetime import datetime, timezone
 from typing import Any, Callable, Mapping
 
-from aios_branch_binding import is_valid_governed_branch
-
 
 class JobError(RuntimeError):
     pass
@@ -43,6 +41,8 @@ class JobState(str, Enum):
     REMOTE_SYNCING = "REMOTE_SYNCING"
     REMOTE_VERIFIED = "REMOTE_VERIFIED"
     COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+    CANCELLED = "CANCELLED"
     RECOVERABLE_FAILURE = "RECOVERABLE_FAILURE"
     RECONCILING = "RECONCILING"
     RECONCILIATION_REQUIRED = "RECONCILIATION_REQUIRED"
@@ -61,7 +61,12 @@ _ORDER = {
     JobState.COMPLETED: 8,
 }
 _RECOVERABLE = {JobState.RECOVERABLE_FAILURE, JobState.RECONCILIATION_REQUIRED}
-_TERMINAL = {JobState.COMPLETED, JobState.MANUAL_OWNER_REVIEW_REQUIRED}
+_TERMINAL = {
+    JobState.COMPLETED,
+    JobState.FAILED,
+    JobState.CANCELLED,
+    JobState.MANUAL_OWNER_REVIEW_REQUIRED,
+}
 
 
 def utc_now() -> str:
@@ -244,26 +249,8 @@ class JobStore:
             raise ServiceUnavailable("JOB_DB_UNAVAILABLE") from exc
         if row is None:
             raise JobError("JOB_NOT_FOUND")
-        self._validate_persisted_binding(row)
         return dict(row)
 
-    @staticmethod
-    def _validate_persisted_binding(row: Mapping[str, Any]) -> None:
-        try:
-            raw = json.loads(str(row["request_json"]))
-        except (KeyError, TypeError, ValueError) as exc:
-            raise JobError("DURABLE_BINDING_INVALID") from exc
-        binding = raw.get("binding", raw)
-        if not isinstance(binding, Mapping):
-            raise JobError("DURABLE_BINDING_INVALID")
-        canonical_branch = row["branch"]
-        if not is_valid_governed_branch(canonical_branch):
-            raise JobError("DURABLE_BINDING_INVALID")
-        for field in ("branch", "target_branch"):
-            value = binding.get(field)
-            if value is not None and (not isinstance(value, str) or value != canonical_branch):
-                raise JobError("TARGET_BRANCH_BINDING_CONFLICT")
-
     def _receipt(self, row: Mapping[str, Any], *, duplicate: bool) -> JobReceipt:
         state = JobState(row["state"])
         if state == JobState.COMPLETED:
@@ -296,11 +283,6 @@ class GitOpsJobController:
             raise JobError("PAYLOAD_DIGEST_INVALID")
         if request["branch"] in {"main", "master"} or request["branch"].startswith(("refs/", "tags/")):
             raise JobError("PROTECTED_BRANCH_REJECTED")
-        target_branch = request.get("target_branch")
-        if target_branch is not None and (
-            not isinstance(target_branch, str) or target_branch != request["branch"]
-        ):
-            raise JobError("TARGET_BRANCH_BINDING_CONFLICT")
         binding = {field: str(request[field]) for field in fields}
         # Operation-specific, non-secret binding inputs must survive the
         # durable round trip and participate in idempotency. Arbitrary request
@@ -327,7 +309,7 @@ class GitOpsJobController:
                 continue
             if isinstance(value, bool) or not isinstance(value, (str, int)):
                 raise JobError("JOB_BINDING_OPTION_INVALID")
-            text = str(value) if field == "target_branch" else str(value).strip()
+            text = str(value).strip()
             if not text or len(text) > 512:
                 raise JobError("JOB_BINDING_OPTION_INVALID")
             binding[field] = text

active-runtime/app/aios_gitops_model_api.py

@@ -5,6 +5,8 @@ from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 from typing import Any
 
+from release_version import validate_release_version
+
 ROOT = Path(os.getenv('AIOS_GITOPS_ROOT', '/data/aios-gitops'))
 WORKSPACE = Path(os.getenv('AIOS_GITOPS_WORKSPACE', str(ROOT / 'workspace')))
 DB_PATH = Path(os.getenv('AIOS_GITOPS_DB', str(ROOT / 'runtime' / 'gitops_model.sqlite3')))
@@ -218,7 +220,11 @@ class Handler(BaseHTTPRequestHandler):
                 a = self.require_write(['owner']);
                 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 ''): self.send_json({'error':'version must match VxRxCx'},400); return
+                try:
+            validate_release_version(ver)
+        except ValueError:
+            self.send_json({'error':'version must match VxRxCx'},400)
+            return
                 msg=data.get('message') or f'release {ver}'; out=git_cmd(['tag','-a',ver,'-m',msg]);
                 if data.get('push',False): git_cmd(['push','origin',ver])
                 level='V' if re.match(r'^V[1-9]\d*R0C0', ver) else ('R' if re.match(r'^V\d+R[1-9]\d*C0', ver) else 'C'); exec_sql('INSERT OR REPLACE INTO gitops_versions(version,tag,level,summary,status,created_by,created_at) VALUES(?,?,?,?,?,?,?)',(ver,ver,level,msg,'ready',a['username'],now())); exec_sql('UPDATE gitops_baseline SET active_version=?,active_tag=?,updated_at=? WHERE id=?',(ver,ver,now(),'current')); audit(a['username'],'git_tag',ver,{'level':level}); self.send_json({'status':'tagged','version':ver,'git':out}); return

active-runtime/app/aios_governed_task_bootstrap.py

@@ -78,7 +78,7 @@ class GovernedTaskBootstrap:
             if generation < 1: raise BootstrapError("GENERATION_INVALID")
         payload = json.dumps(values, sort_keys=True, separators=(",", ":")).encode()
         _, controller = self._store(values["task_id"])
-        receipt = controller.submit({"idempotency_key": values["idempotency_key"], "campaign_id": values["task_id"], "task_id": values["task_id"], "repository": values["repository"], "operation": "GOVERNED_TASK_CREATE", "branch": values["target_branch"], "target_branch": values["target_branch"], "expected_branch_oid": expected, "payload_digest": hashlib.sha256(payload).hexdigest(), "lineage_anchor_oid": values["base_oid"]}, payload=payload)
+        receipt = controller.submit({"idempotency_key": values["idempotency_key"], "campaign_id": values["task_id"], "task_id": values["task_id"], "repository": values["repository"], "operation": "GOVERNED_TASK_CREATE", "branch": values["target_branch"], "expected_branch_oid": expected, "payload_digest": hashlib.sha256(payload).hexdigest(), "lineage_anchor_oid": values["base_oid"]}, payload=payload)
         binding = GovernedTaskBinding(**values, expected_branch_oid=expected, branch_mode=mode, generation=generation, job_id=receipt.job_id)
         self._write(binding)
         return binding.response()

active-runtime/app/aios_model_api_staging.py

@@ -23,6 +23,7 @@ from gitea_tag_publication import (
     TagPublisher,
     redact,
     validate_version,
+    validate_gitea_api_url,
 )
 from orchestrator.action_monitor import ActionMonitor
 from silent_release_hardening import (
@@ -319,8 +320,7 @@ def resolve_commit_oid(value: str | None, field: str = 'target_oid') -> str:
         raise ValueError(f'{field} does not resolve to the exact approved commit') from exc
 
 def existing_tag_target(tag: str) -> str | None:
-    if not re.fullmatch(r'V\d+R\d+C\d+(?:-[A-Za-z0-9_.-]+)?$', str(tag or '')):
-        raise ValueError('invalid release version')
+    validate_version(tag)
     try:
         result = run_authoritative_git(
             ['rev-parse', '--verify', f'refs/tags/{tag}^{{commit}}'],
@@ -553,7 +553,15 @@ class H(BaseHTTPRequestHandler):
                     return self.sendj({'error':redact(exc)},413)
                 except (AuthoritativeGitError, RuntimeError) as exc:
                     return self.sendj({'error':redact(exc)},503)
-                return self.sendj({'from':frm,'to':to,'diff':diff})
+                payload = {'from': frm, 'to': to, 'diff': diff}
+                payload.update({
+                    key: diff[key]
+                    for key in (
+                        'from_oid', 'to_oid', 'changed_paths', 'stats',
+                        'total_size_bytes', 'truncated', 'patch_limit_bytes',
+                    )
+                })
+                return self.sendj(payload)
             if path in ('/api/patch','/api/patches','/api/branches','/patch'):
                 snapshot = repository_snapshot(
                     git_dir=AUTHORITATIVE_GIT_DIR,
@@ -822,7 +830,10 @@ class H(BaseHTTPRequestHandler):
         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)
+        try:
+            validate_version(ver)
+        except ValueError:
+            return self.sendj({'error':'version must match VxRxCx'},400)
         if not data.get('target_oid') or not data.get('evidence_closure_oid') or not data.get('approval_plan_id'):
             return self.sendj({
                 'error':'production_tag_evidence_required',
@@ -1016,6 +1027,7 @@ def api_spec():
 
 
 def main():
+    validate_gitea_api_url(os.getenv('AIOS_GITOPS_GITEA_API_URL', ''))
     print(f'AIOS ChatGPT GitOps adapter listening on {HOST}:{PORT}')
     ThreadingHTTPServer((HOST,PORT), H).serve_forever()
 if __name__ == '__main__': main()

active-runtime/app/authoritative_git.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 import os
 import re
 import subprocess
+import time
 import urllib.parse
 from pathlib import Path
 from typing import Iterable
@@ -306,14 +307,76 @@ def authoritative_diff(
     from_oid = validate_git_revision(from_revision, "from", git_dir=path)
     to_oid = validate_git_revision(to_revision, "to", git_dir=path)
     args = ["diff", "--no-ext-diff", "--no-textconv", from_oid, to_oid]
-    result = run_authoritative_git(args, git_dir=path)
+    patch_limit = max(1, min(_MAX_OUTPUT, 256 * 1024))
+    process = subprocess.Popen(
+        ["git", "--git-dir", str(path), *args],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        env={**os.environ, "GIT_OPTIONAL_LOCKS": "0"},
+    )
+    chunks: list[bytes] = []
+    stored_bytes = 0
+    total_bytes = 0
+    started = time.monotonic()
+    try:
+        while process.stdout is not None:
+            chunk = process.stdout.read(64 * 1024)
+            if not chunk:
+                break
+            total_bytes += len(chunk)
+            if stored_bytes < patch_limit:
+                remaining = patch_limit - stored_bytes
+                selected = chunk[:remaining]
+                chunks.append(selected)
+                stored_bytes += len(selected)
+            if time.monotonic() - started > _TIMEOUT:
+                process.kill()
+                raise AuthoritativeGitError("GIT_REF_QUERY_TIMEOUT")
+        stderr = (
+            process.stderr.read(8192).decode("utf-8", errors="replace")
+            if process.stderr is not None
+            else ""
+        )
+        returncode = process.wait(timeout=max(0.1, _TIMEOUT - (time.monotonic() - started)))
+    except (OSError, subprocess.TimeoutExpired) as exc:
+        process.kill()
+        process.wait()
+        raise AuthoritativeGitError("GIT_REF_QUERY_FAILED") from exc
+    if returncode != 0:
+        raise AuthoritativeGitError(_redact(stderr.strip() or "GIT_REF_QUERY_FAILED")[:200])
+    try:
+        names_result = run_authoritative_git(
+            ["diff", "--no-ext-diff", "--no-textconv", "--name-status", from_oid, to_oid],
+            git_dir=path,
+        )
+        changed_paths = [
+            line.split("\t", 1)[-1]
+            for line in names_result.stdout.splitlines()
+            if line.strip()
+        ]
+    except AuthoritativeGitOutputTooLarge:
+        changed_paths = []
+    try:
+        stats_result = run_authoritative_git(
+            ["diff", "--no-ext-diff", "--no-textconv", "--stat", from_oid, to_oid],
+            git_dir=path,
+        )
+        stats = stats_result.stdout.strip()
+    except AuthoritativeGitOutputTooLarge:
+        stats = "GIT_STAT_OUTPUT_TRUNCATED"
+    patch = b"".join(chunks).decode("utf-8", errors="replace")
     return {
         "code": 0,
-        "stdout": result.stdout,
+        "stdout": patch,
         "stderr": "",
         "cmd": ["git", f"--git-dir={path}", *args],
         "from_oid": from_oid,
         "to_oid": to_oid,
+        "changed_paths": changed_paths,
+        "stats": stats,
+        "total_size_bytes": total_bytes,
+        "truncated": total_bytes > patch_limit,
+        "patch_limit_bytes": patch_limit,
     }
 
 

active-runtime/app/gitea_tag_publication.py

@@ -8,6 +8,7 @@ import json
 import os
 import re
 import subprocess
+import sys
 import tempfile
 import time
 import urllib.error
@@ -23,10 +24,15 @@ try:
     from authoritative_git import AuthoritativeGitError, run_authoritative_git
 except ModuleNotFoundError:
     from .authoritative_git import AuthoritativeGitError, run_authoritative_git
+try:
+    from release_version import RELEASE_VERSION_RE, validate_release_version
+except ModuleNotFoundError:
+    sys.path.insert(0, str(Path(__file__).resolve().parents[2]))
+    from release_version import RELEASE_VERSION_RE, validate_release_version
 
 
 OID_RE = re.compile(r"^[0-9a-f]{40}$")
-VERSION_RE = re.compile(r"^V\d+R\d+C\d+(?:-[A-Za-z0-9_.-]+)?$")
+VERSION_RE = RELEASE_VERSION_RE
 DEPLOYMENT_EVIDENCE_RE = re.compile(r"^(?:sha256:[0-9a-f]{64}|git:[0-9a-f]{40})$")
 FINGERPRINT_FIELDS = (
     "version",
@@ -83,9 +89,14 @@ class PublicationManualOwnerReviewRequired(
 
 
 def validate_version(version: str) -> str:
-    value = str(version or "")
-    if not VERSION_RE.fullmatch(value):
-        raise ValueError("invalid release version")
+    return validate_release_version(version)
+
+
+def validate_gitea_api_url(api_url: str) -> str:
+    value = str(api_url or "").strip().rstrip("/")
+    parsed = urllib.parse.urlsplit(value)
+    if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+        raise ValueError("Gitea API URL must be HTTP(S)")
     return value
 
 
@@ -411,13 +422,11 @@ class GiteaTagClient:
         timeout: float = 15,
         token_line: int = 1,
     ):
-        self.api_url = api_url.rstrip("/")
+        self.api_url = validate_gitea_api_url(api_url)
         self.repository = repository.strip("/")
         self.token_file = token_file
         self.timeout = timeout
         self.token_line = token_line
-        if not self.api_url.startswith(("https://", "http://")):
-            raise ValueError("Gitea API URL must be HTTP(S)")
         if self.repository.count("/") != 1:
             raise ValueError("Gitea repository must be owner/name")
 

active-runtime/app/governed_tag_adapter.py

@@ -34,6 +34,8 @@ from gitea_tag_publication import (
     TagPublisher,
 )
 
+from release_version import validate_release_version
+
 OID_RE = re.compile(r"^[0-9a-f]{40}$")
 PLAN_RE = re.compile(r"^sha256:[0-9a-f]{64}$")
 
@@ -44,8 +46,10 @@ def load_request() -> dict[str, Any]:
         raise ValueError("request_object_required")
     if value.get("schema") != "aios.production-executor-request.v1":
         raise ValueError("request_schema_invalid")
-    if not re.fullmatch(r"V\d+R\d+C\d+(?:-[A-Za-z0-9_.-]+)?", str(value.get("version", ""))):
-        raise ValueError("version_invalid")
+    try:
+        validate_release_version(value.get("version", ""))
+    except ValueError as exc:
+        raise ValueError("version_invalid") from exc
     for name in ("target_oid", "evidence_closure_oid"):
         if not OID_RE.fullmatch(str(value.get(name, ""))):
             raise ValueError(f"{name}_invalid")

active-runtime/app/release_metadata_adapter.py

@@ -27,6 +27,8 @@ import urllib.request
 from pathlib import Path
 from typing import Any, Mapping
 
+from release_version import validate_release_version
+
 OID_RE = re.compile(r"^[0-9a-f]{40}$")
 SHA_RE = re.compile(r"^[0-9a-f]{64}$")
 PLAN_RE = re.compile(r"^sha256:[0-9a-f]{64}$")
@@ -86,8 +88,10 @@ def load_request() -> dict[str, Any]:
         raise ValueError("request_schema_invalid")
     if value.get("repository_identity") != "aios/aios":
         raise ValueError("repository_identity_invalid")
-    if not re.fullmatch(r"V\d+R\d+C\d+(?:-[A-Za-z0-9_.-]+)?", str(value.get("version", ""))):
-        raise ValueError("version_invalid")
+    try:
+        validate_release_version(value.get("version", ""))
+    except ValueError as exc:
+        raise ValueError("version_invalid") from exc
     for name in ("target_oid", "evidence_closure_oid"):
         if not OID_RE.fullmatch(str(value.get(name, ""))):
             raise ValueError(f"{name}_invalid")

active-runtime/app/silent_release_controller.py

@@ -22,11 +22,12 @@ from enum import Enum
 from pathlib import Path
 from typing import Any, Protocol
 
+from release_version import validate_release_version
+
 
 OID_RE = re.compile(r"^[0-9a-f]{40}$")
 SHA256_RE = re.compile(r"^[0-9a-f]{64}$")
 CANDIDATE_ID_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_.-]{2,127}$")
-VERSION_RE = re.compile(r"^V\d+R\d+C\d+(?:-[A-Za-z0-9_.-]+)?$")
 SECRET_PATTERNS = (
     re.compile(r"(?i)(authorization\s*[:=]\s*)(?:bearer|token)\s+\S+"),
     re.compile(r"(?i)((?:access_)?token\s*[:=]\s*)\S+"),
@@ -769,8 +770,10 @@ class TagApprovalEnvelope:
     def validate(self) -> None:
         if self.action != "production_tag":
             raise ApprovalError("approval does not authorize production tag")
-        if not VERSION_RE.fullmatch(self.version):
-            raise ApprovalError("invalid release version")
+        try:
+            validate_release_version(self.version)
+        except ValueError as exc:
+            raise ApprovalError("invalid release version") from exc
         _validate_oid("tag_oid", self.tag_oid)
         _validate_oid("target_oid", self.target_oid)
         if _parse_utc(self.expires_at) <= datetime.now(timezone.utc):

active-runtime/app/task_plane/capabilities.py

@@ -1,25 +1,36 @@
-"""Compatibility facade for the canonical capability contract."""
+"""Capability matcher helpers."""
 
 from __future__ import annotations
 
-from aios_capability_contract import (
-    has_capabilities as _has_capabilities,
-    normalize_worker_capabilities,
-    required_capabilities_subset as _required_capabilities_subset,
-)
+from fnmatch import fnmatch
+
+
+def _normalize_capability(capability: str) -> str:
+    return capability.strip().lower()
 
 
 def capability_matches(granted: str, required: str) -> bool:
-    return _has_capabilities([granted], [required])
+    granted = _normalize_capability(granted)
+    required = _normalize_capability(required)
+    if granted == required:
+        return True
+    # A granted wildcard such as "test.*" should match required "test.unit"
+    if "*" in granted:
+        return fnmatch(required, granted)
+    # A required wildcard is treated as a suffix/prefix requirement for callers.
+    if "*" in required:
+        return fnmatch(granted, required)
+    return False
 
 
 def has_capabilities(granted_caps: list[str], required_caps: list[str]) -> bool:
-    return _has_capabilities(granted_caps, required_caps)
+    granted = [_normalize_capability(c) for c in granted_caps]
+    for required in required_caps:
+        required = _normalize_capability(required)
+        if not any(capability_matches(g, required) for g in granted):
+            return False
+    return True
 
 
 def normalize_capabilities(caps: list[str]) -> list[str]:
-    return sorted(normalize_worker_capabilities(caps))
-
-
-def required_capabilities_subset(granted: list[str], required: list[str]) -> bool:
-    return _required_capabilities_subset(granted, required)
+    return sorted({_normalize_capability(cap) for cap in caps})

active-runtime/app/task_plane/delegation.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-from .capabilities import required_capabilities_subset
 from .errors import ConflictError, ForbiddenError, NotFoundError
 from .models import Budget, TaskPlan, TaskRecord
 from .store import TaskPlaneStore
@@ -35,9 +34,8 @@ class DelegationEngine:
     def delegate(self, parent_id: str, child_plan: TaskPlan, *, caller: str) -> TaskRecord:
         self.can_delegate(parent_id, child_plan)
         parent = self.store.get_task(parent_id)
-        if child_plan.required_capabilities and not required_capabilities_subset(
-            parent.task_plan.required_capabilities or [],
-            child_plan.required_capabilities,
+        if child_plan.required_capabilities and not set(child_plan.required_capabilities).issubset(
+            set(parent.task_plan.required_capabilities or [])
         ):
             raise ForbiddenError("child capabilities exceed parent constraints")
         risk_rank = {"low": 1, "medium": 2, "high": 3}

active-runtime/app/task_plane/policy.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Callable
 
-from .capabilities import has_capabilities
 from .errors import ForbiddenError, LockedError
 from .models import ProbeEvidence, ResultEnvelope, TaskRecord
 
@@ -51,7 +50,7 @@ class ReadonlyWorkerProfile:
             return False
         if plan.metadata.get("production_side_effects") is not False:
             return False
-        return has_capabilities(list(self.capabilities), plan.required_capabilities)
+        return set(plan.required_capabilities).issubset(self.capabilities)
 
 
 class IdentityVerifier:

deploy/systemd/aios-chatgpt-bridge-v2-staging.service

@@ -4,14 +4,25 @@ After=network-online.target
 
 [Service]
 Type=simple
-User=aios-bridge-staging
-Group=aios-bridge-staging
-WorkingDirectory=/opt/aios/gitops-control-plane/current
+User=aiman
+Group=gitops
+PermissionsStartOnly=true
+WorkingDirectory=@RUNTIME_ROOT@
 Environment=AIOS_BRIDGE_SCHEMA_VERSION=aios.chatgpt-gitops-bridge.v2
 Environment=AIOS_GITOPS_WRITES_ENABLED=false
 Environment=AIOS_GITOPS_DURABLE_JOB_EXECUTION_ENABLED=true
+Environment=AIOS_GITOPS_WRITES_ENABLED=false
+Environment=AIOS_GITEA_API_BASE=https://g.cnnetmkt.top/git/api/v1
+Environment=AIOS_GITEA_TOKEN_FILE=/run/credentials/aios-chatgpt-bridge-v2-staging.service/gitea_token
+Environment=AIOS_GITEA_REMOTE=gitea-http
+Environment=AIOS_CONTROL_PLANE_TARGET_VERSION=V2R2C1
+Environment=AIOS_CONTROL_PLANE_TARGET_OID=@SOURCE_OID@
+Environment=AIOS_CONTROL_PLANE_ARTIFACT_SHA256=@ARTIFACT_SHA256@
+Environment=PYTHONPATH=@RUNTIME_ROOT@:@RUNTIME_ROOT@/app:@RUNTIME_ROOT@/runtime-agent-os
 Environment=AIOS_DEPLOYMENT_STATE=STAGING
-ExecStart=/usr/bin/python3 /opt/aios/gitops-control-plane/current/bridge-v2-staging-server.py
+LoadCredential=gitea_token:/run/credentials/aios-governance-executor.service/gitea-governance-executor-token
+ExecStartPre=/usr/bin/install -d -o aiman -g gitops -m 0750 /var/lib/aios-gitops/bridge-v2-staging
+ExecStart=/usr/bin/python3 -B @RUNTIME_ROOT@/app/aios_chatgpt_bridge_v2_server.py
 NoNewPrivileges=true
 PrivateTmp=true
 ProtectSystem=strict

deploy/systemd/aios-gitops-model-api-v2r2c1-staging.service

@@ -7,6 +7,9 @@ Wants=network-online.target
 Type=simple
 User=aiman
 Group=gitops
+PermissionsStartOnly=true
+ExecStartPre=/usr/bin/install -d -o aiman -g gitops -m 0750 /var/lib/aios-gitops/model-api-staging
+ExecStartPre=/usr/bin/install -d -o aiman -g gitops -m 0750 /var/lib/aios-gitops/model-api-staging/silent-release
 WorkingDirectory=@RUNTIME_ROOT@
 Environment=PYTHONUNBUFFERED=1
 Environment=PYTHONDONTWRITEBYTECODE=1
@@ -27,10 +30,16 @@ Environment=AIOS_GITOPS_DEPLOYMENT_STATE=STAGING
 Environment=AIOS_GITOPS_MODEL_API_SERVICE=aios-gitops-model-api-v2r2c1-staging.service
 Environment=AIOS_SILENT_RELEASE_EXECUTION_ENABLED=false
 Environment=AIOS_SILENT_RELEASE_STATE_ROOT=/var/lib/aios-gitops/model-api-staging/silent-release
+Environment=AIOS_GITOPS_GITEA_API_URL=https://g.cnnetmkt.top/git/api/v1
+Environment=AIOS_GITOPS_GITEA_REPOSITORY=aios/aios
+Environment=AIOS_GITOPS_GITEA_REMOTE=gitea-http
+Environment=AIOS_GITOPS_GITEA_TOKEN_FILE=/run/credentials/aios-gitops-model-api-v2r2c1-staging.service/gitea_token
+Environment=AIOS_GITOPS_GITEA_TOKEN_LINE=1
+LoadCredential=gitea_token:/run/credentials/aios-governance-executor.service/gitea-governance-executor-token
 Environment=AIOS_BRIDGE_V2_URL=http://127.0.0.1:18892
 Environment=AIOS_GITOPS_HOST=127.0.0.1
 Environment=AIOS_GITOPS_PORT=18893
-Environment=PYTHONPATH=@RUNTIME_ROOT@/app:@RUNTIME_ROOT@/runtime-agent-os
+Environment=PYTHONPATH=@RUNTIME_ROOT@:@RUNTIME_ROOT@/app:@RUNTIME_ROOT@/runtime-agent-os
 ExecStart=/usr/bin/python3 @RUNTIME_ROOT@/app/aios_model_api_staging.py
 Restart=on-failure
 RestartSec=2

docs/gitops/capability-contract.md

@@ -1,31 +0,0 @@
-# AIOS capability contract
-
-The Agent Task API compares task requirements and worker registrations through one
-strict semantic matcher. Task-facing names are normalized to the worker vocabulary
-before both poll and claim; the two paths cannot disagree about eligibility.
-
-| Task-facing requirement | Semantic capability | Worker vocabulary |
-| --- | --- | --- |
-| repository_read | repo.read | git.read |
-| test_execution | test.execute | git.test |
-| governed_git_write | governed.git.write (composite) | governed.write.branch + governed.write.file |
-
-governed_git_write is composite: a worker must have both the branch-write and
-file-write capabilities. A single component never satisfies the requirement.
-
-Unknown names are not granted by normalization. Wildcard, prefix, and glob
-expressions are never expanded. This is fail-closed: an unknown task
-requirement is never eligible, even if a worker happens to report the same
-unknown string.
-
-The same matcher is used by:
-
-- GET /v1/agent/tasks/poll
-- POST /v1/agent/tasks/{task_id}/claim
-- the compatibility facade in task_plane.capabilities
-
-Legacy runtime names such as shell, git, and python remain exact semantic
-capabilities for compatibility; none implies governed write, production, main, or
-unrestricted command execution. Capability aliases are a compatibility boundary
-only; they do not grant additional authority. Capability strings remain separate
-from Owner credentials, Agent tokens, and WriterLease authorization.

docs/gitops/openapi-agent-task-v1.yaml

@@ -1,310 +0,0 @@
-openapi: 3.1.0
-info:
-  title: AIOS Online Agent Task API
-  version: 1.0.0
-  description: >
-    Durable online task distribution for OpenClaw, Hermes, and other external
-    agents. Agent credentials and lease tokens are bearer credentials and must
-    never be committed to Git.
-servers:
-  - url: /agent-tasks
-paths:
-  /health:
-    get:
-      operationId: agentTaskHealth
-      responses:
-        "200":
-          description: Service health
-  /v1/agents/register:
-    post:
-      operationId: registerOnlineAgent
-      security:
-        - bearerAuth: []
-      description: Control-plane only. Returns the agent token once.
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: "#/components/schemas/RegisterAgentRequest"
-      responses:
-        "201":
-          description: Registered
-  /v1/tasks:
-    post:
-      operationId: createOnlineAgentTask
-      security:
-        - bearerAuth: []
-      description: Control-plane only.
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: "#/components/schemas/CreateTaskRequest"
-      responses:
-        "201":
-          description: Task created
-  /v1/tasks/poll:
-    post:
-      operationId: pollOnlineAgentTasks
-      security:
-        - bearerAuth: []
-      description: Agent operation. Returns capability-compatible queued tasks.
-      requestBody:
-        content:
-          application/json:
-            schema:
-              type: object
-              properties:
-                limit:
-                  type: integer
-                  minimum: 1
-                  maximum: 100
-                  default: 20
-      responses:
-        "200":
-          description: Available tasks
-  /v1/tasks/{task_id}:
-    parameters:
-      - $ref: "#/components/parameters/TaskId"
-    get:
-      operationId: getOnlineAgentTaskDirect
-      security:
-        - bearerAuth: []
-      responses:
-        "200":
-          description: Task status
-  /v1/tasks/{task_id}/claim:
-    parameters:
-      - $ref: "#/components/parameters/TaskId"
-    post:
-      operationId: claimOnlineAgentTask
-      security:
-        - bearerAuth: []
-      requestBody:
-        content:
-          application/json:
-            schema:
-              type: object
-              properties:
-                lease_seconds:
-                  type: integer
-                  minimum: 30
-                  maximum: 3600
-                  default: 300
-      responses:
-        "200":
-          description: >
-            Claim succeeded. The lease_token is returned once and must be kept
-            in runtime memory/secret storage, never Git.
-        "409":
-          description: Already claimed or otherwise not claimable
-  /v1/tasks/{task_id}/heartbeat:
-    parameters:
-      - $ref: "#/components/parameters/TaskId"
-    post:
-      operationId: heartbeatOnlineAgentTask
-      security:
-        - bearerAuth: []
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: "#/components/schemas/HeartbeatRequest"
-      responses:
-        "200":
-          description: Lease renewed
-  /v1/tasks/{task_id}/result:
-    parameters:
-      - $ref: "#/components/parameters/TaskId"
-    post:
-      operationId: submitOnlineAgentResult
-      security:
-        - bearerAuth: []
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: "#/components/schemas/ResultRequest"
-      responses:
-        "200":
-          description: Result accepted into VERIFYING
-  /v1/tasks/{task_id}/verify:
-    parameters:
-      - $ref: "#/components/parameters/TaskId"
-    post:
-      operationId: verifyOnlineAgentTaskDirect
-      security:
-        - bearerAuth: []
-      description: Control-plane only.
-      requestBody:
-        required: true
-        content:
-          application/json:
-            schema:
-              $ref: "#/components/schemas/VerifyRequest"
-      responses:
-        "200":
-          description: Verification decision applied
-  /v1/tasks/{task_id}/cancel:
-    parameters:
-      - $ref: "#/components/parameters/TaskId"
-    post:
-      operationId: cancelOnlineAgentTaskDirect
-      security:
-        - bearerAuth: []
-      description: Control-plane only.
-      requestBody:
-        content:
-          application/json:
-            schema:
-              type: object
-              properties:
-                reason:
-                  type: string
-      responses:
-        "200":
-          description: Cancelled or already terminal
-  /v1/tasks/{task_id}/events:
-    parameters:
-      - $ref: "#/components/parameters/TaskId"
-    get:
-      operationId: getOnlineAgentTaskEventsDirect
-      security:
-        - bearerAuth: []
-      description: Control-plane only.
-      responses:
-        "200":
-          description: Audit event list
-components:
-  securitySchemes:
-    bearerAuth:
-      type: http
-      scheme: bearer
-  parameters:
-    TaskId:
-      name: task_id
-      in: path
-      required: true
-      schema:
-        type: string
-        pattern: "^[A-Za-z0-9][A-Za-z0-9._:-]{2,179}$"
-  schemas:
-    RegisterAgentRequest:
-      type: object
-      additionalProperties: false
-      required: [agent_id, agent_type, agent_version, capabilities]
-      properties:
-        agent_id:
-          type: string
-        agent_type:
-          type: string
-          examples: [openclaw]
-        agent_version:
-          type: string
-        capabilities:
-          type: array
-          items:
-            type: string
-        metadata:
-          type: object
-          additionalProperties: true
-    CreateTaskRequest:
-      type: object
-      additionalProperties: false
-      required:
-        - goal
-        - instructions
-        - success_criteria
-        - idempotency_key
-      properties:
-        task_id:
-          type: string
-        goal:
-          type: string
-        instructions:
-          type: string
-        success_criteria:
-          type: array
-          items: {}
-        required_capabilities:
-          type: array
-          items:
-            type: string
-        constraints:
-          type: object
-          additionalProperties: true
-        metadata:
-          type: object
-          additionalProperties: true
-        deadline:
-          type: string
-          format: date-time
-        priority:
-          type: integer
-          minimum: -100
-          maximum: 100
-          default: 0
-        max_attempts:
-          type: integer
-          minimum: 1
-          maximum: 20
-          default: 3
-        idempotency_key:
-          type: string
-    HeartbeatRequest:
-      type: object
-      additionalProperties: false
-      required: [lease_token]
-      properties:
-        lease_token:
-          type: string
-        lease_seconds:
-          type: integer
-          minimum: 30
-          maximum: 3600
-          default: 300
-        progress:
-          type: object
-          additionalProperties: true
-    ResultRequest:
-      type: object
-      additionalProperties: false
-      required: [lease_token, idempotency_key, result]
-      properties:
-        lease_token:
-          type: string
-        idempotency_key:
-          type: string
-        result:
-          type: object
-          additionalProperties: true
-    VerifyRequest:
-      type: object
-      additionalProperties: false
-      required: [decision]
-      properties:
-        decision:
-          type: string
-          enum: [SUCCEEDED, NEEDS_REWORK, FAILED]
-        verification:
-          type: object
-          additionalProperties: true
-x-aios-capability-contract:
-  description: >
-    Task-facing semantic capability names are normalized against the worker
-    runtime vocabulary before eligibility. Unknown and wildcard names fail
-    closed. The composite governed_git_write requirement requires both
-    governed.write.branch and governed.write.file.
-  task_facing:
-    repository_read: repo.read
-    test_execution: test.execute
-    governed_git_write: governed.git.write
-  worker_vocabulary:
-    git.read: repo.read
-    git.test: test.execute
-    governed.write.branch: governed.git.write.branch
-    governed.write.file: governed.git.write.file

docs/gitops/openapi-authorized-task-writer-fragment.yaml

@@ -35,7 +35,6 @@ components:
         target_branch:
           type: string
           pattern: '^agent/[A-Za-z0-9][A-Za-z0-9._/-]{2,179}$'
-          maxLength: 186
         owner_authorization_reference:
           type: string
           minLength: 4

docs/gitops/openapi-chatgpt-actions.yaml

@@ -241,6 +241,48 @@ components:
       properties:
         candidate_id: {type: string}
 paths:
+  /v2/commit-files:
+    post:
+      operationId: commitFilesGoverned
+      summary: Submit one atomic governed commit containing multiple files
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              additionalProperties: false
+              required:
+                - task_id
+                - repository
+                - expected_branch_oid
+                - target_branch
+                - generation
+                - idempotency_key
+                - files
+                - message
+              properties:
+                task_id: {type: string}
+                repository: {type: string, example: aios/aios}
+                expected_branch_oid: {type: string, pattern: '^[0-9a-f]{40}$'}
+                target_branch: {type: string, pattern: '^agent/[A-Za-z0-9._/-]+$'}
+                generation: {type: integer, minimum: 1}
+                idempotency_key: {type: string}
+                files:
+                  type: array
+                  minItems: 1
+                  items:
+                    type: object
+                    additionalProperties: false
+                    required: [path, content_base64]
+                    properties:
+                      path: {type: string, minLength: 1, maxLength: 512}
+                      content_base64: {type: string}
+                message: {type: string, minLength: 1, maxLength: 200}
+      responses:
+        '200': {description: Governed commit job and verified branch result}
+        '400': {description: Contract or policy rejection}
+        '409': {description: Branch CAS or idempotency conflict}
   /createReleaseIntent:
     post:
       operationId: createReleaseIntent

docs/gitops/openapi-owner-authorization-broker-fragment.yaml

@@ -38,7 +38,6 @@ components:
         target_branch:
           type: string
           pattern: '^agent/[A-Za-z0-9][A-Za-z0-9._/-]{2,179}$'
-          maxLength: 186
         one_time_use:
           type: boolean
           const: true

docs/gitops/writer-lease-binding.md

@@ -1,19 +0,0 @@
-# AIOS WriterLease branch binding
-
-A governed branch name is an opaque contract value and must survive the entire
-lifecycle unchanged:
-
-Task.target_branch -> Job.branch -> Lease.branch -> commit request.target_branch -> actual ref
-
-The binding rules are:
-
-- The value must match the governed agent branch grammar and the configured length limit.
-- No truncation, abbreviation, slugging, whitespace trimming, case folding, or inferred replacement is permitted.
-- If a request carries both branch and target_branch, they must be byte-for-byte equal before a job is persisted or a ref is touched.
-- A WriterLease response is checked against the exact requested branch before editing begins.
-- A persisted binding with conflicting aliases is invalid and fails closed as reconciliation-required state; operators must inspect and repair it through the governed path rather than guessing a branch.
-- Overlong or malformed names are validation errors, never shortened values.
-
-The exact value is also checked at commit preflight alongside repository and
-expected base OID. The proof of completion is the exact branch ref and commit OID,
-not merely a successful HTTP response or an active service.

release_version.py

@@ -0,0 +1,21 @@
+"""Canonical AIOS release-version parser shared by runtime and release tools."""
+from __future__ import annotations
+
+import re
+
+
+# The suffix preserves already-supported annotated release names while the
+# canonical VnRnCn namespace remains accepted exactly.
+RELEASE_VERSION_PATTERN = r"^V[0-9]+R[0-9]+C[0-9]+(?:-[A-Za-z0-9_.-]+)?$"
+RELEASE_VERSION_RE = re.compile(RELEASE_VERSION_PATTERN)
+
+
+def parse_release_version(version: object) -> str:
+    value = str(version or "").strip()
+    if not RELEASE_VERSION_RE.fullmatch(value):
+        raise ValueError("invalid release version")
+    return value
+
+
+def validate_release_version(version: object) -> str:
+    return parse_release_version(version)

reports/action-contract-regression-remediation-20260825.md

@@ -0,0 +1,75 @@
+# Action Contract Regression Remediation — 2026-08-25
+
+## Scope
+
+Governed task: `fix-action-contracts-20260825-1407`
+Base: `3244f0f17f8845592ac94d585f5ebd65693c9f29`
+Target branch: `agent/fix-action-contracts-20260825-1407`
+
+## Verified regressions
+
+1. `getReleaseConsistency` and `runReleaseAcceptance` fail before evaluation with:
+   `Gitea API URL must be HTTP(S)`.
+   V2R2C1 release evidence at `a8b906d1bc24088c19647e98de6a679268f6d0a2`
+   proves Gitea API readback passed for target `998d30304787e31e5ae607c0bd86b5edb2b0e5ad`.
+   Therefore current staging/contract overlay configuration has regressed.
+
+2. `getReleaseSaga` fails with:
+   `Permission denied: '/var/lib/aios-gitops/silent-release'`.
+   Runtime service identity must have read/traverse access to the durable release state root.
+   Fix ownership/group/ACL at deployment time; do not broaden to world-writable permissions.
+
+3. `getTagPublicationStatus` rejects the authoritative approved version `V2R2C1`
+   as `invalid release version`, while `getGovernedWriteCapabilities` returns the same
+   version as the approved release scope. The two Action contracts are internally inconsistent.
+   Release-version validation must accept the canonical AIOS `^V[0-9]+R[0-9]+C[0-9]+$`
+   namespace (or, preferably, use one shared validator for all release Actions).
+
+4. `commitFilesGoverned` is unusable from the published Action schema.
+   Runtime capability metadata declares required fields:
+   `task_id, repository, expected_branch_oid, target_branch, generation, idempotency_key, files, message`,
+   but the exposed tool contract has no `files` input. Regenerate/publish the Action schema from
+   the same operation contract source and add a contract-parity test.
+
+5. `reconcileGitOpsJob` returned `DURABLE_BINDING_INVALID` for a completed governed
+   single-file job that was otherwise read back as `COMPLETED`.
+   Reconciliation of a valid terminal job should be idempotent/read-only and must not require
+   a stale or absent active lease. Add a regression case for terminal completed jobs.
+
+6. `getDiff` returns `ResponseTooLargeError` / `GIT_OUTPUT_LIMIT_EXCEEDED` for large diffs.
+   Add server-side bounded output: path/stat summary plus truncation metadata, or pagination.
+   The Action must never fail merely because a valid repository diff is large.
+
+## Required implementation changes
+
+- Centralize release-version parsing and reuse it in tag status, candidate, consistency, and acceptance.
+- Validate/normalize Gitea API URL at service startup and fail health checks with a configuration-specific diagnostic.
+- Ensure the deployment unit projects a valid HTTP(S) Gitea API base URL into the staging overlay.
+- Correct durable release-state directory ownership/ACL for the runtime service account.
+- Generate the external Action schema from the runtime operation contract; parity-test required fields.
+- Make terminal reconciliation idempotent and independent of expired active writer leases.
+- Bound diff output and return `truncated=true` with deterministic metadata rather than transport failure.
+
+## Acceptance gates
+
+All must pass on the same deployed overlay:
+
+- `getReleaseConsistency(V2R2C1, 998d303..., a8b906d..., approved_plan)` returns a structured result, not URL error.
+- `runReleaseAcceptance(...)` reaches policy evaluation, not URL error.
+- `getTagPublicationStatus("V2R2C1")` returns structured publication state.
+- `getReleaseSaga(nonexistent_candidate)` returns NOT_FOUND/empty-state semantics, never filesystem permission failure.
+- Published `commitFilesGoverned` schema exposes `files` and a two-file isolated branch commit succeeds.
+- Reconcile of a completed governed job is idempotent.
+- Large diff returns bounded/truncated data rather than transport exception.
+- Existing protected-ref controls remain unchanged: no direct main/tag/baseline/production write.
+
+## Proven stable reference
+
+V2R2C1 evidence closure (`a8b906d1bc24088c19647e98de6a679268f6d0a2`) records:
+- Gitea Git/API readback PASS
+- staging runtime PASS
+- restart recovery PASS
+- 59 mandatory tests passed / 0 failed
+
+This evidence should be used as the compatibility baseline when repairing the current
+`contract-overlay-v2` / `scheme-a-323b615b...` staging layer.

runbooks/agent-fix-action-contracts-20260825.md

@@ -0,0 +1,207 @@
+# Agent Execution Contract — Action Contract Regression Repair
+
+## Objective
+
+Fully repair the current AIOS Action runtime/contract overlay regressions on the single server, without modifying protected refs directly and without introducing new infrastructure. The task is not complete until the deployed staging/action overlay passes all acceptance gates.
+
+## Authority and scope
+
+- Repository: `aios/aios`
+- Base at task creation: `3244f0f17f8845592ac94d585f5ebd65693c9f29`
+- Governed task: `fix-action-contracts-20260825-1407`
+- Target branch: `agent/fix-action-contracts-20260825-1407`
+- Protected refs must not be directly written: `main`, release tags, baseline registry, production runtime.
+- No new SaaS, database, agent framework, or monitoring platform may be introduced.
+
+## Non-interactive rules
+
+The Agent must run the whole flow unnattended:
+
+1. Collect facts.
+2. Determine root causes.
+3. Make the smallest correct changes.
+4. Run unit/integration/contract tests.
+5. Deploy to staging only.
+6. Restart only the affected non-production services.
+7. Run the full Action smoke suite.
+8. On failure, automatically collect logs, diagnose, fix, and retry.
+9. If a change causes a new regression, automatically roll back the staging change to the previous known-good configuration and record the failure.
+10. Stop only if an owner decision is required for a high-risk, irreversible, or production-boundary action.
+
+## Fact collection — required before editing
+
+Record all of the following in the final evidence bundle:
+
+- `id`, `hostname`, `uname -a`, `date --iso-seconds`
+- `git rev-parse --show HEAD` for authority worktree and running overlay source
+- `git status --porcelaine=v2`
+- `git remote -v`
+- current systemd service unit(s), drop-ins, Environment/EnvironmentFile sources for GitOps/Bredge/release services
+- `systemctl show <affected-service>` including `User=`, `Group=`, `Environment=`, `EnvironmentFile=`, `ExecStart=`
+- resolved Gitea API base URL after env/config expansion; redact secrets but not scheme/host
+- `stat -c, `namei -l`, `getfacl`, als -ld on `/var/lib/aios-gitops/silent-release` and its parents
+- find Action OpenAPI/schema generator and runtime operation definitions for `commitFilesGoverned`
+- find the release version validator(s) and all callers of `getTagPublicationStatus`
+- find `reconcileGitOpsJob` implementation and durable binding validation logic
+- find `getDiff  implementation and transport output limits
+
+Do not edit any file until the actual implementation and configuration sources have been located.
+
+## Repair 1 — Gitea API URL
+
+Symptoms:
+
+- `getReleaseConsistency` → `Gitea API URL must be HTTP(S)`
+- `runReleaseAcceptance` → `Gitea API URL must be HTTP(ÊX
+
+Required behavior:
+
+- Determine which env/config key is projected into the current contract overlay.
+- Compare the deployed overlay with V2R2C1 known-good configuration/deployment manifests.
+- Restore a valid `HTTP://` or `HTTPS://` Gitea API base URL.
+- Add startup config validation so invalid schemes fail at health/startup with a config-specific message, not during a release check.
+- Never hard-code a different Gitea host if the existing deployment already has a single authoritative source.
+
+## Repair 2 — durable release state permissions
+
+Symptom:
+
+- `getReleaseSaga` → `Permission denied: '/var/lib/aios-gitops/silent-release'`
+
+Required behavior:
+
+- Identify the actual runtime service User/Group.
+- Grant only the required traverse/read/write permissions for the durable state directories the service must use.
+- Prefer ownership + group mode or a specific ACL; keep the directory non-world-writable.
+- Persist the permission in deployment/install logic so restart/reboot does not regress.
+- Verify create/read/update of a staging-only saga state file under the service identity.
+
+## Repair 3 — release version contract
+
+Symptom:
+
+- `getTagPublicationStatus("V2R2C1")` → `invalid release version`
+- The same runtime exposes `V2R2C1` as `approved_release_version`.
+
+Required behavior:
+
+- Locate all version validators; consolidate onto one canonical parser.
+- Accept the AIOS canonical namespace `^V[0-9]+R[0-9]+C[0-9]+$`.
+- Preserve any additional already-supported legacy formats unless they are security-sensitive.
+ - Add contract tests proving that the version accepted by capabilities is accepted by status, candidate, consistency, acceptance, and tag publication.
+
+## Repair 4 — `commitFilesGoverned` schema parity
+
+Symptom:
+
+- Runtime capability metadata requires `files`.
+- Published Action tool schema does not expose `files`.
+- Call reaches Bridge and fails `BRIDGE_REQUEST_FIELDS_MISSING`.
+
+Required behavior:
+
+- Find the canonical runtime operation contract.
+- Generate the external tool schema from the same source of truth; do not manually copy a parallel schema.
+- `files` must be required and must represent a list of file objects with at least `path` and `content_base64`.
+- Add a parity test that compares runtime required fields with published Action required fields.
+- Add a real governed commit test that writes two test files to an isolated `agent/` ibranch and verifies remote OID.
+
+## Repair 5 — terminal reconciliation
+
+Symptom:
+
+- A governed job read back as `COMPLETED' but `reconcileGitOpsJob` failed `DURABLE_BINDING_INVALID`.
+
+Required behavior:
+
+- Reconciling a terminal successful job must be idempotent.
+- An expired writer lease must not invalidate a durable binding for a job that is already terminal.
+- Active-job reconciliation may require a live lease; terminal read-back must not.
+- Add cases for COMPLETED, FAILED, CANCELLED / equivalent terminal states.
+
+## Repair 6 — bounded `getDiff` output
+
+Symptom:
+
+- Large valid diffs fail with `ResponseTooLargeError` or `GIT_OUTPUT_LIMIT_EXCEEDED`.
+
+Required behavior:
+
+- Do not load unbounded diff text into the Action response.
+- Return bounded summary data: commit identities, changed paths/stats, total bytes, and `truncated: true` when the full patch exceeds the safe limit.
+- If pagination already exists in the contract use it; otherwise prefer deterministic truncation over a breaking schema change.
+- Add tests for small, empty, and oversize diffs.
+
+## Staging deployment procedure
+
+1. Run the existing mandatory test suite before modification; record baseline.
+2. Apply code and config changes only on the governed branch/worktree.
+3. Run focused regression tests.
+4. Run the full mandatory suite.
+5. Build the staging contract overlay using the repository's existing build/deploy path.
+6. Deploy to staging/non-production only.
+7. If systemd units are changed: `systemctl daemon-reload`, then restart only the affected staging services.
+8. Wait for the existing health endpoint/runtime status to become healthy.
+9. Run the acceptance suite below.
+
+If any step fails:
+- collect `journalctl` logs and relevant app logs;
+- diagnose root cause;
+- automatically repair and retry when non-destructive;
+- if a new change breaks staging, restore the previous staging artifact/config and restart the affected service;
+- never silently continue after a failed gate.
+
+## Acceptance suite
+
+All of the following must pass on the same deployed staging overlay:
+
+- Runtime status is `active` and healthy after restart.
+- Gitea Git/API readback works from the runtime service identity.
+- `getReleaseConsistency(V2R2C1, 998d30304787e31e5ae607c0bd86b5edb2b0e5ad, a8b906d1bc24088c19647e98de6a679268f6d0a2, approved_plan) returns a structured result and reaches evaluation.
+- `runReleaseAcceptance` for the same identities reaches policy evaluation, not URL validation error.
+- `getTagPublicationStatus("V2R2C1")` returns structured state, not `invalid release version`.
+- `getReleaseSaga` for a nonexistent candidate returns NOT_FOUND/empty-state semantics, not filesystem permission failure.
+- `commitFilesGoverned` exposes its required `files` parameter in the published Action schema.
+ - A real two-file governed commit to an isolated `agent/` branch succeeds and remote branch OID matches.
+- Resuming a COMPLETED job returns the existing `JOB_TERMINAL` semantics or idempotent success as designed.
+- Reconciling a COMPLETED governed job is successful/idempotent and does not require an active lease.
+- Small/empty `getDiff  still works.
+- Large `getDiff` returns bounded output with truncation metadata instead of a transport exception.
+- Existing protected-ref controls remain unchange: no direct main/tag/baseline/production write.
+
+## Restart / reboot persistence
+
+After the first full pass:
+
+- Restart the staging Action/Bridge/release services one more time without changing files.
+- Rerun the acceptance suite.
+- Permissions, Gitea URL, and schema must still be correct after restart.
+- If the repository already has a safe staging reboot test, run it as well.
+
+## Evidence and completion
+
+Create a single durable report in the repository, e.g. `reports/action-contract-repair-evidence-20260825.md`, containing:
+
+- pre-change facts
+- root cause for each regression
+- files changed and why
+- config/permission changes
+- test commands and exact results
+- staging deployment identity (commit/artifact/config digest)
+- restart-persistence results
+- final Action smoke results
+- any remaining risks
+
+Commit all source, test, deployment config, and runbook changes to the governed task branch. Do not mark the task SUCCEEDED until all acceptance gates pass on the actually deployed staging overlay.
+
+## Automatic rollback conditions
+
+Automatically roll back the staging deployment if any of the following occur:
+
+- service fails to become healthy after restart
+- protected-ref write boundary is broken
+- Gitea readback that worked before the change stops working
+- durable saga state cannot be read or recovered
+- mandatory test suite regresses below the pre-change baseline
+
+Do not automatically roll back an existing production release. Rollback here refers only to the staging overlay/service configuration changes made by this task.

scripts/build_agent_task_api.py

@@ -1,101 +0,0 @@
-#!/usr/bin/env python3
-"""Build deterministic immutable staging artifact for AIOS Agent Task API."""
-from __future__ import annotations
-
-import argparse
-import hashlib
-import json
-from pathlib import Path
-import tarfile
-import tempfile
-
-
-REQUIRED = (
-    "active-runtime/app/aios_agent_task_protocol.py",
-    "active-runtime/app/aios_agent_task_api.py",
-    "active-runtime/app/aios_capability_contract.py",
-    "docs/gitops/openapi-agent-task-v1.yaml",
-)
-
-
-def sha256(path: Path) -> str:
-    digest = hashlib.sha256()
-    with path.open("rb") as source:
-        for chunk in iter(lambda: source.read(1024 * 1024), b""):
-            digest.update(chunk)
-    return digest.hexdigest()
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--source-root", required=True, type=Path)
-    parser.add_argument("--output-root", required=True, type=Path)
-    parser.add_argument("--source-oid", required=True)
-    args = parser.parse_args()
-
-    oid = args.source_oid.strip().lower()
-    if len(oid) != 40 or any(ch not in "0123456789abcdef" for ch in oid):
-        raise SystemExit("source oid must be exact 40 hex")
-    source = args.source_root.resolve(strict=True)
-    output = args.output_root.resolve()
-    for relative in REQUIRED:
-        if not (source / relative).is_file():
-            raise SystemExit("required source missing: " + relative)
-
-    output.mkdir(parents=True, exist_ok=True)
-    archive = output / f"aios-agent-task-api-{oid}.tar.gz"
-    manifest = {
-        "schema": "aios.agent-task-artifact.v1",
-        "source_oid": oid,
-        "repository_identity": "aios/aios",
-        "deployment_state": "STAGING",
-        "runtime_mode": "IMMUTABLE_STAGING",
-        "entrypoint": "app/aios_agent_task_api.py",
-        "listen": "127.0.0.1:18940",
-        "plaintext_credentials_in_artifact": False,
-        "included_paths": list(REQUIRED),
-    }
-
-    with tempfile.TemporaryDirectory(prefix="agent-task-build-", dir=str(output)) as temp:
-        stage = Path(temp) / "runtime"
-        for relative in REQUIRED:
-            src = source / relative
-            if relative.startswith("active-runtime/"):
-                dest = stage / Path(relative).relative_to("active-runtime")
-            else:
-                dest = stage / relative
-            dest.parent.mkdir(parents=True, exist_ok=True)
-            dest.write_bytes(src.read_bytes())
-        (stage / "manifest.json").write_text(
-            json.dumps(manifest, sort_keys=True, indent=2) + "\n",
-            encoding="utf-8",
-        )
-        with tarfile.open(archive, "w:gz", format=tarfile.PAX_FORMAT) as tar:
-            for path in sorted(stage.rglob("*")):
-                arcname = str(path.relative_to(stage.parent)).replace("\\", "/")
-                info = tar.gettarinfo(str(path), arcname=arcname)
-                info.mtime = 0
-                info.uid = info.gid = 0
-                info.uname = info.gname = "root"
-                if path.is_file():
-                    with path.open("rb") as fh:
-                        tar.addfile(info, fh)
-                else:
-                    tar.addfile(info)
-
-    receipt = {
-        **manifest,
-        "artifact_path": str(archive),
-        "artifact_sha256": sha256(archive),
-    }
-    receipt_path = archive.with_suffix(archive.suffix + ".receipt.json")
-    receipt_path.write_text(
-        json.dumps(receipt, sort_keys=True, indent=2) + "\n",
-        encoding="utf-8",
-    )
-    print(json.dumps(receipt, sort_keys=True, indent=2))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

scripts/build_v2r2c1_model_api_staging.py

@@ -5,6 +5,7 @@ import hashlib
 import json
 import os
 from pathlib import Path
+import sys
 import tarfile
 import tempfile
 
@@ -18,6 +19,18 @@ REQUIRED_APP = (
     'silent_release_controller.py',
     'silent_release_hardening.py',
     'aios_gitops_job_controller.py',
+    'aios_chatgpt_bridge_v2.py',
+    'aios_chatgpt_bridge_v2_server.py',
+    'governed_production_release.py',
+    'v2r2c1_production_adapter.py',
+    'v2r1c7_production_adapter.py',
+    'aios_governed_task_bootstrap.py',
+    'aios_continuation_executor.py',
+    'aios_continuation_lease.py',
+    'aios_authority_git_executor.py',
+    'aios_gitops_reconciliation_core.py',
+    'authorized_task_writer_provisioning.py',
+    'signer_contract_compatibility.py',
 )
 OPTIONAL_APP = (
     'aios_chatgpt_actions_api.py',
@@ -56,11 +69,18 @@ def main() -> int:
     source = args.source_root.resolve(strict=True)
     output = args.output_root.resolve()
     app = source / 'active-runtime' / 'app'
+    sys.path.insert(0, str(app))
+    from aios_chatgpt_bridge_v2 import render_openapi_contract_fragment
+
     runtime = source / 'runtime' / 'agent-os'
     docs = source / 'docs' / 'gitops'
     if not app.is_dir():
         raise SystemExit('active-runtime/app missing')
     paths = []
+    root_version = source / 'release_version.py'
+    if not root_version.is_file():
+        raise SystemExit('required source dependency missing: release_version.py')
+    paths.append((Path('release_version.py'), root_version))
     for name in REQUIRED_APP:
         path = app / name
         if not path.is_file():
@@ -77,6 +97,8 @@ def main() -> int:
         paths.append((Path('runtime-agent-os') / rel, path))
     openapi = docs / 'openapi-chatgpt-actions.yaml'
     if openapi.is_file():
+        if '  /v2/commit-files:' not in openapi.read_text(encoding='utf-8'):
+            raise SystemExit('published OpenAPI is missing generated commitFilesGoverned contract')
         paths.append((Path('docs') / 'gitops' / 'openapi-chatgpt-actions.yaml', openapi))
     for folder in ('config/model_registry', 'config/model_priority', 'patches', 'versions'):
         root = source / folder

scripts/release_version.sh

@@ -9,10 +9,16 @@ WORKSPACE="${AIOS_GITOPS_WORKSPACE:-/data/aios-gitops/workspace}"
 TAG_REMOTE="${AIOS_GITOPS_GITEA_REMOTE:-gitea}"
 BRANCH_REMOTE="${AIOS_GITOPS_BRANCH_REMOTE:-gitea}"
 
-case "$VERSION" in
-  V[0-9]*R[0-9]*C[0-9]*) ;;
-  *) echo "ERROR: version must match VxRxCx" >&2; exit 64 ;;
-esac
+SCRIPT_ROOT="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
+if ! PYTHONPATH="$SCRIPT_ROOT:${PYTHONPATH:-}" python3 - "$VERSION" <<'PY'
+import sys
+from release_version import validate_release_version
+validate_release_version(sys.argv[1])
+PY
+then
+  echo "ERROR: version must match VxRxCx" >&2
+  exit 64
+fi
 
 for value in "$TARGET_OID" "$EVIDENCE_CLOSURE_OID"; do
   [[ "$value" =~ ^[0-9a-f]{40}$ ]] || {

services/aios-release-controller/aios_release_controller/manifest.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 import hashlib,json,re,tarfile
+from release_version import RELEASE_VERSION_RE
 from pathlib import Path
 from typing import Any
-OID_RE=re.compile(r"^[0-9a-f]{40}$"); SHA_RE=re.compile(r"^[0-9a-f]{64}$"); VERSION_RE=re.compile(r"^V[0-9]+R[0-9]+C[0-9]+(?:-[A-Za-z0-9_.-]+)?$")
+OID_RE=re.compile(r"^[0-9a-f]{40}$"); SHA_RE=re.compile(r"^[0-9a-f]{64}$"); VERSION_RE=RELEASE_VERSION_RE
 REQUIRED_SOURCE={"schema","version","repository","base_ref","base_oid","binding_mode","release_readiness","production_deployed","tag_created","baseline_changed","production_service","production_port","rollback_metadata","controller_schema","required_checks"}
 REQUEST_KEYS={"schema","version","repository","base_oid","target_oid","artifact_uri","artifact_sha256","artifact_size","evidence_closure_oid","approval_plan_id","execute","production_deployed","production_service","production_port","rollback_metadata","current_tag_oid","source_manifest_sha256"}
 class ManifestValidationError(ValueError):

tests/contract-integration-a.txt

@@ -0,0 +1 @@
+action-contract-integration-a

tests/contract-integration-b.txt

@@ -0,0 +1 @@
+action-contract-integration-b

tests/test_action_contract_regressions.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+from aios_chatgpt_bridge_v2 import (  # noqa: E402
+    OPERATION_REQUIRED_FIELDS,
+    operation_contracts,
+    render_openapi_contract_fragment,
+)
+from aios_chatgpt_bridge_v2_server import GovernedRuntime  # noqa: E402
+from aios_gitops_job_controller import JobState  # noqa: E402
+from gitea_tag_publication import validate_gitea_api_url  # noqa: E402
+from release_version import validate_release_version  # noqa: E402
+
+
+def test_canonical_release_version_is_shared_and_accepts_v2r2c1():
+    assert validate_release_version("V2R2C1") == "V2R2C1"
+    assert validate_release_version("V2R2C1-repair") == "V2R2C1-repair"
+    with pytest.raises(ValueError):
+        validate_release_version("v2r2c1")
+
+
+def test_gitea_url_validation_is_startup_safe():
+    assert validate_gitea_api_url("https://g.cnnetmkt.top/git/api/v1") == (
+        "https://g.cnnetmkt.top/git/api/v1"
+    )
+    with pytest.raises(ValueError, match="HTTP"):
+        validate_gitea_api_url("g.cnnetmkt.top/git/api/v1")
+
+
+def test_commit_files_runtime_and_published_schema_have_same_required_fields():
+    runtime = operation_contracts()["commitFilesGoverned"]["required_fields"]
+    assert runtime == list(OPERATION_REQUIRED_FIELDS["commitFilesGoverned"])
+    fragment = render_openapi_contract_fragment()
+    published = (ROOT / "docs/gitops/openapi-chatgpt-actions.yaml").read_text()
+    assert fragment in published
+    for field in runtime:
+        assert f"                - {field}" in fragment
+    assert "required: [path, content_base64]" in fragment
+
+
+class _Store:
+    def __init__(self, row):
+        self.row = row
+        self.receipt_calls = 0
+
+    def read(self, _job_id):
+        return self.row
+
+    def _receipt(self, row, duplicate=False):
+        self.receipt_calls += 1
+        return type("Receipt", (), {"as_dict": lambda _self: {
+            "job_id": row["job_id"],
+            "state": row["state"],
+            "duplicate": duplicate,
+        }})()
+
+
+class _Controller:
+    def __init__(self, row):
+        self.store = _Store(row)
+
+
+def _runtime_for(row):
+    runtime = object.__new__(GovernedRuntime)
+    controller = _Controller(row)
+    runtime._controller_for_job = lambda _job_id: controller
+    runtime._executor_from_row = lambda *_args: (_ for _ in ()).throw(
+        AssertionError("terminal reconcile must not reconstruct an executor")
+    )
+    return runtime, controller
+
+
+@pytest.mark.parametrize(
+    "state",
+    [
+        JobState.COMPLETED.value,
+        JobState.FAILED.value,
+        JobState.CANCELLED.value,
+        JobState.MANUAL_OWNER_REVIEW_REQUIRED.value,
+    ],
+)
+def test_terminal_reconcile_is_idempotent_without_durable_binding(state):
+    row = {
+        "job_id": "job-terminal",
+        "state": state,
+        "request_json": json.dumps({}),
+    }
+    runtime, controller = _runtime_for(row)
+    result = GovernedRuntime.job(runtime, {"job_id": row["job_id"]}, "reconcile")
+    assert result["duplicate"] is True
+    assert controller.store.receipt_calls == 1
+
+
+def test_active_reconcile_still_uses_executor():
+    row = {
+        "job_id": "job-active",
+        "state": JobState.RECONCILIATION_REQUIRED.value,
+        "request_json": json.dumps({}),
+    }
+    runtime, controller = _runtime_for(row)
+    class Executor:
+        def reconcile(self, job_id):
+            return {"job_id": job_id, "state": "COMPLETED"}
+    runtime._executor_from_row = lambda *_args: Executor()
+    assert GovernedRuntime.job(runtime, {"job_id": row["job_id"]}, "reconcile") == {
+        "job_id": "job-active",
+        "state": "COMPLETED",
+    }

tests/test_agent_task_protocol.py

@@ -1,317 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime, timedelta, timezone
-from pathlib import Path
-import threading
-
-import pytest
-
-from aios_agent_task_protocol import TaskProtocolError, TaskStore
-
-
-class Clock:
-    def __init__(self) -> None:
-        self.value = datetime(2026, 8, 9, 12, 0, tzinfo=timezone.utc)
-
-    def __call__(self) -> datetime:
-        return self.value
-
-    def advance(self, seconds: int) -> None:
-        self.value += timedelta(seconds=seconds)
-
-
-@pytest.fixture
-def env(tmp_path: Path):
-    clock = Clock()
-    store = TaskStore(tmp_path / "tasks.sqlite3", now=clock, token_pepper="test-pepper")
-    a1 = store.register_agent(
-        agent_id="openclaw-1",
-        agent_type="openclaw",
-        agent_version="test",
-        capabilities=["shell", "git", "python"],
-    )
-    a2 = store.register_agent(
-        agent_id="hermes-1",
-        agent_type="hermes",
-        agent_version="test",
-        capabilities=["shell", "git", "python"],
-    )
-    return store, clock, a1, a2
-
-
-def create_task(store: TaskStore, task_id: str = "TASK-ONLINE-001"):
-    return store.create_task(
-        task_id=task_id,
-        goal="Create a deterministic validation artifact",
-        instructions="Write validation.txt containing ONLINE_TASK_OK.",
-        success_criteria=[
-            {"type": "file_exists", "path": "validation.txt"},
-            {"type": "contains", "path": "validation.txt", "value": "ONLINE_TASK_OK"},
-        ],
-        required_capabilities=["shell"],
-        constraints={"network": "optional"},
-        metadata={"suite": "online-task"},
-        priority=10,
-        max_attempts=3,
-        idempotency_key="create:" + task_id,
-    )
-
-
-def test_full_flow_requires_server_verification(env):
-    store, _clock, a1, _a2 = env
-    create_task(store)
-
-    polled = store.poll_tasks(agent_id=a1["agent_id"])
-    assert [item["task_id"] for item in polled] == ["TASK-ONLINE-001"]
-
-    claim = store.claim_task(
-        task_id="TASK-ONLINE-001",
-        agent_id=a1["agent_id"],
-        lease_seconds=300,
-    )
-    assert claim["status"] == "CLAIMED"
-    assert claim["lease_token"].startswith("lease_")
-
-    running = store.heartbeat(
-        task_id="TASK-ONLINE-001",
-        agent_id=a1["agent_id"],
-        lease_token=claim["lease_token"],
-        progress={"percent": 50},
-        lease_seconds=300,
-    )
-    assert running["status"] == "RUNNING"
-
-    submitted = store.submit_result(
-        task_id="TASK-ONLINE-001",
-        agent_id=a1["agent_id"],
-        lease_token=claim["lease_token"],
-        idempotency_key="result:1",
-        result={
-            "status": "completed",
-            "summary": "Created validation.txt",
-            "artifacts": [{"path": "validation.txt", "sha256": "0" * 64}],
-        },
-    )
-    assert submitted["status"] == "VERIFYING"
-    assert submitted["status"] != "SUCCEEDED"
-
-    verified = store.verify_task(
-        task_id="TASK-ONLINE-001",
-        decision="SUCCEEDED",
-        verification={"checks": {"content": "PASS"}},
-    )
-    assert verified["status"] == "SUCCEEDED"
-
-
-def test_atomic_claim_allows_only_one_agent(env):
-    store, _clock, a1, a2 = env
-    create_task(store)
-    outcomes: list[tuple[str, str]] = []
-    barrier = threading.Barrier(2)
-
-    def runner(agent_id: str) -> None:
-        barrier.wait()
-        try:
-            store.claim_task(
-                task_id="TASK-ONLINE-001",
-                agent_id=agent_id,
-                lease_seconds=300,
-            )
-            outcomes.append((agent_id, "CLAIMED"))
-        except TaskProtocolError as exc:
-            outcomes.append((agent_id, exc.code))
-
-    t1 = threading.Thread(target=runner, args=(a1["agent_id"],))
-    t2 = threading.Thread(target=runner, args=(a2["agent_id"],))
-    t1.start()
-    t2.start()
-    t1.join()
-    t2.join()
-
-    assert sum(result == "CLAIMED" for _, result in outcomes) == 1
-    assert sum(result in {"TASK_NOT_CLAIMABLE", "TASK_CLAIM_CONFLICT"} for _, result in outcomes) == 1
-
-
-def test_expired_lease_is_requeued_and_reclaimable(env):
-    store, clock, a1, a2 = env
-    create_task(store)
-    first = store.claim_task(
-        task_id="TASK-ONLINE-001",
-        agent_id=a1["agent_id"],
-        lease_seconds=30,
-    )
-    assert first["attempt"] == 1
-
-    clock.advance(31)
-    available = store.poll_tasks(agent_id=a2["agent_id"])
-    assert available[0]["status"] == "QUEUED"
-
-    second = store.claim_task(
-        task_id="TASK-ONLINE-001",
-        agent_id=a2["agent_id"],
-        lease_seconds=30,
-    )
-    assert second["attempt"] == 2
-    assert second["claimed_by"] == a2["agent_id"]
-
-
-def test_wrong_lease_token_is_rejected(env):
-    store, _clock, a1, _a2 = env
-    create_task(store)
-    store.claim_task(
-        task_id="TASK-ONLINE-001",
-        agent_id=a1["agent_id"],
-        lease_seconds=300,
-    )
-    with pytest.raises(TaskProtocolError, match="TASK_LEASE_TOKEN_INVALID"):
-        store.heartbeat(
-            task_id="TASK-ONLINE-001",
-            agent_id=a1["agent_id"],
-            lease_token="lease_wrong",
-            progress={},
-        )
-
-
-def test_result_submission_is_idempotent(env):
-    store, _clock, a1, _a2 = env
-    create_task(store)
-    claim = store.claim_task(
-        task_id="TASK-ONLINE-001",
-        agent_id=a1["agent_id"],
-        lease_seconds=300,
-    )
-    payload = {"status": "completed", "summary": "ok"}
-    first = store.submit_result(
-        task_id="TASK-ONLINE-001",
-        agent_id=a1["agent_id"],
-        lease_token=claim["lease_token"],
-        idempotency_key="result:same",
-        result=payload,
-    )
-    second = store.submit_result(
-        task_id="TASK-ONLINE-001",
-        agent_id=a1["agent_id"],
-        lease_token=claim["lease_token"],
-        idempotency_key="result:same",
-        result=payload,
-    )
-    assert first["status"] == "VERIFYING"
-    assert second["status"] == "VERIFYING"
-    assert second["idempotent"] is True
-
-    with pytest.raises(TaskProtocolError, match="IDEMPOTENCY_CONFLICT"):
-        store.submit_result(
-            task_id="TASK-ONLINE-001",
-            agent_id=a1["agent_id"],
-            lease_token=claim["lease_token"],
-            idempotency_key="result:same",
-            result={"status": "completed", "summary": "different"},
-        )
-
-
-def test_needs_rework_returns_to_queue(env):
-    store, _clock, a1, _a2 = env
-    create_task(store)
-    claim = store.claim_task(
-        task_id="TASK-ONLINE-001",
-        agent_id=a1["agent_id"],
-        lease_seconds=300,
-    )
-    store.submit_result(
-        task_id="TASK-ONLINE-001",
-        agent_id=a1["agent_id"],
-        lease_token=claim["lease_token"],
-        idempotency_key="result:1",
-        result={"status": "completed"},
-    )
-    result = store.verify_task(
-        task_id="TASK-ONLINE-001",
-        decision="NEEDS_REWORK",
-        verification={"reason": "success criteria not met"},
-    )
-    assert result["status"] == "QUEUED"
-    assert result["claimed_by"] is None
-
-
-def test_capability_filter(env):
-    store, _clock, a1, _a2 = env
-    store.create_task(
-        task_id="TASK-GPU-001",
-        goal="GPU task",
-        instructions="Run GPU workload",
-        success_criteria=[],
-        required_capabilities=["gpu"],
-        idempotency_key="create:gpu",
-    )
-    assert store.poll_tasks(agent_id=a1["agent_id"]) == []
-
-
-def test_create_task_idempotency_conflict(env):
-    store, _clock, _a1, _a2 = env
-    first = create_task(store)
-    replay = create_task(store)
-    assert first["task_id"] == replay["task_id"]
-    assert replay["idempotent"] is True
-
-    with pytest.raises(TaskProtocolError, match="IDEMPOTENCY_CONFLICT"):
-        store.create_task(
-            task_id="TASK-ONLINE-002",
-            goal="different",
-            instructions="different",
-            success_criteria=[],
-            idempotency_key="create:TASK-ONLINE-001",
-        )
-
-
-def test_terminal_success_retains_executing_agent_for_final_readback(env):
-    store, _clock, a1, _a2 = env
-    create_task(store, "TASK-TERMINAL-READBACK")
-    claim = store.claim_task(
-        task_id="TASK-TERMINAL-READBACK",
-        agent_id=a1["agent_id"],
-        lease_seconds=120,
-    )
-    store.submit_result(
-        task_id="TASK-TERMINAL-READBACK",
-        agent_id=a1["agent_id"],
-        lease_token=claim["lease_token"],
-        idempotency_key="terminal-result",
-        result={"status": "completed"},
-    )
-    final = store.verify_task(
-        task_id="TASK-TERMINAL-READBACK",
-        decision="SUCCEEDED",
-        verification={"criteria": "PASS"},
-    )
-    assert final["status"] == "SUCCEEDED"
-    assert final["claimed_by"] == a1["agent_id"]
-
-
-def test_needs_rework_releases_agent_ownership_for_reclaim(env):
-    store, _clock, a1, a2 = env
-    create_task(store, "TASK-REWORK-OWNERSHIP")
-    claim = store.claim_task(
-        task_id="TASK-REWORK-OWNERSHIP",
-        agent_id=a1["agent_id"],
-        lease_seconds=120,
-    )
-    store.submit_result(
-        task_id="TASK-REWORK-OWNERSHIP",
-        agent_id=a1["agent_id"],
-        lease_token=claim["lease_token"],
-        idempotency_key="rework-owner-result",
-        result={"status": "completed"},
-    )
-    requeued = store.verify_task(
-        task_id="TASK-REWORK-OWNERSHIP",
-        decision="NEEDS_REWORK",
-        verification={"criteria": "FAIL"},
-    )
-    assert requeued["status"] == "QUEUED"
-    assert requeued["claimed_by"] is None
-    reclaimed = store.claim_task(
-        task_id="TASK-REWORK-OWNERSHIP",
-        agent_id=a2["agent_id"],
-        lease_seconds=120,
-    )
-    assert reclaimed["claimed_by"] == a2["agent_id"]

tests/test_branch_binding_contract.py

@@ -1,105 +0,0 @@
-from __future__ import annotations
-
-import json
-import sqlite3
-
-import pytest
-
-from aios_continuation_lease import ContinuationError, WriterLeaseRequestV2
-from aios_gitops_job_controller import GitOpsJobController, JobError, JobStore
-
-
-BASE_OID = "3244f0f17f8845592ac94d585f5ebd65693c9f29"
-FULL_BRANCH = "agent/r4p0-writerlease-correctness-20260816"
-
-
-class CreateNewProbe:
-    def branch_exists(self, branch):
-        return False
-
-    def commit_exists(self, oid):
-        return True
-
-
-def _job_request(target_branch=FULL_BRANCH, branch=FULL_BRANCH):
-    return {
-        "campaign_id": "governance-contract-remediation-20260816",
-        "repository": "aios/aios",
-        "operation": "GOVERNED_COMMIT",
-        "branch": branch,
-        "target_branch": target_branch,
-        "expected_branch_oid": BASE_OID,
-        "payload_digest": "a" * 64,
-        "idempotency_key": "governance-contract-remediation-v1",
-    }
-
-
-def test_writer_lease_branch_round_trip_preserves_full_regression_value():
-    request = WriterLeaseRequestV2(
-        task_id="governance-contract-remediation-20260816",
-        repository="aios/aios",
-        branch_mode="CREATE_NEW",
-        base_oid=BASE_OID,
-        expected_branch_oid=BASE_OID,
-        target_branch=FULL_BRANCH,
-        generation=1,
-        lease_seconds=900,
-    )
-    request.validate(CreateNewProbe())
-    assert request.target_branch == FULL_BRANCH
-
-
-def test_job_binding_round_trip_keeps_branch_and_target_branch_exact(tmp_path):
-    store = JobStore(str(tmp_path / "jobs"))
-    receipt = GitOpsJobController(store).submit(_job_request())
-    binding = store.read(receipt.job_id)
-    assert binding["branch"] == FULL_BRANCH
-    assert json.loads(binding["request_json"])["binding"]["target_branch"] == FULL_BRANCH
-
-
-def test_mismatched_alias_fails_closed_before_persisting_job(tmp_path):
-    root = tmp_path / "jobs"
-    store = JobStore(str(root))
-    request = _job_request(
-        target_branch="agent/r4p0-writerlease-correctness-2026",
-        branch=FULL_BRANCH,
-    )
-    with pytest.raises(JobError, match="TARGET_BRANCH_BINDING_CONFLICT"):
-        GitOpsJobController(store).submit(request)
-
-    connection = sqlite3.connect(root / "state.sqlite3")
-    try:
-        assert connection.execute("SELECT COUNT(*) FROM jobs").fetchone()[0] == 0
-    finally:
-        connection.close()
-
-
-def test_damaged_persisted_alias_fails_closed(tmp_path):
-    root = tmp_path / "jobs"
-    store = JobStore(str(root))
-    receipt = GitOpsJobController(store).submit(_job_request())
-    connection = sqlite3.connect(root / "state.sqlite3")
-    try:
-        damaged = json.dumps({"binding": {**_job_request(), "target_branch": "agent/r4p0-writerlease-correctness-2026"}})
-        connection.execute("UPDATE jobs SET request_json=? WHERE job_id=?", (damaged, receipt.job_id))
-        connection.commit()
-    finally:
-        connection.close()
-    with pytest.raises(JobError, match="TARGET_BRANCH_BINDING_CONFLICT"):
-        store.read(receipt.job_id)
-
-
-def test_overlong_branch_is_rejected_without_shortening():
-    overlong = "agent/" + ("a" * 181)
-    request = WriterLeaseRequestV2(
-        task_id="governance-contract-remediation-20260816",
-        repository="aios/aios",
-        branch_mode="CREATE_NEW",
-        base_oid=BASE_OID,
-        expected_branch_oid=BASE_OID,
-        target_branch=overlong,
-        generation=1,
-        lease_seconds=900,
-    )
-    with pytest.raises(ContinuationError, match="target_branch_invalid"):
-        request.validate(CreateNewProbe())

tests/test_capability_contract.py

@@ -1,106 +0,0 @@
-from __future__ import annotations
-
-import pytest
-
-from aios_capability_contract import (
-    has_capabilities,
-    normalize_required_capabilities,
-    normalize_worker_capabilities,
-)
-from aios_agent_task_protocol import TaskProtocolError, TaskStore
-from task_plane.capabilities import has_capabilities as legacy_has_capabilities
-
-
-def test_task_worker_aliases_and_composite_write():
-    assert has_capabilities(["git.read"], ["repository_read"])
-    assert has_capabilities(["git.test"], ["test_execution"])
-    assert has_capabilities(
-        ["governed.write.branch", "governed.write.file"],
-        ["governed_git_write"],
-    )
-    assert legacy_has_capabilities(["git.read"], ["repository_read"])
-
-
-@pytest.mark.parametrize(
-    ("required", "worker"),
-    [
-        (["governed_git_write"], ["governed.write.file"]),
-        (["governed_git_write"], ["governed.write.branch"]),
-        (["governed.write.branch"], ["governed.write.file"]),
-        (["production.superuser"], ["git.read"]),
-        (["mystery.capability"], ["mystery.capability"]),
-        (["git.*"], ["git.read"]),
-        (["git.read*"], ["git.read"]),
-    ],
-)
-def test_capability_matching_fails_closed(required, worker):
-    assert not has_capabilities(required, worker)
-
-
-def test_security_boundaries_do_not_expand_capabilities():
-    assert not has_capabilities(
-        ["governed.write.branch", "governed.write.file"], ["production.superuser"]
-    )
-    assert not has_capabilities(
-        ["governed.write.branch", "governed.write.file"], ["main.write"]
-    )
-    assert not has_capabilities(["git.test"], ["runtime.shell"])
-    assert not has_capabilities(["git.read"], ["governed_git_write"])
-
-
-def test_duplicate_aliases_normalize_to_one_semantic_capability():
-    assert normalize_required_capabilities(
-        ["repository_read", "git.read", "repo.read"]
-    ) == {"repo.read"}
-    assert normalize_worker_capabilities(["git.read", "repo.read"]) == {"repo.read"}
-
-
-def test_poll_and_claim_share_the_same_matcher(tmp_path):
-    store = TaskStore(tmp_path / "tasks.sqlite3")
-    store.register_agent(
-        agent_id="agent-1",
-        agent_type="test-worker",
-        agent_version="test",
-        capabilities=["git.read", "git.test"],
-    )
-    task_id = "task-capability-contract"
-    store.create_task(
-        task_id=task_id,
-        goal="capability contract",
-        instructions="run the contract test",
-        success_criteria=[],
-        required_capabilities=["repository_read", "test_execution"],
-        idempotency_key="capability-contract-v1",
-    )
-
-    eligible = store.poll_tasks(agent_id="agent-1", limit=10)
-    assert [row["task_id"] for row in eligible] == [task_id]
-
-    claimed = store.claim_task(task_id=task_id, agent_id="agent-1")
-    assert claimed["task_id"] == task_id
-    assert claimed["claimed_by"] == "agent-1"
-
-
-def test_poll_and_claim_reject_the_same_ineligible_worker(tmp_path):
-    store = TaskStore(tmp_path / "tasks.sqlite3")
-    store.register_agent(
-        agent_id="agent-file-only",
-        agent_type="test-worker",
-        agent_version="test",
-        capabilities=["governed.write.file"],
-    )
-    task_id = "task-write-contract"
-    store.create_task(
-        task_id=task_id,
-        goal="write capability contract",
-        instructions="run the contract test",
-        success_criteria=[],
-        required_capabilities=["governed_git_write"],
-        idempotency_key="write-contract-v1",
-    )
-
-    eligible = store.poll_tasks(agent_id="agent-file-only", limit=10)
-    assert eligible == []
-
-    with pytest.raises(TaskProtocolError, match="AGENT_CAPABILITY_MISMATCH"):
-        store.claim_task(task_id=task_id, agent_id="agent-file-only")