@agentlayer.tech/wallet 0.1.90 → 0.1.92

package/agent-wallet/README.md

@@ -138,7 +138,20 @@ If you want a simpler local setup flow, use the installer:
 sh ../setup.sh
 ```
 
-If you already use a local coding agent on the same machine, it can run this installer for you. You can simply ask the agent to install the wallet, and it can perform the file setup, Python setup, and OpenClaw config patching steps automatically.
+The public npm entrypoint is a universal host orchestrator:
+
+```bash
+npx @agentlayer.tech/wallet install --yes
+npx @agentlayer.tech/wallet install --yes --hosts codex,claude-code
+npx @agentlayer.tech/wallet detect --json
+```
+
+It detects OpenClaw, Codex, Claude Code, and Hermes before installation. The
+direct `setup.sh`/Python path retains its OpenClaw-oriented default for
+backward compatibility; the npm CLI passes `--no-configure-openclaw` and lets
+the selected OpenClaw host adapter own `openclaw.json`.
+
+If you already use a local coding agent on the same machine, it can run this installer for you. You can simply ask the agent to install the wallet, and it can perform the file setup, Python setup, and selected host-bridge setup automatically.
 
 By default it will:
 
@@ -562,6 +575,18 @@ That native plugin package is additive. Keep the existing runtime installer for
 npx @agentlayer.tech/wallet install --yes
 ```
 
+To bind a welcome invite from `https://www.agent-layer.tech/onboard` to the
+local Base address during installation:
+
+```bash
+npx @agentlayer.tech/wallet install --yes --invite alw_...
+```
+
+The installer sends only the one-time invite and the public EVM address to the
+AgentLayer onboarding API. It never sends a private key, seed, wallet password,
+local user ID, or telemetry install ID. A network or EVM provisioning failure
+does not consume the invite and does not roll back the wallet installation.
+
 The ClawHub plugin package auto-checks `~/.openclaw/agent-wallet-runtime/current/agent-wallet` before it falls back to a local workspace checkout.
 
 Public-safe helper scripts are available in `agent-wallet/scripts/`:

package/agent-wallet/UPGRADE_COMPATIBILITY.md

@@ -20,8 +20,9 @@ Raising the floor requires all of the following:
 
 | Path | Purpose | Removal condition |
 |---|---|---|
-| JavaScript boot-key fallback | Updates runtimes that predate the verified Python installer resolver. | The supported floor includes `resolve_boot_key_for_installer`, and direct-upgrade fixtures no longer require the fallback. |
+| JavaScript boot-key fallback | Updates runtimes that predate the verified Python installer resolver. | The supported floor no longer includes releases without `resolve_boot_key_for_installer`; until then, isolated CI upgrades the published `0.1.53` package to the packed candidate and verifies boot-key, sealed-bundle, wallet-file, and address identity. |
 | Directory runtime-pointer migration | Converts pre-versioned `current/` directories into release entries. | The supported floor guarantees symlink-based runtime pointers. |
+| OpenClaw legacy adoption | Recognizes an AgentLayer entry whose package or extension path belongs to the active runtime home. | The supported floor guarantees an `integrations.json` OpenClaw ownership entry. |
 | Hermes legacy adoption | Recognizes an AgentLayer plugin installed before the ownership registry. | The supported floor guarantees an `integrations.json` Hermes ownership entry. |
 | Codex legacy adoption | Recognizes a matching local marketplace registration and AgentLayer manifest. | The supported floor guarantees an `integrations.json` Codex ownership entry. |
 | Claude Code legacy adoption | Recognizes the AgentLayer marketplace and plugin manifest before registry ownership. | The supported floor guarantees an `integrations.json` Claude Code ownership entry. |

package/agent-wallet/agent_wallet/__init__.py

@@ -2,7 +2,7 @@
 
 # Keep in sync with package.json, pyproject.toml, and the npm installer version.
 # scripts/check_release_version.mjs enforces this on release.
-__version__ = "0.1.90"
+__version__ = "0.1.92"
 
 __all__ = [
     "config",

package/agent-wallet/agent_wallet/boot_key_migration.py

@@ -12,8 +12,8 @@ from pathlib import Path
 
 from agent_wallet.config import (
     read_boot_key_from_keystore,
+    resolve_boot_key,
     resolve_openclaw_home,
-    settings,
 )
 from agent_wallet.file_ops import atomic_write_text
 from agent_wallet.keystore import (
@@ -26,20 +26,6 @@ from agent_wallet.keystore import (
 _ENV_LINE_PREFIX = "AGENT_WALLET_BOOT_KEY="
 
 
-def _read_legacy_boot_key() -> str:
-    """The authoritative live key from legacy sources only (env override -> file)."""
-    direct = os.getenv("AGENT_WALLET_BOOT_KEY", settings.agent_wallet_boot_key).strip()
-    if direct:
-        return direct
-    key_file = os.getenv("AGENT_WALLET_BOOT_KEY_FILE", settings.agent_wallet_boot_key_file).strip()
-    if key_file:
-        try:
-            return Path(key_file).expanduser().read_text(encoding="utf-8").strip()
-        except OSError:
-            return ""
-    return ""
-
-
 def _env_boot_key_value(line: str) -> str | None:
     """Return the boot-key value on an AGENT_WALLET_BOOT_KEY= line, else None."""
     stripped = line.strip()
@@ -140,23 +126,26 @@ def migrate_boot_key_to_keystore() -> dict:
                 "removed_boot_key_file": False, "reason": "no-os-keystore"}
 
     authoritative = read_boot_key_from_keystore()
+    resolved = resolve_boot_key()
     first_time = False
-    if not authoritative:
-        legacy_key = _read_legacy_boot_key()
-        if not legacy_key:
+    if authoritative != resolved:
+        if not resolved:
             return {"migrated": False, "backend": store.backend_id, "swept_env_files": 0,
                     "removed_boot_key_file": False, "reason": "no-legacy-key"}
         try:
-            store.set(BOOT_KEY_ITEM, legacy_key)
+            store.set(BOOT_KEY_ITEM, resolved)
         except Exception as exc:
             return {"migrated": False, "backend": store.backend_id, "swept_env_files": 0,
                     "removed_boot_key_file": False, "reason": f"keystore-set-failed: {exc}"}
         # Verify-before-delete.
-        if store.get(BOOT_KEY_ITEM) != legacy_key:
+        if store.get(BOOT_KEY_ITEM) != resolved:
             return {"migrated": False, "backend": store.backend_id, "swept_env_files": 0,
                     "removed_boot_key_file": False, "reason": "verify-failed"}
-        authoritative = legacy_key
+        authoritative = resolved
         first_time = True
+    elif not authoritative:
+        return {"migrated": False, "backend": store.backend_id, "swept_env_files": 0,
+                "removed_boot_key_file": False, "reason": "no-legacy-key"}
 
     record_keystore_backend(store)
     swept, removed = _sweep_plaintext(home, authoritative)

package/agent-wallet/agent_wallet/config.py

@@ -448,6 +448,19 @@ def read_boot_key_from_keystore() -> str:
         return ""
 
 
+def read_boot_key_from_legacy_unscoped_keystore() -> str:
+    """Read the pre-home-scoping native service for compatibility only."""
+    sealed_path = resolve_openclaw_home() / "sealed_keys.json"
+    if not sealed_path.exists():
+        return ""
+    try:
+        from agent_wallet.keystore import read_legacy_unscoped_boot_key
+
+        return read_legacy_unscoped_boot_key()
+    except Exception:
+        return ""
+
+
 def _read_boot_key_file(path_value: str) -> str:
     if not path_value.strip():
         return ""
@@ -477,6 +490,13 @@ def _boot_key_candidates() -> Iterator[tuple[str, str]]:
     if keystore_item:
         yield keystore_item
 
+    legacy_keystore_item = candidate(
+        "legacy_unscoped_keystore",
+        read_boot_key_from_legacy_unscoped_keystore(),
+    )
+    if legacy_keystore_item:
+        yield legacy_keystore_item
+
     configured_file = os.getenv(
         "AGENT_WALLET_BOOT_KEY_FILE", settings.agent_wallet_boot_key_file
     ).strip()

package/agent-wallet/agent_wallet/evm_user_wallets.py

@@ -200,6 +200,121 @@ def _listening_pids(port: int) -> list[int]:
     return pids
 
 
+def _daemon_takeover_disabled() -> bool:
+    return os.getenv("OPENCLAW_EVM_DISABLE_DAEMON_TAKEOVER", "").strip().lower() in {
+        "1",
+        "true",
+        "yes",
+        "on",
+    }
+
+
+def _takeover_refusal(port: int, listeners: list[int], data_dir: str, reason: str) -> str:
+    pids = ", ".join(str(pid) for pid in listeners) if listeners else "unknown"
+    return (
+        f"Refusing to stop the wdk-evm-wallet on port {port}: {reason}. "
+        f"Listening PIDs: {pids}. Daemon dataDir: {data_dir or 'unknown'}. "
+        f"To clear it manually: lsof -nP -iTCP:{port} -sTCP:LISTEN, then kill <pid>."
+    )
+
+
+def _process_cwd(pid: int) -> Path | None:
+    """Return a process working directory via lsof, or None when unverified."""
+    lsof = shutil.which("lsof")
+    if not lsof:
+        return None
+    try:
+        completed = subprocess.run(  # noqa: S603
+            [lsof, "-a", "-p", str(pid), "-d", "cwd", "-Fn"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if completed.returncode != 0:
+        return None
+    for line in completed.stdout.splitlines():
+        if line.startswith("n") and line[1:].strip():
+            try:
+                return Path(line[1:].strip()).resolve()
+            except OSError:
+                return None
+    return None
+
+
+def _process_exists(pid: int) -> bool:
+    try:
+        os.kill(pid, 0)
+        return True
+    except ProcessLookupError:
+        return False
+    except PermissionError:
+        return True
+
+
+def _process_released_service(pid: int, port: int, service_url: str) -> bool:
+    if not _process_exists(pid):
+        return True
+    # A daemon signalled by a process other than its parent can remain briefly
+    # as a zombie. Once its listener and health endpoint are both gone, it no
+    # longer blocks the updated runtime and is considered released.
+    return pid not in _listening_pids(port) and _service_health(service_url) is None
+
+
+def _owner_matches(
+    owner: dict[str, Any] | None,
+    current_health: dict[str, Any],
+    *,
+    pid: int,
+    port: int,
+) -> bool:
+    if owner is None:
+        return not _service_owner_path().exists()
+    try:
+        owner_pid = int(owner.get("pid") or 0)
+        owner_port = int(owner.get("port") or 0)
+    except (TypeError, ValueError):
+        return False
+    return (
+        owner_pid == pid
+        and owner_port == port
+        and _same_path(owner.get("data_dir"), _expected_local_service_data_dir())
+        and str(owner.get("instance_id") or "")
+        == str(current_health.get("instanceId") or "")
+    )
+
+
+def _resolve_stoppable_pid(current_health: dict[str, Any], port: int) -> int:
+    """Return a strictly verified same-home daemon PID, or 0 to fail closed."""
+    reported_data_dir = str(current_health.get("dataDir") or "").strip()
+    if not _same_path(reported_data_dir, _expected_local_service_data_dir()):
+        return 0
+    listeners = _listening_pids(port)
+    if not listeners:
+        return 0
+    try:
+        reported_pid = int(current_health.get("pid") or 0)
+    except (TypeError, ValueError):
+        reported_pid = 0
+    if reported_pid > 0:
+        if reported_pid not in listeners:
+            return 0
+        candidate = reported_pid
+    elif len(listeners) == 1:
+        # One-time compatibility for a pre-PID daemon. The listener and its
+        # working directory still have to identify the bundled service.
+        candidate = listeners[0]
+    else:
+        return 0
+    cwd = _process_cwd(candidate)
+    if cwd is None or cwd.name != "wdk-evm-wallet":
+        return 0
+    if not _owner_matches(_read_service_owner(), current_health, pid=candidate, port=port):
+        return 0
+    return candidate
+
+
 def _stop_local_service(service_url: str, health: dict[str, Any] | None = None) -> None:
     """Gracefully stop a local wdk-evm-wallet daemon so a fresh one can start.
 
@@ -212,37 +327,57 @@ def _stop_local_service(service_url: str, health: dict[str, Any] | None = None)
             f"Refusing to stop an unidentified service on port {port}."
         )
     listeners = _listening_pids(port)
-    owner = _read_service_owner()
-    expected_instance = _expected_local_service_instance_id()
-    reported_instance = str(current_health.get("instanceId") or "").strip()
     reported_data_dir = str(current_health.get("dataDir") or "").strip()
-    try:
-        reported_pid = int(current_health.get("pid") or 0)
-    except (TypeError, ValueError):
-        reported_pid = 0
 
-    owned_pid = 0
-    if reported_instance == expected_instance and reported_pid > 0:
-        owner_matches = (
-            not owner
-            or (
-                int(owner.get("pid") or 0) == reported_pid
-                and str(owner.get("instance_id") or "") == expected_instance
-                and int(owner.get("port") or 0) == port
+    if _daemon_takeover_disabled():
+        raise WalletBackendError(
+            _takeover_refusal(
+                port,
+                listeners,
+                reported_data_dir,
+                "takeover is disabled by OPENCLAW_EVM_DISABLE_DAEMON_TAKEOVER",
             )
-            or int(owner.get("pid") or 0) not in listeners
         )
-        if owner_matches and (not listeners or reported_pid in listeners):
-            owned_pid = reported_pid
-    elif not reported_instance and reported_data_dir and len(listeners) == 1:
-        # One-time compatibility path for pre-instance-id daemons.
-        owned_pid = listeners[0]
 
+    if not _same_path(reported_data_dir, _expected_local_service_data_dir()):
+        raise WalletBackendError(
+            _takeover_refusal(
+                port,
+                listeners,
+                reported_data_dir,
+                "the daemon belongs to a different wallet home",
+            )
+        )
+
+    owned_pid = _resolve_stoppable_pid(current_health, port)
     if owned_pid <= 0:
         raise WalletBackendError(
-            f"A stale wdk-evm-wallet is running on port {port} but ownership could not be verified. "
-            "Stop it manually and retry."
+            _takeover_refusal(
+                port,
+                listeners,
+                reported_data_dir,
+                "the listening process could not be identified",
+            )
         )
+
+    try:
+        os.kill(owned_pid, 0)
+    except ProcessLookupError:
+        try:
+            _service_owner_path().unlink()
+        except FileNotFoundError:
+            pass
+        return
+    except PermissionError as exc:
+        raise WalletBackendError(
+            _takeover_refusal(
+                port,
+                listeners,
+                reported_data_dir,
+                f"pid {owned_pid} belongs to another user ({exc})",
+            )
+        ) from exc
+
     try:
         os.kill(owned_pid, signal.SIGTERM)
     except ProcessLookupError:
@@ -253,20 +388,36 @@ def _stop_local_service(service_url: str, health: dict[str, Any] | None = None)
         ) from exc
     deadline = time.time() + 10.0
     while time.time() < deadline:
-        if _service_health(service_url) is None:
+        if _process_released_service(owned_pid, port, service_url):
             try:
                 _service_owner_path().unlink()
             except FileNotFoundError:
                 pass
             return
         time.sleep(0.3)
+    # Re-run the socket/cwd/owner checks immediately before a hard stop. A PID
+    # that exited and was reused must never inherit permission from old health.
+    refreshed_health = _service_health(service_url)
+    if (
+        not refreshed_health
+        or refreshed_health.get("service") != "wdk-evm-wallet"
+        or _resolve_stoppable_pid(refreshed_health, port) != owned_pid
+    ):
+        raise WalletBackendError(
+            _takeover_refusal(
+                port,
+                _listening_pids(port),
+                str((refreshed_health or {}).get("dataDir") or ""),
+                "process identity changed before the hard stop",
+            )
+        )
     try:
         os.kill(owned_pid, signal.SIGKILL)
     except ProcessLookupError:
         pass
     deadline = time.time() + 5.0
     while time.time() < deadline:
-        if _service_health(service_url) is None:
+        if _process_released_service(owned_pid, port, service_url):
             try:
                 _service_owner_path().unlink()
             except FileNotFoundError:

package/agent-wallet/agent_wallet/keystore.py

@@ -13,6 +13,7 @@ BOOT_KEY_KEYCHAIN_ARCHITECTURE.md.
 
 from __future__ import annotations
 
+import hashlib
 import json
 import os
 import platform
@@ -36,9 +37,53 @@ _SUBPROCESS_TIMEOUT = 10.0
 
 
 def _service() -> str:
-    """Keychain/Secret-Service service name. Overridable so tests never touch the
-    real shared slot (the OS keychain is global, not scoped to OPENCLAW_HOME)."""
-    return os.getenv("AGENT_WALLET_KEYSTORE_SERVICE", "").strip() or KEYSTORE_SERVICE
+    """Return the keystore namespace for the active wallet home.
+
+    Desktop keystores are global to the OS account, while ``OPENCLAW_HOME`` can
+    point at an isolated test or secondary installation. Keep the historical
+    service for the default home, but derive a stable namespace for every other
+    home so one installation cannot replace another installation's boot key.
+    Tests can still choose a readable throwaway namespace explicitly.
+    """
+    explicit = os.getenv("AGENT_WALLET_KEYSTORE_SERVICE", "").strip()
+    if explicit:
+        return explicit
+    home = resolve_openclaw_home().expanduser().resolve()
+    default_home = (_account_home() / ".openclaw").resolve()
+    if home == default_home:
+        return KEYSTORE_SERVICE
+    home_hash = hashlib.sha256(str(home).encode("utf-8")).hexdigest()[:16]
+    return f"{KEYSTORE_SERVICE}.home-{home_hash}"
+
+
+def _account_home() -> Path:
+    """Return the OS account home without trusting a test-overridden ``HOME``."""
+    if os.name == "nt":
+        user_profile = os.getenv("USERPROFILE", "").strip()
+        if user_profile:
+            return Path(user_profile)
+        drive = os.getenv("HOMEDRIVE", "").strip()
+        home_path = os.getenv("HOMEPATH", "").strip()
+        if drive and home_path:
+            return Path(f"{drive}{home_path}")
+    try:
+        import pwd
+
+        return Path(pwd.getpwuid(os.getuid()).pw_dir)
+    except (ImportError, KeyError, OSError):
+        return Path.home()
+
+
+def _legacy_unscoped_service() -> str | None:
+    """Return the pre-home-scoping service for safe compatibility reads."""
+    if os.getenv("AGENT_WALLET_KEYSTORE_SERVICE", "").strip():
+        return None
+    if _service() == KEYSTORE_SERVICE:
+        return None
+    state = _read_backend_state_payload()
+    if state and state["service"] == KEYSTORE_SERVICE:
+        return KEYSTORE_SERVICE
+    return None
 
 
 def _backend_preference() -> str:
@@ -56,7 +101,7 @@ def _state_path() -> Path:
     return resolve_openclaw_home() / "keystore" / _KEYSTORE_STATE_FILENAME
 
 
-def _read_backend_state() -> dict[str, str] | None:
+def _read_backend_state_payload() -> dict[str, str] | None:
     try:
         payload = json.loads(_state_path().read_text(encoding="utf-8"))
     except (OSError, ValueError):
@@ -72,9 +117,17 @@ def _read_backend_state() -> dict[str, str] | None:
         "plaintext-file",
     }:
         return None
+    return {"backend": backend, "service": service}
+
+
+def _read_backend_state() -> dict[str, str] | None:
+    payload = _read_backend_state_payload()
+    if payload is None:
+        return None
+    service = payload["service"]
     if service != _service():
         return None
-    return {"backend": backend, "service": service}
+    return payload
 
 
 class KeyStoreError(Exception):
@@ -129,11 +182,14 @@ def _run(
 class MacKeychainStore:
     backend_id = "macos-keychain"
 
+    def __init__(self, service: str | None = None) -> None:
+        self.service = service or _service()
+
     def available(self) -> bool:
         return platform.system() == "Darwin" and Path(_SECURITY_BIN).exists()
 
     def get(self, name: str) -> str | None:
-        proc = _run([_SECURITY_BIN, "find-generic-password", "-s", _service(), "-a", name, "-w"])
+        proc = _run([_SECURITY_BIN, "find-generic-password", "-s", self.service, "-a", name, "-w"])
         if proc.returncode != 0:
             return None  # item not found (44) or other non-fatal lookup miss
         value = proc.stdout.rstrip("\n")
@@ -150,17 +206,17 @@ class MacKeychainStore:
         # Trade-off: any process running as this user can read the key without a
         # prompt — the same runtime exposure as a 0600 file. At-rest protection
         # (backups, synced home dirs, a stolen disk) is fully preserved.
-        _run([_SECURITY_BIN, "delete-generic-password", "-s", _service(), "-a", name])
+        _run([_SECURITY_BIN, "delete-generic-password", "-s", self.service, "-a", name])
         proc = _run([
             _SECURITY_BIN, "add-generic-password",
-            "-s", _service(), "-a", name,
+            "-s", self.service, "-a", name,
             "-w", value, "-A",
         ])
         if proc.returncode != 0:
             raise KeyStoreError(f"security add-generic-password failed: {proc.stderr.strip()}")
 
     def delete(self, name: str) -> None:
-        _run([_SECURITY_BIN, "delete-generic-password", "-s", _service(), "-a", name])
+        _run([_SECURITY_BIN, "delete-generic-password", "-s", self.service, "-a", name])
 
 
 class WindowsDpapiStore:
@@ -215,19 +271,22 @@ class WindowsDpapiStore:
 class LinuxSecretServiceStore:
     backend_id = "linux-secretservice"
 
+    def __init__(self, service: str | None = None) -> None:
+        self.service = service or _service()
+
     def available(self) -> bool:
         if platform.system() != "Linux" or shutil.which("secret-tool") is None:
             return False
         # A probe lookup succeeds (rc 0/1) only when a Secret Service answers;
         # a missing/unreachable service errors out (rc >1) or times out.
         try:
-            proc = _run(["secret-tool", "lookup", "service", _service(), "account", "__probe__"])
+            proc = _run(["secret-tool", "lookup", "service", self.service, "account", "__probe__"])
         except subprocess.TimeoutExpired:
             return False
         return proc.returncode in (0, 1)
 
     def get(self, name: str) -> str | None:
-        proc = _run(["secret-tool", "lookup", "service", _service(), "account", name])
+        proc = _run(["secret-tool", "lookup", "service", self.service, "account", name])
         if proc.returncode != 0:
             return None
         value = proc.stdout.rstrip("\n")
@@ -235,15 +294,15 @@ class LinuxSecretServiceStore:
 
     def set(self, name: str, value: str) -> None:
         proc = _run(
-            ["secret-tool", "store", "--label", f"{_service()} {name}",
-             "service", _service(), "account", name],
+            ["secret-tool", "store", "--label", f"{self.service} {name}",
+             "service", self.service, "account", name],
             input_text=value,
         )
         if proc.returncode != 0:
             raise KeyStoreError(f"secret-tool store failed: {proc.stderr.strip()}")
 
     def delete(self, name: str) -> None:
-        _run(["secret-tool", "clear", "service", _service(), "account", name])
+        _run(["secret-tool", "clear", "service", self.service, "account", name])
 
 
 class PlaintextFileStore:
@@ -340,16 +399,52 @@ def _resolve_keystore_uncached() -> KeyStore:
     return PlaintextFileStore()
 
 
-def _store_for_backend(backend_id: str) -> KeyStore | None:
+def _store_for_backend(backend_id: str, *, service: str | None = None) -> KeyStore | None:
     stores: dict[str, KeyStore] = {
-        "macos-keychain": MacKeychainStore(),
+        "macos-keychain": MacKeychainStore(service),
         "windows-dpapi": WindowsDpapiStore(),
-        "linux-secretservice": LinuxSecretServiceStore(),
+        "linux-secretservice": LinuxSecretServiceStore(service),
         "plaintext-file": PlaintextFileStore(),
     }
     return stores.get(backend_id)
 
 
+def read_legacy_unscoped_boot_key() -> str:
+    """Read the historical global service without probing or writing it.
+
+    This is used only as a compatibility candidate for an existing sealed
+    custom-home installation. The caller must verify the value against that
+    home's ``sealed_keys.json`` before accepting or migrating it.
+    """
+    legacy_service = _legacy_unscoped_service()
+    preference = _backend_preference()
+    if not legacy_service or preference in {"plain", "plaintext", "plaintext-file", "file"}:
+        return ""
+
+    if preference in {"macos", "macos-keychain", "keychain"}:
+        candidates: list[KeyStore] = [MacKeychainStore(legacy_service)]
+    elif preference in {"linux", "linux-secretservice", "secretservice"}:
+        candidates = [LinuxSecretServiceStore(legacy_service)]
+    elif preference in {"windows", "windows-dpapi", "dpapi"}:
+        candidates = []
+    else:
+        candidates = [
+            MacKeychainStore(legacy_service),
+            LinuxSecretServiceStore(legacy_service),
+        ]
+
+    for candidate in candidates:
+        try:
+            if not candidate.available():
+                continue
+            value = candidate.get(BOOT_KEY_ITEM)
+            if isinstance(value, str) and value.strip():
+                return value.strip()
+        except Exception:
+            continue
+    return ""
+
+
 def record_keystore_backend(store: KeyStore) -> dict[str, object]:
     """Persist a verified boot-key backend without replacing a temporary fallback."""
     existing = _read_backend_state()

package/agent-wallet/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agent-wallet",
   "name": "Agent Wallet",
   "description": "Plugin-friendly wallet backend for OpenClaw agents with safe wallet tools and runtime instructions across Solana, local BTC, and local EVM.",
-  "version": "0.1.90",
+  "version": "0.1.92",
   "skills": ["skills/wallet-operator"],
   "configSchema": {
     "type": "object",

package/agent-wallet/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openclaw-agent-wallet"
-version = "0.1.90"
+version = "0.1.92"
 description = "Plugin-friendly wallet backend for OpenClaw agents"
 requires-python = ">=3.10"
 dependencies = [