claude-smart 0.2.45 → 0.2.47

package/plugin/src/claude_smart/cli.py

@@ -3,7 +3,7 @@
 Exposes the following subcommands:
 
 - ``install``: register the GitHub marketplace and install the plugin into
-  Claude Code, then seed ``~/.reflexio/.env`` with the local-provider flags.
+  Claude Code, then seed ``~/.claude-smart/.env`` with the local-provider flags.
 - ``update``: update the plugin to the latest version via the native Claude
   Code plugin CLI.
 - ``uninstall``: remove the plugin from Claude Code via the native plugin
@@ -21,6 +21,10 @@ Exposes the following subcommands:
 from __future__ import annotations
 
 import argparse
+from collections.abc import Iterable, Iterator
+from contextlib import contextmanager
+from dataclasses import dataclass
+from hashlib import sha256
 import json
 import os
 import re
@@ -29,11 +33,11 @@ import shutil
 import subprocess
 import sys
 import time
-from collections.abc import Iterable
-from dataclasses import dataclass
 from pathlib import Path
+from urllib.parse import urlparse
+from urllib.request import url2pathname
 
-from claude_smart import context_format, env_config, ids, publish, state
+from claude_smart import context_format, cs_cite, env_config, ids, publish, state
 from claude_smart.reflexio_adapter import Adapter
 
 _REFLEXIO_ENV_PATH = env_config.REFLEXIO_ENV_PATH
@@ -56,6 +60,8 @@ _CODEX_PLUGIN_CACHE_DIR = (
     / "claude-smart"
 )
 _CODEX_CLI_TIMEOUT_SECONDS = 30
+_OPENCODE_BARE_PLUGIN_SPEC = "claude-smart"
+_OPENCODE_CONFIG_NAMES = ("opencode.json", "opencode.jsonc")
 _REFLEXIO_UNREACHABLE_MSG = (
     "Failed to reach reflexio. Check ~/.claude-smart/backend.log "
     "or restart Claude Code.\n"
@@ -70,6 +76,9 @@ _BACKEND_SCRIPT = _SCRIPTS_DIR / "backend-service.sh"
 _DASHBOARD_SCRIPT = _SCRIPTS_DIR / "dashboard-service.sh"
 _REFLEXIO_DIR = Path.home() / ".reflexio"
 _STATE_DIR = Path.home() / ".claude-smart"
+_OPENCODE_LOCAL_PACKAGE_DIR = _STATE_DIR / "opencode" / "claude-smart"
+_OPENCODE_PACKAGE_LOCK_TIMEOUT_SECONDS = 120.0
+_OPENCODE_PACKAGE_LOCK_STALE_SECONDS = 10 * 60.0
 _LOCAL_DATA_NOTICE = (
     "Local data was kept so reinstalling claude-smart can reuse your learned "
     "rules, sessions, logs, and local Reflexio data.\n"
@@ -83,7 +92,12 @@ _LOCAL_DATA_NOTICE = (
 _INSTALL_FAILURE_MARKER = _STATE_DIR / "install-failed"
 _SERVICE_STATUS_PROBE_FAILED = "probe_failed"
 _DEFAULT_STORAGE_ROOT = _REFLEXIO_DIR / "data"
-_REFLEXIO_CONFIG_PATH = _REFLEXIO_DIR / "configs" / "config_self-host-org.json"
+# Org id claude-smart's backend runs under (set via REFLEXIO_DEFAULT_ORG_ID in
+# backend-service.sh). reflexio names the config file config_<org>.json, so this
+# must stay in sync with that export; using our own org keeps us off the
+# enterprise self-host backend's config_self-host-org.json.
+_REFLEXIO_ORG_ID = "claude-smart"
+_REFLEXIO_CONFIG_PATH = _REFLEXIO_DIR / "configs" / f"config_{_REFLEXIO_ORG_ID}.json"
 _LOCAL_STORAGE_ENV = "LOCAL_STORAGE_PATH"
 _CODEX_REQUIRED_FILES = (
     Path(".agents/plugins/marketplace.json"),
@@ -92,6 +106,9 @@ _CODEX_REQUIRED_FILES = (
     Path("plugin/scripts/codex-claude-compat"),
     Path("plugin/scripts/codex-claude-compat.cmd"),
     Path("plugin/scripts/codex-claude-compat.js"),
+    Path("plugin/scripts/opencode-claude-compat"),
+    Path("plugin/scripts/opencode-claude-compat.cmd"),
+    Path("plugin/scripts/opencode-claude-compat.js"),
     Path("plugin/scripts/codex-hook.js"),
     Path("plugin/scripts/backend-log-runner.sh"),
     Path("plugin/scripts/_codex_env.sh"),
@@ -103,6 +120,7 @@ _COPYTREE_IGNORE = shutil.ignore_patterns(
     "*.pyo",
     ".pytest_cache",
     ".ruff_cache",
+    ".git",
     ".next",
     "node_modules",
 )
@@ -963,6 +981,391 @@ def _configure_reflexio_setup() -> bool:
     return read_only
 
 
+def _strip_jsonc(text: str) -> str:
+    """Remove JSONC comments and trailing commas without touching strings."""
+
+    def skip_trivia(index: int) -> int:
+        while index < len(text):
+            while index < len(text) and text[index].isspace():
+                index += 1
+            if text[index : index + 2] == "//":
+                index += 2
+                while index < len(text) and text[index] not in "\r\n":
+                    index += 1
+                continue
+            if text[index : index + 2] == "/*":
+                index += 2
+                while index + 1 < len(text) and text[index : index + 2] != "*/":
+                    index += 1
+                index = min(index + 2, len(text))
+                continue
+            break
+        return index
+
+    out: list[str] = []
+    in_string = False
+    escaped = False
+    i = 0
+    while i < len(text):
+        ch = text[i]
+        nxt = text[i + 1] if i + 1 < len(text) else ""
+        if in_string:
+            out.append(ch)
+            if escaped:
+                escaped = False
+            elif ch == "\\":
+                escaped = True
+            elif ch == '"':
+                in_string = False
+            i += 1
+            continue
+        if ch == '"':
+            in_string = True
+            out.append(ch)
+            i += 1
+            continue
+        if ch == "/" and nxt == "/":
+            while i < len(text) and text[i] not in "\r\n":
+                i += 1
+            continue
+        if ch == "/" and nxt == "*":
+            i += 2
+            while i + 1 < len(text) and not (text[i] == "*" and text[i + 1] == "/"):
+                i += 1
+            i += 2
+            continue
+        if ch == ",":
+            j = skip_trivia(i + 1)
+            if j < len(text) and text[j] in "}]":
+                i += 1
+                continue
+        out.append(ch)
+        i += 1
+    return "".join(out)
+
+
+def _read_jsonc_object(path: Path) -> dict[str, object]:
+    try:
+        text = path.read_text() if path.exists() else "{}"
+        parsed = json.loads(_strip_jsonc(text or "{}"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise ValueError(f"could not parse OpenCode config {path}: {exc}") from exc
+    if not isinstance(parsed, dict):
+        raise ValueError(f"OpenCode config {path} must be a JSON object")
+    return parsed
+
+
+def _opencode_global_config_dir() -> Path:
+    xdg = os.environ.get("XDG_CONFIG_HOME", "").strip()
+    base = Path(xdg) if xdg else Path.home() / ".config"
+    return base / "opencode"
+
+
+def _opencode_config_path(*, global_config: bool = False, cwd: Path | None = None) -> Path:
+    if global_config:
+        config_dir = _opencode_global_config_dir()
+        for name in _OPENCODE_CONFIG_NAMES:
+            candidate = config_dir / name
+            if candidate.exists():
+                return candidate
+        return config_dir / "opencode.json"
+    base = cwd or Path.cwd()
+    candidates = [
+        *(base / name for name in _OPENCODE_CONFIG_NAMES),
+        *(base / ".opencode" / name for name in _OPENCODE_CONFIG_NAMES),
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return base / "opencode.json"
+
+
+def _opencode_plugin_spec(entry: object) -> str | None:
+    if isinstance(entry, str):
+        return entry
+    if isinstance(entry, list) and entry and isinstance(entry[0], str):
+        return entry[0]
+    return None
+
+
+def _opencode_local_plugin_spec(
+    package_root: Path = _OPENCODE_LOCAL_PACKAGE_DIR,
+) -> str:
+    return package_root.resolve(strict=False).as_uri()
+
+
+def _is_default_opencode_package_path(package_path: Path) -> bool:
+    if _same_real_path(package_path, _OPENCODE_LOCAL_PACKAGE_DIR):
+        return True
+    try:
+        return package_path.resolve(strict=False) == _OPENCODE_LOCAL_PACKAGE_DIR.resolve(
+            strict=False
+        )
+    except OSError:
+        return False
+
+
+def _is_opencode_claude_smart_spec(spec: str | None) -> bool:
+    if not spec:
+        return False
+    if spec == _OPENCODE_BARE_PLUGIN_SPEC or spec.startswith(
+        f"{_OPENCODE_BARE_PLUGIN_SPEC}@"
+    ):
+        return True
+    parsed = urlparse(spec)
+    if parsed.scheme != "file":
+        return False
+    package_path = Path(url2pathname(parsed.path))
+    if _is_default_opencode_package_path(package_path):
+        return True
+    try:
+        manifest = json.loads((package_path / "package.json").read_text())
+        if manifest.get("name") == _OPENCODE_BARE_PLUGIN_SPEC:
+            return True
+    except (OSError, json.JSONDecodeError):
+        pass
+    return False
+
+
+def _patch_opencode_plugin_config(
+    config_path: Path, *, install: bool, plugin_spec: str | None = None
+) -> tuple[bool, Path]:
+    if install and plugin_spec is None:
+        plugin_spec = _opencode_local_plugin_spec()
+    data = _read_jsonc_object(config_path)
+    for field in ("plugins", "plugin"):
+        value = data.get(field)
+        if value is not None and not isinstance(value, list):
+            raise ValueError(
+                f'OpenCode config {config_path} field "{field}" must be a JSON array'
+            )
+    current_plugin = data.get("plugin")
+    plugins: list[object] = []
+    if isinstance(current_plugin, list):
+        plugins.extend(current_plugin)
+    legacy_plugins = data.get("plugins")
+    if isinstance(legacy_plugins, list):
+        plugins.extend(legacy_plugins)
+    kept = [
+        item
+        for item in plugins
+        if not _is_opencode_claude_smart_spec(_opencode_plugin_spec(item))
+    ]
+    if install:
+        assert plugin_spec is not None
+        next_plugins = [*kept, plugin_spec]
+    else:
+        next_plugins = kept
+    if isinstance(current_plugin, list):
+        changed = ("plugins" in data) or next_plugins != current_plugin
+    else:
+        changed = ("plugins" in data) or (install and bool(next_plugins))
+    if not changed:
+        return False, config_path
+    if config_path.exists():
+        original = config_path.read_text()
+        if original.strip() and original != _strip_jsonc(original):
+            config_path.with_suffix(config_path.suffix + ".bak").write_text(original)
+    data["plugin"] = next_plugins
+    data.pop("plugins", None)
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    config_path.write_text(json.dumps(data, indent=2) + "\n")
+    return True, config_path
+
+
+def _has_extraction_provider() -> bool:
+    env_config.load_reflexio_env(_REFLEXIO_ENV_PATH)
+    if os.environ.get(env_config.REFLEXIO_API_KEY_ENV, "").strip():
+        return True
+    cli_path = os.environ.get("CLAUDE_SMART_CLI_PATH", "").strip()
+    if cli_path:
+        resolved = Path(cli_path).expanduser()
+        if resolved.is_file() and os.access(resolved, os.X_OK):
+            return True
+    return bool(shutil.which("claude") or shutil.which("codex") or shutil.which("opencode"))
+
+
+def _extraction_provider_error() -> str:
+    return (
+        "error: OpenCode support needs a working learning/extraction provider.\n"
+        "Run `npx claude-smart setup` to configure Reflexio, or install "
+        "OpenCode, Claude Code, or Codex so local extraction can use a supported CLI.\n"
+    )
+
+
+def _opencode_install_supported_from_this_package() -> bool:
+    return (_SCRIPTS_DIR / "smart-install.sh").is_file()
+
+
+def _file_sha256(path: Path) -> str:
+    return sha256(path.read_bytes()).hexdigest()
+
+
+def _same_real_path(left: Path, right: Path) -> bool:
+    try:
+        return left.resolve(strict=True) == right.resolve(strict=True)
+    except OSError:
+        return False
+
+
+def _verify_opencode_plugin_package(package_root: Path) -> None:
+    source_script = _PLUGIN_ROOT / "scripts" / "smart-install.sh"
+    copied_script = package_root / "plugin" / "scripts" / "smart-install.sh"
+    for path in (package_root / "package.json", copied_script):
+        if not path.exists():
+            raise OSError(f"OpenCode local plugin package is missing {path}")
+    if _file_sha256(source_script) != _file_sha256(copied_script):
+        raise OSError(
+            "OpenCode local plugin package does not match the installed claude-smart package"
+        )
+
+
+@contextmanager
+def _opencode_package_install_lock(package_root: Path) -> Iterator[None]:
+    lock_dir = package_root.parent / ".install.lock"
+    package_root.parent.mkdir(parents=True, exist_ok=True)
+    deadline = time.monotonic() + _OPENCODE_PACKAGE_LOCK_TIMEOUT_SECONDS
+    while True:
+        try:
+            lock_dir.mkdir()
+            break
+        except FileExistsError:
+            try:
+                stale = (
+                    time.time() - lock_dir.stat().st_mtime
+                    > _OPENCODE_PACKAGE_LOCK_STALE_SECONDS
+                )
+            except OSError:
+                stale = False
+            if stale:
+                shutil.rmtree(lock_dir, ignore_errors=True)
+                continue
+            if time.monotonic() >= deadline:
+                raise OSError(
+                    f"timed out waiting for OpenCode package install lock at {lock_dir}"
+                )
+            time.sleep(0.1)
+    try:
+        yield
+    finally:
+        shutil.rmtree(lock_dir, ignore_errors=True)
+
+
+def _unique_opencode_package_path(parent: Path, prefix: str) -> Path:
+    return parent / f"{prefix}-{os.getpid()}-{time.monotonic_ns()}"
+
+
+def _replace_opencode_plugin_package(staged_package: Path, package_root: Path) -> None:
+    backup_package = _unique_opencode_package_path(
+        package_root.parent, ".claude-smart-previous"
+    )
+    backup_created = False
+    try:
+        if package_root.exists() or package_root.is_symlink():
+            package_root.rename(backup_package)
+            backup_created = True
+        staged_package.rename(package_root)
+        if backup_created:
+            shutil.rmtree(backup_package, ignore_errors=True)
+    except OSError:
+        if backup_created and not package_root.exists() and backup_package.exists():
+            backup_package.rename(package_root)
+        raise
+
+
+def _install_opencode_plugin_package() -> Path:
+    package_root = _OPENCODE_LOCAL_PACKAGE_DIR
+    if _same_real_path(_REPO_ROOT, package_root):
+        _verify_opencode_plugin_package(package_root)
+        return package_root
+    with _opencode_package_install_lock(package_root):
+        staged_package = _unique_opencode_package_path(
+            package_root.parent, ".claude-smart-copy"
+        )
+        shutil.rmtree(staged_package, ignore_errors=True)
+        try:
+            shutil.copytree(_REPO_ROOT, staged_package, ignore=_COPYTREE_IGNORE)
+            _verify_opencode_plugin_package(staged_package)
+            _replace_opencode_plugin_package(staged_package, package_root)
+            _verify_opencode_plugin_package(package_root)
+        finally:
+            shutil.rmtree(staged_package, ignore_errors=True)
+    return package_root
+
+
+def _bootstrap_opencode_install(read_only: bool) -> tuple[bool, str]:
+    if not _opencode_install_supported_from_this_package():
+        return (
+            False,
+            "OpenCode install is supported from the npm package. "
+            "Run `npx claude-smart install --host opencode`.",
+        )
+    try:
+        package_root = _install_opencode_plugin_package()
+    except OSError as exc:
+        return False, str(exc)
+    plugin_root = package_root / "plugin"
+    try:
+        _force_plugin_root(plugin_root)
+    except OSError as exc:
+        return False, str(exc)
+    bash = _resolve_bash()
+    if not bash:
+        return False, "bash is required to bootstrap claude-smart dependencies"
+    scripts_dir = plugin_root / "scripts"
+    result = subprocess.run([bash, str(scripts_dir / "smart-install.sh")], cwd=plugin_root)
+    if result.returncode != 0:
+        return False, f"smart-install.sh failed in {plugin_root}"
+    if _INSTALL_FAILURE_MARKER.is_file():
+        first_line = _INSTALL_FAILURE_MARKER.read_text().splitlines()
+        reason = (first_line[0].strip() if first_line else "") or "unknown error"
+        return False, reason
+    if read_only:
+        _prune_publish_hooks_for_read_only(plugin_root)
+    return True, str(package_root)
+
+
+def cmd_install_opencode(args: argparse.Namespace) -> int:
+    if not _opencode_install_supported_from_this_package():
+        sys.stderr.write(
+            "error: OpenCode install is supported from the npm package. "
+            "Run `npx claude-smart install --host opencode`.\n"
+        )
+        return 1
+    read_only = _configure_reflexio_setup()
+    if not _has_extraction_provider():
+        sys.stderr.write(_extraction_provider_error())
+        return 1
+    bootstrapped, package_root_text = _bootstrap_opencode_install(read_only)
+    if not bootstrapped:
+        sys.stderr.write(
+            f"error: claude-smart OpenCode setup failed during dependency bootstrap: {package_root_text}\n"
+        )
+        return 1
+    package_root = Path(package_root_text)
+    plugin_root = package_root / "plugin"
+    plugin_spec = _opencode_local_plugin_spec(package_root)
+    config_path = _opencode_config_path(
+        global_config=bool(getattr(args, "global_config", False))
+    )
+    try:
+        changed, config_path = _patch_opencode_plugin_config(
+            config_path,
+            install=True,
+            plugin_spec=plugin_spec,
+        )
+    except ValueError as exc:
+        sys.stderr.write(f"error: {exc}\n")
+        return 1
+    action = "Updated" if changed else "OpenCode config already includes"
+    sys.stdout.write(
+        f"{action} `{plugin_spec}` in {config_path}.\n"
+        f"Prepared claude-smart runtime at {plugin_root}.\n"
+        "Restart OpenCode in your project so it loads the plugin.\n"
+    )
+    return 0
+
+
 def cmd_install_codex(args: argparse.Namespace) -> int:
     """Install the claude-smart plugin marketplace for Codex.
 
@@ -1073,7 +1476,7 @@ def cmd_install(args: argparse.Namespace) -> int:
 
     Runs ``claude plugin marketplace add`` (pointed at the bundled marketplace
     at ``_REPO_ROOT``) followed by ``claude plugin install``, then appends the
-    local-provider flags to ``~/.reflexio/.env`` so reflexio can route
+    local-provider flags to ``~/.claude-smart/.env`` so reflexio can route
     generation through the local Claude Code CLI.
 
     Args:
@@ -1084,6 +1487,8 @@ def cmd_install(args: argparse.Namespace) -> int:
     """
     if getattr(args, "host", "claude-code") == "codex":
         return cmd_install_codex(args)
+    if getattr(args, "host", "claude-code") == "opencode":
+        return cmd_install_opencode(args)
 
     if not shutil.which("claude"):
         sys.stderr.write(
@@ -1156,6 +1561,8 @@ def cmd_update(args: argparse.Namespace) -> int:
     """
     if getattr(args, "host", "claude-code") == "codex":
         return cmd_update_codex(args)
+    if getattr(args, "host", "claude-code") == "opencode":
+        return cmd_update_opencode(args)
 
     _run_service(_DASHBOARD_SCRIPT, "stop")
     _run_service(_BACKEND_SCRIPT, "stop")
@@ -1182,6 +1589,17 @@ def cmd_update_codex(_args: argparse.Namespace) -> int:
     return cmd_install_codex(install_args)
 
 
+def cmd_update_opencode(args: argparse.Namespace) -> int:
+    _run_service(_DASHBOARD_SCRIPT, "stop")
+    _run_service(_BACKEND_SCRIPT, "stop")
+    sys.stdout.write(
+        "Updating claude-smart OpenCode support by reinstalling from this package...\n"
+    )
+    install_args = argparse.Namespace(**vars(args))
+    install_args.host = "opencode"
+    return cmd_install_opencode(install_args)
+
+
 def cmd_uninstall(_args: argparse.Namespace) -> int:
     """Uninstall claude-smart from Claude Code via the native plugin CLI.
 
@@ -1196,6 +1614,8 @@ def cmd_uninstall(_args: argparse.Namespace) -> int:
     """
     if getattr(_args, "host", "claude-code") == "codex":
         return cmd_uninstall_codex(_args)
+    if getattr(_args, "host", "claude-code") == "opencode":
+        return cmd_uninstall_opencode(_args)
 
     if not shutil.which("claude"):
         sys.stderr.write(
@@ -1256,6 +1676,40 @@ def cmd_uninstall_codex(_args: argparse.Namespace) -> int:
     return 0
 
 
+def cmd_uninstall_opencode(args: argparse.Namespace) -> int:
+    _run_service(_DASHBOARD_SCRIPT, "stop")
+    _run_service(_BACKEND_SCRIPT, "stop")
+    local_scripts = _OPENCODE_LOCAL_PACKAGE_DIR / "plugin" / "scripts"
+    for script in (
+        local_scripts / "dashboard-service.sh",
+        local_scripts / "backend-service.sh",
+    ):
+        if script.exists():
+            _run_service(script, "stop")
+    config_path = _opencode_config_path(
+        global_config=bool(getattr(args, "global_config", False))
+    )
+    try:
+        changed, config_path = _patch_opencode_plugin_config(config_path, install=False)
+    except ValueError as exc:
+        sys.stderr.write(f"error: {exc}\n")
+        return 1
+    shutil.rmtree(_OPENCODE_LOCAL_PACKAGE_DIR, ignore_errors=True)
+    try:
+        _OPENCODE_LOCAL_PACKAGE_DIR.parent.rmdir()
+    except OSError:
+        pass
+    if changed:
+        sys.stdout.write(f"Removed claude-smart OpenCode plugin entries from {config_path}.\n")
+    else:
+        sys.stdout.write("OpenCode config did not include claude-smart.\n")
+    sys.stdout.write(
+        "Restart OpenCode to apply. "
+        f"{_LOCAL_DATA_NOTICE}"
+    )
+    return 0
+
+
 def cmd_show(args: argparse.Namespace) -> int:
     """Print this project's skills + preferences, plus globally-shared skills.
 
@@ -1292,12 +1746,26 @@ def cmd_show(args: argparse.Namespace) -> int:
             f"First error: {adapter.read_errors[0]}\n"
         )
         return 1
-    sys.stdout.write(
-        md or f"_No skills or preferences yet for project `{project_id}`._\n"
-    )
+    body = md or f"_No skills or preferences yet for project `{project_id}`._\n"
+    sys.stdout.write(body + _reflexio_show_footer())
     return 0
 
 
+def _reflexio_show_footer() -> str:
+    """Return the markdown attribution footer appended to ``show`` output.
+
+    Reinforces that claude-smart is powered by the open-source reflexio engine
+    and nudges users to star the repo.
+
+    Returns:
+        str: A leading-separator markdown footer ending in a newline.
+    """
+    return (
+        f"\n---\n⭐ claude-smart is powered by [reflexio]({cs_cite.REFLEXIO_REPO_URL})"
+        f" — if it helps you, [star it on GitHub]({cs_cite.REFLEXIO_REPO_URL}).\n"
+    )
+
+
 def cmd_learn(args: argparse.Namespace) -> int:
     """Force reflexio extraction over the active session's interactions.
 
@@ -1981,28 +2449,46 @@ def _build_parser() -> argparse.ArgumentParser:
     inst = sub.add_parser("install", help="Install claude-smart")
     inst.add_argument(
         "--host",
-        choices=("claude-code", "codex"),
+        choices=("claude-code", "codex", "opencode"),
         default="claude-code",
         help="Install target host",
     )
+    inst.add_argument(
+        "--global",
+        dest="global_config",
+        action="store_true",
+        help="For OpenCode, patch ~/.config/opencode instead of the project config",
+    )
     inst.set_defaults(func=cmd_install)
 
     upd = sub.add_parser("update", help="Update claude-smart to the latest version")
     upd.add_argument(
         "--host",
-        choices=("claude-code", "codex"),
+        choices=("claude-code", "codex", "opencode"),
         default="claude-code",
         help="Update target host",
     )
+    upd.add_argument(
+        "--global",
+        dest="global_config",
+        action="store_true",
+        help="For OpenCode, patch ~/.config/opencode instead of the project config",
+    )
     upd.set_defaults(func=cmd_update)
 
     uni = sub.add_parser("uninstall", help="Remove claude-smart")
     uni.add_argument(
         "--host",
-        choices=("claude-code", "codex"),
+        choices=("claude-code", "codex", "opencode"),
         default="claude-code",
         help="Uninstall target host",
     )
+    uni.add_argument(
+        "--global",
+        dest="global_config",
+        action="store_true",
+        help="For OpenCode, patch ~/.config/opencode instead of the project config",
+    )
     uni.set_defaults(func=cmd_uninstall)
 
     sh = sub.add_parser(

package/plugin/src/claude_smart/context_format.py

@@ -269,7 +269,7 @@ def _compact_citation_instruction(marker_parts: list[str] | None = None) -> str:
     gate = cs_cite.WHEN_TO_CITE_COMPACT
     link_style = os.environ.get(_CITATION_LINK_STYLE_ENV, "markdown")
     if link_style == "osc8" and marker_parts:
-        marker = f"✨ claude-smart rule applied: {' | '.join(marker_parts)}"
+        marker = cs_cite.build_marker(" | ".join(marker_parts), "osc8")
         separator_instruction = (
             " Separate multiple linked memories with the visible ` | ` separator."
             if len(marker_parts) > 1
@@ -281,12 +281,13 @@ def _compact_citation_instruction(marker_parts: list[str] | None = None) -> str:
         )
     if link_style == "osc8":
         return _remoteize_citation_instruction(
-            f"{gate} If you do, end with `✨ claude-smart rule applied:` "
-            "followed by the same linked memory text; keep the link, but do "
-            "not show the URL."
+            f"{gate} If you do, end with `{cs_cite.MARKER_PREFIX}` "
+            "followed by the same linked memory text, then "
+            f"`{cs_cite.marker_attribution('osc8')}` linking to the reflexio "
+            "repo; keep the links, but do not show the URL."
         )
     if marker_parts:
-        marker = f"✨ claude-smart rule applied: {' | '.join(marker_parts)}"
+        marker = cs_cite.build_marker(" | ".join(marker_parts), "markdown")
         separator_instruction = (
             " Separate multiple linked memories with the visible ` | ` separator."
             if len(marker_parts) > 1
@@ -297,9 +298,8 @@ def _compact_citation_instruction(marker_parts: list[str] | None = None) -> str:
             f"links: `{marker}`.{separator_instruction}"
         )
     return _remoteize_citation_instruction(
-        f"{gate} If you do, end with one final marker like `✨ claude-smart "
-        "rule applied: [verify process state](http://localhost:3001/rules/"
-        "s1-123)` using the shown rule URL."
+        f"{gate} If you do, end with one final marker like "
+        f"`{cs_cite.MARKDOWN_EXAMPLE_ONE}` using the shown rule URL."
     )
 
 
@@ -337,7 +337,7 @@ def _exact_osc8_marker_instruction(entries: list[dict[str, Any]]) -> str:
     if not marker_parts:
         return ""
 
-    marker = f"✨ claude-smart rule applied: {' | '.join(marker_parts)}"
+    marker = cs_cite.build_marker(" | ".join(marker_parts), "osc8")
     return (
         "If any listed memory above was used, copy this exact final marker, "
         f"preserving its hidden OSC 8 terminal links: `{marker}`. "