cluxion-agentplugin-preprocessing 0.2.0__py3-none-any.whl

cluxion_agentplugin_adapters/claude/.claude-plugin/plugin.json

@@ -0,0 +1,8 @@
+{
+  "name": "cluxion-agentplugin-preprocessing",
+  "version": "0.2.0",
+  "description": "Cluxion preprocessing: honesty, clarification, Rust work queue, resource admission.",
+  "author": "cluxion",
+  "commands": "./commands",
+  "skills": "./skills"
+}

cluxion_agentplugin_adapters/claude/skills/preprocess/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: cluxion-preprocess
+description: Run Cluxion preprocessing before agent work. You (the connected AI) call cluxion tools/CLI. Use for task planning, long work queueing, or unclear user intent. Enforces honesty and clarification before queueing.
+---
+
+# Cluxion Preprocessing — 연결된 AI 지시문
+
+작업 전에 **당신(연결된 AI)** 이 plan·큐 도구를 호출합니다. 플러그인은 JSON 계약만 반환합니다.
+
+## Plan 호출
+
+```bash
+cluxion-runtime plan --surface claude --json-stdin
+```
+
+stdin: `{"prompt": "<user request>", "cwd": "<workspace>"}`
+
+Hermes에서는 `cluxion_plan` 도구를 동일 목적으로 사용합니다.
+
+## 규칙
+
+1. `clarification.required`이 true이면 사용자에게 질문하고 작업을 시작하지 말 것.
+2. context가 부족하면 모른다고 말할 것 — 사실을 지어내지 말 것.
+3. `queued` 모드: `cluxion_queue_next` → segment 처리 → `cluxion_queue_record` → `cluxion_queue_brief`.
+4. 세션 맥락 보존이 필요하면 brief를 ForgetForge에 넘길 것: `forgetforge import-brief --source preprocessing --brief "<cluxion_queue_brief output>"` (또는 Hermes `forgetforge_import_brief`).
+5. `answer_policy.required_checks`를 응답 전에 따를 것.
+6. 플러그인이 대신 completion을 생성하지 않음 — **당신**이 계약에 맞게 응답할 것.
+
+## 설치 확인
+
+```bash
+cluxion-preprocess check
+```

cluxion_agentplugin_adapters/codex/config-snippet.toml

@@ -0,0 +1,5 @@
+# Add to ~/.codex/config.toml
+[plugins.cluxion_preprocess]
+enabled = true
+command = ["cluxion-runtime", "plan", "--json-stdin", "--surface", "codex"]
+description = "Cluxion preprocessing: honesty, clarification, Rust queue"

cluxion_agentplugin_docs/cluxion-Docs/README.md

@@ -0,0 +1,22 @@
+# Legacy Docs (cluxion-Docs)
+
+> **공개 문서 기준: [`../Docs/`](../Docs/)**  
+> 이 폴더는 이전 `hermes-cluxion` 패키징 시기의 **레거시 참고**입니다.
+
+## 현재 방향 (요약)
+
+- **연결된 AI**가 `cluxion_plan`·큐 도구를 호출하고 JSON 계약을 따릅니다.
+- **모델·OAuth·provider**는 host agent가 소유합니다. 플러그인은 plan·게이트만 반환합니다.
+- 플러그인 내부에서 **별도 LLM을 호출하지 않습니다.**
+
+사용자·에이전트 연동 설명은 **`Docs/README.md`** 를 따르세요.
+
+## 레거시 목차 (기술 참고)
+
+| 문서 | 내용 |
+|------|------|
+| [architecture.md](./architecture.md) | 패키지 경계 (레거시 명칭 포함) |
+| [harness-logic.md](./harness-logic.md) | intent·전처리·큐·resource |
+| [honesty-preprocessing.md](./honesty-preprocessing.md) | answer_policy 계약 |
+| [install-and-operations.md](./install-and-operations.md) | 설치 요약 → `Docs/installation.md` |
+| [security.md](./security.md) | 공개 배포 보안 원칙 |

cluxion_agentplugin_docs/cluxion-Docs/architecture.md

@@ -0,0 +1,36 @@
+# Architecture (legacy reference)
+
+> 최신 문서: [`../Docs/architecture.md`](../Docs/architecture.md)
+
+## 패키지 구성
+
+| 패키지 | 역할 |
+|--------|------|
+| `cluxion_agentplugin_preprocessing` | Hermes plugin, CLI, tool schema |
+| `cluxion_runtime` | `cluxion-runtime plan`, harness 엔진 |
+| `rust/cluxion_queue` | SQLite 작업큐 + dispatch (선택) |
+
+## Host vs Cluxion
+
+**Host agent (연결된 AI)**
+
+- OAuth, provider, **모델 선택**
+- tool 권한, completion, 최종 응답
+- queued segment 처리·synthesis
+
+**Cluxion preprocessing**
+
+- `WorkItem` 정규화, intent 분류
+- `answer_policy` · `host_execution` 계약
+- 명확화·segment 큐·resource admission
+- **추가 LLM 호출 없음**
+
+## 등록 도구 (Hermes `cluxion` toolset)
+
+| Tool | 용도 |
+|------|------|
+| `cluxion_plan` | 전처리·방향·큐·리소스 plan |
+| `cluxion_clarify` | 명확화 질문 |
+| `cluxion_queue_next` / `record` / `brief` | segment 큐 |
+
+모델·provider 변경은 host agent 책임입니다. 전처리 플러그인은 실행 **전** 계약만 제공합니다.

cluxion_agentplugin_docs/cluxion-Docs/harness-logic.md

@@ -0,0 +1,51 @@
+# Harness Logic (legacy reference)
+
+> 최신 문서: [`../Docs/design.md`](../Docs/design.md), [`../Docs/tools.md`](../Docs/tools.md)
+
+## 1. Adapter Payload
+
+```bash
+cluxion-runtime plan --json-stdin --surface <surface>
+```
+
+필수: `prompt`  
+선택: `work_id`, `priority`, `cwd`, `metadata`, `expected_ram_mb`, `context_tokens`
+
+## 2. Intent 분류
+
+`classify_intent()` — **모델 호출 없음**, 결정론적.
+
+- `category`, `operation`, `direction`, `confidence`, `signals`
+- 방향은 host harness (`hermes_harness`, `claude_harness`, …) 또는 `host_managed`
+
+## 3. 전처리 모드
+
+| Mode | 용도 |
+|------|------|
+| `simple_answer` | 짧은 일반 질문 |
+| `verification_answer` | 사실 확인 필요 짧은 질문 |
+| `standard` | 코드·테스트·보안·문서 등 실질 작업 |
+| `queued` | 긴 입력 segment 분할 |
+| `needs_clarification` | 사용자 방향 확정 전 |
+
+모든 모드에 `answer_policy` 포함.
+
+## 4. 작업큐
+
+`AgentWorkQueue` — priority + FIFO. Rust `cluxion-queue` 또는 Python fallback.
+
+## 5. Host Execution
+
+`host_execution` 계약을 **연결된 AI**가 읽고 실행:
+
+- `current_turn_direct_answer`
+- `current_turn_verify_then_answer`
+- `single_host_task`
+- `durable_segment_queue` + `cluxion_queue_*`
+- `ask_user_before_queue`
+
+## 6. Resource Admission
+
+`collect_resource_snapshot()` + `capacity_decision()` — fail-closed RAM/CPU 게이트.
+
+Queued segment content는 out-of-band store에 저장됩니다.

cluxion_agentplugin_docs/cluxion-Docs/honesty-preprocessing.md

@@ -0,0 +1,40 @@
+# Honesty Preprocessing (legacy reference)
+
+> 최신 문서: [`../Docs/design.md`](../Docs/design.md)
+
+플러그인은 모델을 바꾸지 않습니다. **연결된 AI**가 따라야 하는 `answer_policy` 계약을 만듭니다.
+
+## Goals
+
+- 모르면 모른다고 말하게 함
+- 확인하지 않은 실행·파일·환경 상태를 사실처럼 말하지 않게 함
+- 확인한 사실 / 추론 / unknown 분리
+- 짧은 질문에 heavy preprocessing 비용 최소화
+
+## Modes
+
+| Mode | 동작 |
+|------|------|
+| `simple_answer` | segment·resource snapshot 없음 |
+| `verification_answer` | `verification_required` + `required_checks` |
+| `standard` | segment·resource admission·evidence 기반 응답 |
+| `queued` | checksum·순서 보존 합성 |
+
+## Required Checks (대표)
+
+- `verify_current_or_recent_fact`
+- `cite_external_source_or_document`
+- `inspect_runtime_state_before_claiming`
+- `run_requested_check_or_state_not_run`
+- `tie_claims_to_file_diff_or_command_output`
+- `tie_security_claims_to_evidence`
+- `preserve_segment_checksums_in_synthesis`
+
+## Hard Boundaries
+
+- 기억·추정만으로 현재 상태 단정 금지
+- 실행하지 않은 테스트 통과 주장 금지
+- 존재하지 않는 파일·URL·버전 날조 금지
+- ambiguous prompt는 확정 표현 자제
+
+검증·실행·응답은 **연결된 AI** 책임입니다.

cluxion_agentplugin_docs/cluxion-Docs/install-and-operations.md

@@ -0,0 +1,36 @@
+# Install And Operations (legacy reference)
+
+> 최신 문서: [`../Docs/installation.md`](../Docs/installation.md)
+
+## 설치
+
+```bash
+pip install cluxion-agentplugin-preprocessing
+cluxion-preprocess check
+cluxion-preprocess enable    # Hermes
+```
+
+## 연결된 AI 연동
+
+- Hermes: `cluxion_*` 도구 (plugin enable 후)
+- Claude: `adapters/claude/skills/preprocess/SKILL.md`
+- Codex: `adapters/codex/config-snippet.toml`
+- 공통: `cluxion-runtime plan --surface <hermes|claude|codex|grok_build>`
+
+## Rust 큐 (선택)
+
+```bash
+cargo build --release --manifest-path rust/cluxion_queue/Cargo.toml
+export CLUXION_QUEUE_BIN=/path/to/cluxion-queue
+```
+
+## 배포 전 점검
+
+```bash
+uv run ruff check .
+uv run pytest
+cluxion-preprocess check
+cluxion-runtime plan --surface hermes --prompt "smoke"
+```
+
+모델 endpoint·provider 설정은 **host agent 문서**를 참고하세요. 전처리 플러그인은 모델을 소유하지 않습니다.

cluxion_agentplugin_docs/cluxion-Docs/security.md

@@ -0,0 +1,27 @@
+# Security
+
+> 공개 배포용 보안 원칙. 연동 설명은 [`../Docs/`](../Docs/) 참고.
+
+## 원칙
+
+- API 키·OAuth credential·secret 파일을 저장하지 않습니다.
+- subprocess는 배열 인자만 사용 (`shell=True` 금지).
+- Hermes config 변경 시 timestamp backup 후 atomic replace.
+- 큐·dispatch 데이터는 **사용자 디스크 경로**에만 저장, 원격 전송 없음.
+- host agent venv를 오염시키지 않도록 runtime 의존성은 격리 경로 사용 (코드 내부 정책).
+
+## Host 경계
+
+- 모델·provider·인증은 **연결된 AI / host agent** 소유.
+- Cluxion은 plan·게이트 JSON만 반환.
+
+## 배포 전 점검
+
+```bash
+uv run ruff check .
+uv run pytest
+uv run python -m build
+uv run twine check dist/*
+cluxion-preprocess check
+cluxion-runtime plan --surface hermes --prompt "smoke"
+```

cluxion_agentplugin_docs/github-profile/README.md

@@ -0,0 +1,67 @@
+# hermes-cluxion
+
+`hermes-cluxion` is a lightweight Cluxion harness plugin for Hermes Agent.
+
+It keeps Hermes in control of OAuth, provider auth, active model selection, tools, permissions, and final AI completion calls. Cluxion adds deterministic work planning around Hermes: preprocessing, intent routing, honesty contracts, queued segment dispatch, resource admission, and optional local `vllm-mlx` endpoint setup.
+
+## Install
+
+```bash
+python -m pip install "hermes-cluxion==0.1.9"
+hermes-cluxion enable
+hermes-cluxion check
+```
+
+Confirm the plugin is enabled:
+
+```bash
+hermes tools list
+```
+
+Expected:
+
+```text
+Plugin toolsets (cli):
+  ✓ enabled  cluxion  🔌 Cluxion
+```
+
+## Hermes Tools
+
+- `cluxion_plan`
+- `cluxion_bootstrap`
+- `cluxion_serve_local`
+- `cluxion_hermes_config`
+- `cluxion_queue_next`
+- `cluxion_queue_record`
+- `cluxion_queue_brief`
+
+## Execution Model
+
+- Cloud AI calls stay inside Hermes.
+- Local model calls also stay inside Hermes after switching to a custom local provider.
+- Cluxion returns `host_execution`, `answer_policy`, queue metadata, and resource decisions.
+- Short simple prompts do not pay queue or resource snapshot cost.
+- Short verification prompts get required checks without heavy preprocessing.
+- Long work uses durable queued segment dispatch and final briefing synthesis.
+
+## Local MLX Flow
+
+```bash
+hermes-cluxion bootstrap --upgrade
+hermes-cluxion hermes-config \
+  --model mlx-community/Qwen3.6-35B-A3B-OptiQ-4bit \
+  --port 23003 \
+  --context-length 131072
+cluxion-runtime serve-local \
+  --model mlx-community/Qwen3.6-35B-A3B-OptiQ-4bit \
+  --port 23003 \
+  --upgrade-runtime
+```
+
+Then switch Hermes:
+
+```text
+/model custom:cluxion-local:mlx-community/Qwen3.6-35B-A3B-OptiQ-4bit
+```
+
+Full guide: [README](../../README.md)

cluxion_agentplugin_preprocessing/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import annotations
+
+"""Universal Cluxion preprocessing agent plugin."""
+
+__version__ = "0.2.0"
+
+__all__ = ["__version__"]

cluxion_agentplugin_preprocessing/cli.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+"""CLI helpers for the universal Cluxion preprocessing plugin."""
+
+import argparse
+import json
+import sys
+from typing import TYPE_CHECKING
+
+from cluxion_agentplugin_preprocessing import __version__, hermes_config, runner
+from cluxion_runtime.bootstrap import ensure_local_runtime
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Run cluxion-preprocess CLI."""
+    parser = _parser()
+    args = parser.parse_args(argv)
+    if args.command == "check":
+        return _check()
+    if args.command == "bootstrap":
+        return _bootstrap(args)
+    if args.command == "status":
+        return _status(args)
+    if args.command == "enable":
+        return _enable(args)
+    if args.command == "disable":
+        return _disable(args)
+    if args.command == "hermes-config":
+        return _hermes_config(args)
+    parser.print_help(sys.stderr)
+    return 2
+
+
+def _parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="cluxion-preprocess")
+    parser.add_argument("--version", action="version", version=f"cluxion-agentplugin-preprocessing {__version__}")
+    subparsers = parser.add_subparsers(dest="command")
+    subparsers.add_parser("check", help="Check whether cluxion-runtime is visible")
+    bootstrap = subparsers.add_parser("bootstrap", help="Install or upgrade local runtime dependencies")
+    bootstrap.add_argument("--upgrade", action="store_true")
+    bootstrap.add_argument("--dry-run", action="store_true")
+    bootstrap.add_argument("--package", action="append", default=None)
+    status = subparsers.add_parser("status", help="Show whether Hermes config enables this plugin")
+    status.add_argument("--home", default=None)
+    enable = subparsers.add_parser("enable", help="Enable the pip-installed plugin in Hermes config")
+    enable.add_argument("--home", default=None)
+    enable.add_argument("--dry-run", action="store_true")
+    disable = subparsers.add_parser("disable", help="Disable the pip-installed plugin in Hermes config")
+    disable.add_argument("--home", default=None)
+    disable.add_argument("--dry-run", action="store_true")
+    config = subparsers.add_parser("hermes-config", help="Render Hermes local endpoint config through cluxion-runtime")
+    config.add_argument("--model", required=True)
+    config.add_argument("--host", default="127.0.0.1")
+    config.add_argument("--port", type=int, default=23003)
+    config.add_argument("--context-length", type=int, default=131_072)
+    config.add_argument("--provider-key", default="cluxion-local")
+    config.add_argument("--display-name", default="Cluxion Local")
+    return parser
+
+
+def _check() -> int:
+    from cluxion_runtime.resources.queue_bridge import queue_available
+
+    payload = {
+        "plugin": "cluxion-agentplugin-preprocessing",
+        "version": __version__,
+        "cluxion_runtime_available": runner.runtime_available(),
+        "rust_queue_available": queue_available(),
+    }
+    print(json.dumps(payload, ensure_ascii=False, sort_keys=True))
+    return 0 if payload["cluxion_runtime_available"] else 1
+
+
+def _bootstrap(args: argparse.Namespace) -> int:
+    result = ensure_local_runtime(
+        packages=tuple(args.package) if args.package else ("vllm-mlx",),
+        upgrade=bool(args.upgrade),
+        dry_run=bool(args.dry_run),
+    )
+    print(json.dumps(result.to_dict(), ensure_ascii=False, sort_keys=True))
+    return 0 if result.ok else 1
+
+
+def _status(args: argparse.Namespace) -> int:
+    result = hermes_config.plugin_status(args.home)
+    print(json.dumps({"ok": True, **result.to_dict()}, ensure_ascii=False, sort_keys=True))
+    return 0 if result.enabled else 1
+
+
+def _enable(args: argparse.Namespace) -> int:
+    result = hermes_config.enable_plugin(args.home, dry_run=bool(args.dry_run))
+    print(json.dumps({"ok": True, **result.to_dict()}, ensure_ascii=False, sort_keys=True))
+    return 0
+
+
+def _disable(args: argparse.Namespace) -> int:
+    result = hermes_config.disable_plugin(args.home, dry_run=bool(args.dry_run))
+    print(json.dumps({"ok": True, **result.to_dict()}, ensure_ascii=False, sort_keys=True))
+    return 0
+
+
+def _hermes_config(args: argparse.Namespace) -> int:
+    result = runner.hermes_config(
+        {
+            "model": str(args.model),
+            "host": str(args.host),
+            "port": int(args.port),
+            "context_length": int(args.context_length),
+            "provider_key": str(args.provider_key),
+            "display_name": str(args.display_name),
+        }
+    )
+    print(result.to_json())
+    return 0 if result.ok else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+
+
+__all__ = ["main"]

cluxion_agentplugin_preprocessing/hermes_config.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+"""Hermes config helpers for pip-installed entry point plugins."""
+
+import os
+import shutil
+import tempfile
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+PLUGIN_NAME = "cluxion-agentplugin-preprocessing"
+LEGACY_PLUGIN_NAME = "hermes-cluxion"
+
+
+@dataclass(frozen=True)
+class ConfigChange:
+    """Result of a Hermes config update."""
+
+    config_path: Path
+    changed: bool
+    enabled: bool
+    backup_path: Path | None = None
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "config_path": str(self.config_path),
+            "changed": self.changed,
+            "enabled": self.enabled,
+            "backup_path": str(self.backup_path) if self.backup_path else "",
+        }
+
+
+def plugin_status(home: str | os.PathLike[str] | None = None) -> ConfigChange:
+    """Return whether Hermes config enables this plugin."""
+    path = config_path(home)
+    config = _read_config(path)
+    return ConfigChange(path, False, _is_enabled(config))
+
+
+def enable_plugin(home: str | os.PathLike[str] | None = None, *, dry_run: bool = False) -> ConfigChange:
+    """Add hermes-cluxion to plugins.enabled and remove it from plugins.disabled."""
+    path = config_path(home)
+    config = _read_config(path)
+    changed = _set_enabled(config, enabled=True)
+    if dry_run or not changed:
+        return ConfigChange(path, changed, True)
+    backup = _write_config(path, config)
+    return ConfigChange(path, changed, True, backup)
+
+
+def disable_plugin(home: str | os.PathLike[str] | None = None, *, dry_run: bool = False) -> ConfigChange:
+    """Move hermes-cluxion from plugins.enabled to plugins.disabled."""
+    path = config_path(home)
+    config = _read_config(path)
+    changed = _set_enabled(config, enabled=False)
+    if dry_run or not changed:
+        return ConfigChange(path, changed, False)
+    backup = _write_config(path, config)
+    return ConfigChange(path, changed, False, backup)
+
+
+def config_path(home: str | os.PathLike[str] | None = None) -> Path:
+    """Resolve the Hermes config path without importing Hermes internals."""
+    if home is not None:
+        hermes_home = Path(home).expanduser()
+    else:
+        hermes_home = Path(os.environ.get("HERMES_HOME", "")).expanduser() if os.environ.get("HERMES_HOME") else Path.home() / ".hermes"
+    return hermes_home / "config.yaml"
+
+
+def _read_config(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+    raw = path.read_text(encoding="utf-8")
+    if not raw.strip():
+        return {}
+    loaded = yaml.safe_load(raw)
+    if loaded is None:
+        return {}
+    if not isinstance(loaded, dict):
+        raise ValueError(f"{path} must contain a YAML mapping")
+    return dict(loaded)
+
+
+def _is_enabled(config: dict[str, Any]) -> bool:
+    plugins = config.get("plugins")
+    if not isinstance(plugins, dict):
+        return False
+    enabled = plugins.get("enabled")
+    disabled = plugins.get("disabled")
+    return (_contains(enabled, PLUGIN_NAME) or _contains(enabled, LEGACY_PLUGIN_NAME)) and not _contains(
+        disabled, PLUGIN_NAME
+    ) and not _contains(disabled, LEGACY_PLUGIN_NAME)
+
+
+def _set_enabled(config: dict[str, Any], *, enabled: bool) -> bool:
+    plugins = config.setdefault("plugins", {})
+    if not isinstance(plugins, dict):
+        raise ValueError("plugins must be a YAML mapping")
+    enabled_list = _as_list(plugins.get("enabled"))
+    disabled_list = _as_list(plugins.get("disabled"))
+
+    old_enabled = list(enabled_list)
+    old_disabled = list(disabled_list)
+    if enabled:
+        if PLUGIN_NAME not in enabled_list:
+            enabled_list.append(PLUGIN_NAME)
+        disabled_list = [item for item in disabled_list if item not in {PLUGIN_NAME, LEGACY_PLUGIN_NAME}]
+    else:
+        enabled_list = [item for item in enabled_list if item not in {PLUGIN_NAME, LEGACY_PLUGIN_NAME}]
+        if PLUGIN_NAME not in disabled_list:
+            disabled_list.append(PLUGIN_NAME)
+
+    plugins["enabled"] = enabled_list
+    if disabled_list:
+        plugins["disabled"] = disabled_list
+    else:
+        plugins.pop("disabled", None)
+    return enabled_list != old_enabled or disabled_list != old_disabled
+
+
+def _as_list(value: object) -> list[str]:
+    if value is None:
+        return []
+    if not isinstance(value, list):
+        raise ValueError("plugins.enabled/plugins.disabled must be YAML lists")
+    items: list[str] = []
+    for item in value:
+        if not isinstance(item, str):
+            raise ValueError("plugins.enabled/plugins.disabled entries must be strings")
+        items.append(item)
+    return items
+
+
+def _contains(value: object, item: str) -> bool:
+    return isinstance(value, list) and item in value
+
+
+def _write_config(path: Path, config: dict[str, Any]) -> Path | None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    backup = _backup_config(path)
+    content = yaml.safe_dump(config, allow_unicode=True, sort_keys=False)
+    with tempfile.NamedTemporaryFile("w", encoding="utf-8", dir=path.parent, delete=False) as handle:
+        handle.write(content)
+        temp_name = handle.name
+    Path(temp_name).replace(path)
+    return backup
+
+
+def _backup_config(path: Path) -> Path | None:
+    if not path.exists():
+        return None
+    stamp = datetime.now(UTC).strftime("%Y%m%dT%H%M%SZ")
+    backup = path.with_name(f"{path.name}.bak-{stamp}")
+    shutil.copy2(path, backup)
+    return backup
+
+
+__all__ = ["ConfigChange", "config_path", "disable_plugin", "enable_plugin", "plugin_status"]