open-xmen 0.1.0

package/.cerebro/scripts/test-stop-hook.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python3
+"""Exercise OpenCode-native Cerebro pending-todo blocking behavior."""
+
+from pathlib import Path
+
+
+TODO_FILE = Path(".cerebro/pending-todos/doctor/worker/task.txt")
+PENDING_ROOT = Path(".cerebro/pending-todos")
+
+
+def main() -> int:
+    previous = TODO_FILE.read_bytes() if TODO_FILE.exists() else None
+
+    TODO_FILE.parent.mkdir(parents=True, exist_ok=True)
+    TODO_FILE.write_text("doctor temporary todo\n", encoding="utf-8")
+
+    try:
+        pending = _pending_items(PENDING_ROOT / "doctor")
+    finally:
+        if previous is None:
+            TODO_FILE.unlink(missing_ok=True)
+            _remove_empty_parents(TODO_FILE.parent)
+        else:
+            TODO_FILE.write_bytes(previous)
+
+    if not pending:
+        print("expected pending todo scan to block final response")
+        return 1
+
+    print("pending todo block decision ok")
+    return 0
+
+
+def _pending_items(root: Path) -> list[tuple[Path, str]]:
+    items = []
+    if not root.exists():
+        return items
+    for path in sorted(root.rglob("*")):
+        if not path.is_file():
+            continue
+        for line in path.read_text(errors="replace").splitlines():
+            if line.strip():
+                items.append((path, line.strip()))
+    return items
+
+
+def _remove_empty_parents(path: Path) -> None:
+    current = path
+    while current != PENDING_ROOT.parent and current.exists():
+        try:
+            current.rmdir()
+        except OSError:
+            break
+        if current == PENDING_ROOT:
+            break
+        current = current.parent
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/.cerebro/scripts/upgrade-latest-tag.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""Resolve the latest version tag from the Cerebro upstream repository."""
+
+import argparse
+import subprocess
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--upstream", default="https://github.com/yelaco/claude-xmen.git")
+    args = parser.parse_args()
+
+    try:
+        result = subprocess.run(
+            ["git", "ls-remote", "--tags", "--sort=-version:refname", args.upstream, "refs/tags/v*"],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except (subprocess.SubprocessError, FileNotFoundError) as exc:
+        print(f"Could not resolve latest upstream tag from {args.upstream}: {exc}")
+        return 1
+
+    for line in result.stdout.splitlines():
+        if "refs/tags/" in line:
+            print(line.rsplit("refs/tags/", 1)[1].removesuffix("^{}"))
+            return 0
+
+    print(f"Could not resolve latest upstream tag from {args.upstream}: no v* tags found")
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/.cerebro/scripts/validate-agent-frontmatter.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""Validate OpenCode agent frontmatter for the active Cerebro runtime."""
+
+from pathlib import Path
+
+
+REQUIRED_AGENTS = {
+    "cerebro",
+    "legion",
+    "cypher",
+    "professor-x",
+    "cyclops",
+    "wolverine",
+    "storm",
+    "forge",
+    "nightcrawler",
+    "sage",
+    "beast",
+    "emma-frost",
+}
+REQUIRED_KEYS = {"description", "mode", "model", "permission"}
+VALID_MODES = {"primary", "subagent"}
+
+
+def main() -> int:
+    failed = []
+    seen = set()
+    agent_dir = Path(".opencode/agents")
+
+    if not agent_dir.is_dir():
+        print("missing .opencode/agents")
+        return 1
+
+    for path in sorted(agent_dir.glob("*.md")):
+        frontmatter, error = _frontmatter(path)
+        if error:
+            failed.append((str(path), error))
+            continue
+
+        name = path.stem
+        seen.add(name)
+        if name not in REQUIRED_AGENTS:
+            failed.append((str(path), f"unexpected agent {name}"))
+
+        missing = sorted(REQUIRED_KEYS - set(frontmatter))
+        if missing:
+            failed.append((str(path), f"missing {missing}"))
+            continue
+
+        if frontmatter["mode"] not in VALID_MODES:
+            failed.append((str(path), f"invalid mode {frontmatter['mode']}"))
+        if name == "cerebro" and frontmatter["mode"] != "primary":
+            failed.append((str(path), "cerebro must use mode: primary"))
+        if name != "cerebro" and frontmatter["mode"] != "subagent":
+            failed.append((str(path), f"{name} must use mode: subagent"))
+
+    missing_agents = sorted(REQUIRED_AGENTS - seen)
+    if missing_agents:
+        failed.append((".opencode/agents", f"missing agents {missing_agents}"))
+
+    if failed:
+        for item in failed:
+            print(item)
+        return 1
+
+    print("opencode agent frontmatter ok")
+    return 0
+
+
+def _frontmatter(path: Path) -> tuple[dict[str, str], str | None]:
+    text = path.read_text(encoding="utf-8")
+    if not text.startswith("---\n"):
+        return {}, "missing frontmatter"
+    end = text.find("\n---\n", 4)
+    if end == -1:
+        return {}, "unterminated frontmatter"
+
+    frontmatter = {}
+    for line in text[4:end].splitlines():
+        if ":" in line and not line.startswith(" "):
+            key, value = line.split(":", 1)
+            frontmatter[key.strip()] = value.strip()
+    return frontmatter, None
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/.cerebro/scripts/validate-boulder.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+"""Validate Cerebro boulder execution state using the local schema contract."""
+
+import json
+from pathlib import Path
+
+
+STATE_PATH = Path(".cerebro/boulder.json")
+SCHEMA_PATH = Path(".cerebro/schemas/boulder.schema.json")
+
+
+def main() -> int:
+    if not SCHEMA_PATH.exists():
+        print("missing schema")
+        return 1
+    if not STATE_PATH.exists():
+        print("no active boulder state")
+        return 0
+
+    state = json.loads(STATE_PATH.read_text())
+    errors = []
+
+    allowed_top = {
+        "version",
+        "active_plan",
+        "plan_name",
+        "status",
+        "risk_level",
+        "team_name",
+        "started_at",
+        "updated_at",
+        "approval_gates",
+        "verification_history",
+        "decisions",
+    }
+    missing = sorted(allowed_top - set(state))
+    extra = sorted(set(state) - allowed_top)
+    if missing:
+        errors.append(f"missing top-level fields: {missing}")
+    if extra:
+        errors.append(f"unexpected top-level fields: {extra}")
+
+    if state.get("version") != 2:
+        errors.append(f"version must be 2, got {state.get('version')!r}")
+    if state.get("status") not in {"not_started", "in_progress", "blocked", "completed"}:
+        errors.append(f"invalid status: {state.get('status')!r}")
+    if state.get("risk_level") not in {"LOW", "MEDIUM", "HIGH"}:
+        errors.append(f"invalid risk_level: {state.get('risk_level')!r}")
+
+    if not isinstance(state.get("approval_gates"), list):
+        errors.append("approval_gates must be an array")
+    else:
+        gate_required = {"name", "status", "decided_at", "decision_by", "notes"}
+        for index, gate in enumerate(state["approval_gates"]):
+            if not isinstance(gate, dict):
+                errors.append(f"approval_gates[{index}] must be an object")
+                continue
+            errors.extend(_check_keys(f"approval_gates[{index}]", gate, gate_required))
+            if gate.get("status") not in {"pending", "approved", "rejected"}:
+                errors.append(f"approval_gates[{index}] invalid status {gate.get('status')!r}")
+
+    if not isinstance(state.get("verification_history"), list):
+        errors.append("verification_history must be an array")
+    else:
+        verify_required = {"command", "result", "verified_at", "notes"}
+        for index, item in enumerate(state["verification_history"]):
+            if not isinstance(item, dict):
+                errors.append(f"verification_history[{index}] must be an object")
+                continue
+            errors.extend(_check_keys(f"verification_history[{index}]", item, verify_required))
+            if item.get("result") not in {"PASS", "FAIL", "BLOCKED"}:
+                errors.append(f"verification_history[{index}] invalid result {item.get('result')!r}")
+
+    if not isinstance(state.get("decisions"), list):
+        errors.append("decisions must be an array")
+    else:
+        decision_required = {"at", "topic", "decision", "rationale"}
+        for index, item in enumerate(state["decisions"]):
+            if not isinstance(item, dict):
+                errors.append(f"decisions[{index}] must be an object")
+                continue
+            errors.extend(_check_keys(f"decisions[{index}]", item, decision_required))
+
+    if errors:
+        for error in errors:
+            print(error)
+        return 1
+
+    print("boulder state schema ok")
+    return 0
+
+
+def _check_keys(label: str, item: dict, required: set[str]) -> list[str]:
+    errors = []
+    missing = sorted(required - set(item))
+    extra = sorted(set(item) - required)
+    if missing:
+        errors.append(f"{label} missing {missing}")
+    if extra:
+        errors.append(f"{label} unexpected {extra}")
+    return errors
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/.cerebro/scripts/validate-opencode-runtime.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Validate Cerebro OpenCode runtime files."""
+
+import re
+from pathlib import Path
+
+REQUIRED_AGENTS = {
+    "cerebro",
+    "legion",
+    "cypher",
+    "professor-x",
+    "cyclops",
+    "wolverine",
+    "storm",
+    "forge",
+    "nightcrawler",
+    "sage",
+    "beast",
+    "emma-frost",
+}
+REQUIRED_COMMANDS = {
+    "cerebro-index",
+    "cerebro-plan",
+    "cerebro-start-work",
+    "cerebro-doctor",
+    "cerebro-reset",
+    "cerebro-upgrade",
+    "to-me-my-x-men",
+}
+MODEL_PATTERN = re.compile(r"openai/[A-Za-z0-9._/-]+")
+
+
+def main() -> int:
+    errors = []
+    for path in [
+        "opencode.jsonc",
+        "AGENTS.md",
+        ".opencode/plugins/open-xmen.ts",
+        ".cerebro/cerebro-identity.md",
+        ".cerebro/opencode/model-routing.md",
+    ]:
+        if not Path(path).is_file():
+            errors.append(f"missing {path}")
+
+    allowed_models = _configured_models(Path(".cerebro/opencode/model-routing.md"))
+
+    agent_dir = Path(".opencode/agents")
+    seen_agents = {path.stem for path in agent_dir.glob("*.md")} if agent_dir.is_dir() else set()
+    for name in sorted(REQUIRED_AGENTS - seen_agents):
+        errors.append(f"missing .opencode/agents/{name}.md")
+    for path in sorted(agent_dir.glob("*.md")):
+        text = path.read_text(encoding="utf-8")
+        if not text.startswith("---\n"):
+            errors.append(f"{path}: missing frontmatter")
+            continue
+        model = _frontmatter_value(text, "model")
+        if model and model not in allowed_models:
+            errors.append(f"{path}: model {model!r} is outside configured model availability")
+
+    command_dir = Path(".opencode/commands")
+    seen_commands = {path.stem for path in command_dir.glob("*.md")} if command_dir.is_dir() else set()
+    for name in sorted(REQUIRED_COMMANDS - seen_commands):
+        errors.append(f"missing .opencode/commands/{name}.md")
+    for path in sorted(command_dir.glob("*.md")):
+        text = path.read_text(encoding="utf-8")
+        if "agent: cerebro" not in text:
+            errors.append(f"{path}: command must route to agent: cerebro")
+
+    if errors:
+        for error in errors:
+            print(error)
+        return 1
+    print("opencode runtime ok")
+    return 0
+
+
+def _frontmatter_value(text: str, key: str) -> str | None:
+    end = text.find("\n---\n", 4)
+    if end == -1:
+        return None
+    for line in text[4:end].splitlines():
+        if line.startswith(key + ":"):
+            return line.split(":", 1)[1].strip()
+    return None
+
+
+def _configured_models(path: Path) -> set[str]:
+    if not path.is_file():
+        return set()
+    return set(MODEL_PATTERN.findall(path.read_text(encoding="utf-8")))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/.cerebro/scripts/validate-team-runs.py

@@ -0,0 +1,310 @@
+#!/usr/bin/env python3
+"""Validate Cerebro team-run manifest template and runtime manifests."""
+
+import json
+from pathlib import Path
+
+
+ALLOWED_COMMANDS = {
+    "/to-me-my-x-men",
+    "/cerebro-plan",
+    "/cerebro-start-work",
+    "/cerebro-index",
+    "/cerebro-doctor",
+    "/cerebro-reset",
+    "/cerebro-upgrade",
+}
+ALLOWED_STATUSES = {"planning", "running", "blocked", "completed", "cleaned_up"}
+ALLOWED_RISKS = {"LOW", "MEDIUM", "HIGH"}
+ALLOWED_AGENTS = {
+    "cerebro",
+    "legion",
+    "cypher",
+    "cyclops",
+    "wolverine",
+    "storm",
+    "professor-x",
+    "beast",
+    "emma-frost",
+    "nightcrawler",
+    "sage",
+    "forge",
+}
+ALLOWED_TEAMMATE_STATUSES = {"pending", "active", "idle", "done", "blocked"}
+ALLOWED_APPROVAL_STATUSES = {"pending", "approved", "rejected"}
+ALLOWED_VERIFICATION_STATUSES = {"NOT RUN", "PASS", "FAIL", "BLOCKED"}
+ALLOWED_TASK_STATUSES = {"pending", "active", "blocked", "done", "verified", "failed"}
+
+
+def main() -> int:
+    manifests = [
+        Path(".cerebro/templates/team-run.json"),
+        *sorted(
+            path
+            for path in Path(".cerebro/team-runs").glob("*.json")
+            if not path.name.endswith(".tasks.json")
+        ),
+    ]
+    task_ledgers = sorted(Path(".cerebro/team-runs").glob("*.tasks.json"))
+    mailbox_logs = sorted(Path(".cerebro/team-runs").glob("*.mailbox.jsonl"))
+    checkpoint_logs = sorted(Path(".cerebro/team-runs").glob("*.checkpoints.jsonl"))
+
+    errors = []
+    for path in manifests:
+        errors.extend(validate_manifest(path))
+    for path in task_ledgers:
+        errors.extend(validate_tasks(path))
+    for path in mailbox_logs:
+        errors.extend(_validate_jsonl(path, _validate_mailbox_record))
+    for path in checkpoint_logs:
+        errors.extend(_validate_jsonl(path, _validate_checkpoint_record))
+
+    if errors:
+        for error in errors:
+            print(error)
+        return 1
+
+    print(
+        "team run runtime files ok "
+        f"({len(manifests)} manifest(s), {len(task_ledgers)} task ledger(s), "
+        f"{len(mailbox_logs)} mailbox log(s), {len(checkpoint_logs)} checkpoint log(s))"
+    )
+    return 0
+
+
+def validate_manifest(path: Path) -> list[str]:
+    data = json.loads(path.read_text())
+    errors = []
+
+    top_required = {
+        "version",
+        "run_id",
+        "command",
+        "status",
+        "lead",
+        "team_name",
+        "objective",
+        "risk_level",
+        "started_at",
+        "updated_at",
+        "teammates",
+        "ownership",
+        "mailbox_decisions",
+        "approvals",
+        "verification",
+        "cleanup",
+    }
+    errors.extend(_check_keys(str(path), data, top_required))
+
+    if data.get("version") != 1:
+        errors.append(f"{path}: version must be 1")
+    if data.get("command") not in ALLOWED_COMMANDS:
+        errors.append(f"{path}: invalid command {data.get('command')!r}")
+    if data.get("status") not in ALLOWED_STATUSES:
+        errors.append(f"{path}: invalid status {data.get('status')!r}")
+    if data.get("lead") != "cerebro":
+        errors.append(f"{path}: lead must be cerebro")
+    if data.get("risk_level") not in ALLOWED_RISKS:
+        errors.append(f"{path}: invalid risk_level {data.get('risk_level')!r}")
+    for key in ("run_id", "team_name", "objective", "started_at", "updated_at"):
+        errors.extend(_non_empty(f"{path}: {key}", data.get(key)))
+
+    for field in ("teammates", "ownership", "mailbox_decisions", "approvals", "verification"):
+        if not isinstance(data.get(field), list):
+            errors.append(f"{path}: {field} must be an array")
+
+    _validate_teammates(path, data.get("teammates", []), errors)
+    _validate_ownership(path, data.get("ownership", []), errors)
+    _validate_mailbox(path, data.get("mailbox_decisions", []), errors)
+    _validate_approvals(path, data.get("approvals", []), errors)
+    _validate_verification(path, data.get("verification", []), errors)
+    _validate_cleanup(path, data.get("cleanup"), errors)
+
+    return errors
+
+
+def validate_tasks(path: Path) -> list[str]:
+    data = json.loads(path.read_text())
+    errors = []
+    if not isinstance(data, list):
+        return [f"{path}: task ledger must be an array"]
+
+    required = {
+        "id",
+        "subject",
+        "description",
+        "owner",
+        "status",
+        "depends_on",
+        "created_at",
+        "updated_at",
+        "notes",
+        "verification",
+    }
+    for index, item in enumerate(data):
+        label = f"{path}: tasks[{index}]"
+        errors.extend(_check_keys(label, item, required))
+        for key in ("id", "subject", "description", "owner", "created_at", "updated_at"):
+            errors.extend(_non_empty(f"{label}.{key}", item.get(key) if isinstance(item, dict) else None))
+        if isinstance(item, dict):
+            if item.get("status") not in ALLOWED_TASK_STATUSES:
+                errors.append(f"{label}.status invalid {item.get('status')!r}")
+            for key in ("depends_on", "notes", "verification"):
+                if not isinstance(item.get(key), list):
+                    errors.append(f"{label}.{key} must be an array")
+            _validate_task_verification(path, index, item.get("verification", []), errors)
+    return errors
+
+
+def _validate_teammates(path: Path, items: list, errors: list[str]) -> None:
+    required = {"name", "agent_type", "status", "responsibility", "last_signal"}
+    for index, item in enumerate(items):
+        label = f"{path}: teammates[{index}]"
+        errors.extend(_check_keys(label, item, required))
+        errors.extend(_non_empty(f"{label}.name", item.get("name")))
+        if item.get("agent_type") not in ALLOWED_AGENTS:
+            errors.append(f"{label}.agent_type invalid {item.get('agent_type')!r}")
+        if item.get("status") not in ALLOWED_TEAMMATE_STATUSES:
+            errors.append(f"{label}.status invalid {item.get('status')!r}")
+
+
+def _validate_ownership(path: Path, items: list, errors: list[str]) -> None:
+    required = {"path", "owner", "reviewer", "notes"}
+    for index, item in enumerate(items):
+        label = f"{path}: ownership[{index}]"
+        errors.extend(_check_keys(label, item, required))
+        errors.extend(_non_empty(f"{label}.path", item.get("path")))
+        errors.extend(_non_empty(f"{label}.owner", item.get("owner")))
+
+
+def _validate_mailbox(path: Path, items: list, errors: list[str]) -> None:
+    required = {"at", "from", "to", "decision", "notes"}
+    for index, item in enumerate(items):
+        label = f"{path}: mailbox_decisions[{index}]"
+        errors.extend(_check_keys(label, item, required))
+        for key in ("at", "from", "to", "decision"):
+            errors.extend(_non_empty(f"{label}.{key}", item.get(key)))
+
+
+def _validate_approvals(path: Path, items: list, errors: list[str]) -> None:
+    required = {"gate", "status", "decided_at", "notes"}
+    for index, item in enumerate(items):
+        label = f"{path}: approvals[{index}]"
+        errors.extend(_check_keys(label, item, required))
+        errors.extend(_non_empty(f"{label}.gate", item.get("gate")))
+        if item.get("status") not in ALLOWED_APPROVAL_STATUSES:
+            errors.append(f"{label}.status invalid {item.get('status')!r}")
+
+
+def _validate_verification(path: Path, items: list, errors: list[str]) -> None:
+    required = {"command", "status", "by", "notes"}
+    for index, item in enumerate(items):
+        label = f"{path}: verification[{index}]"
+        errors.extend(_check_keys(label, item, required))
+        errors.extend(_non_empty(f"{label}.command", item.get("command")))
+        errors.extend(_non_empty(f"{label}.by", item.get("by")))
+        if item.get("status") not in ALLOWED_VERIFICATION_STATUSES:
+            errors.append(f"{label}.status invalid {item.get('status')!r}")
+
+
+def _validate_task_verification(path: Path, task_index: int, items: list, errors: list[str]) -> None:
+    if not isinstance(items, list):
+        return
+    required = {"at", "result"}
+    allowed = required | {"command", "notes"}
+    for index, item in enumerate(items):
+        label = f"{path}: tasks[{task_index}].verification[{index}]"
+        errors.extend(_check_required_keys(label, item, required, allowed))
+        if isinstance(item, dict):
+            errors.extend(_non_empty(f"{label}.at", item.get("at")))
+            if item.get("result") not in ALLOWED_VERIFICATION_STATUSES:
+                errors.append(f"{label}.result invalid {item.get('result')!r}")
+
+
+def _validate_jsonl(path: Path, validator) -> list[str]:
+    errors = []
+    for line_number, line in enumerate(path.read_text().splitlines(), start=1):
+        if not line.strip():
+            continue
+        try:
+            record = json.loads(line)
+        except json.JSONDecodeError as exc:
+            errors.append(f"{path}:{line_number}: invalid JSON: {exc.msg}")
+            continue
+        errors.extend(validator(path, line_number, record))
+    return errors
+
+
+def _validate_mailbox_record(path: Path, line_number: int, item: object) -> list[str]:
+    label = f"{path}:{line_number}"
+    if not isinstance(item, dict):
+        return [f"{label}: mailbox record must be an object"]
+
+    common_required = {"at", "from", "to", "type"}
+    if item.get("type") == "dispatch":
+        required = common_required | {"description"}
+        allowed = required
+    else:
+        required = common_required | {"run_id", "body"}
+        allowed = required | {"decision"}
+    errors = _check_required_keys(label, item, required, allowed)
+    for key in sorted(required):
+        errors.extend(_non_empty(f"{label}.{key}", item.get(key)))
+    return errors
+
+
+def _validate_checkpoint_record(path: Path, line_number: int, item: object) -> list[str]:
+    label = f"{path}:{line_number}"
+    required = {"at", "run_id", "summary"}
+    allowed = required | {"next", "verification"}
+    errors = _check_required_keys(label, item, required, allowed)
+    if isinstance(item, dict):
+        for key in sorted(required):
+            errors.extend(_non_empty(f"{label}.{key}", item.get(key)))
+    return errors
+
+
+def _validate_cleanup(path: Path, cleanup: object, errors: list[str]) -> None:
+    required = {"team_stopped", "pending_todos_clear", "notes"}
+    label = f"{path}: cleanup"
+    if not isinstance(cleanup, dict):
+        errors.append(f"{label} must be an object")
+        return
+    errors.extend(_check_keys(label, cleanup, required))
+    for key in ("team_stopped", "pending_todos_clear"):
+        if not isinstance(cleanup.get(key), bool):
+            errors.append(f"{label}.{key} must be a boolean")
+
+
+def _check_keys(label: str, item: object, required: set[str]) -> list[str]:
+    if not isinstance(item, dict):
+        return [f"{label}: must be an object"]
+    errors = []
+    missing = sorted(required - set(item))
+    extra = sorted(set(item) - required)
+    if missing:
+        errors.append(f"{label}: missing {missing}")
+    if extra:
+        errors.append(f"{label}: unexpected {extra}")
+    return errors
+
+
+def _check_required_keys(label: str, item: object, required: set[str], allowed: set[str]) -> list[str]:
+    if not isinstance(item, dict):
+        return [f"{label}: must be an object"]
+    errors = []
+    missing = sorted(required - set(item))
+    extra = sorted(set(item) - allowed)
+    if missing:
+        errors.append(f"{label}: missing {missing}")
+    if extra:
+        errors.append(f"{label}: unexpected {extra}")
+    return errors
+
+
+def _non_empty(label: str, value: object) -> list[str]:
+    return [] if isinstance(value, str) and value else [f"{label}: must be a non-empty string"]
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())