@agentlayer.tech/wallet 0.1.90 → 0.1.91

package/.openclaw/extensions/agent-wallet/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agent-wallet",
   "name": "Agent Wallet",
   "description": "Official OpenClaw plugin bridge for the agent-wallet backends, including Solana, local BTC, and local EVM.",
-  "version": "0.1.90",
+  "version": "0.1.91",
   "contracts": {
     "tools": [
       "agentlayer_autonomous_approve",

package/.openclaw/extensions/agent-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayertech/agent-wallet-plugin",
-  "version": "0.1.90",
+  "version": "0.1.91",
   "description": "OpenClaw plugin bridge for the AgentLayer wallet runtime.",
   "type": "module",
   "license": "SEE LICENSE IN ../../../LICENSE",

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## Unreleased
 
+- Added a universal npm installer for OpenClaw, Codex, Claude Code, and Hermes.
+  `wallet install` now detects installed agent frameworks, supports explicit
+  `--hosts`, `--exclude`, and `--runtime-only` selection, and exposes
+  `wallet detect --json`. Runtime updates remain managed-only, so discovering a
+  new framework later does not silently enroll it. OpenClaw config creation is
+  now a host-specific step; wallet files and sealed secrets remain in their
+  existing `~/.openclaw` locations and are not replaced during updates.
+
+- Confirmed the native OS keystore as the default boot-key backend. `auto`
+  prefers macOS Keychain, Windows DPAPI, or Linux Secret Service and uses the
+  local `0600` file only as a fallback. The npm installer now warns macOS users
+  that the system may request Keychain confirmation; this does not rotate or
+  migrate the boot key during ordinary updates.
+
 - Hardened Morpho EVM operations with a 30% gas-limit buffer calculated from
   the exact final calldata immediately before sending. Morpho vault and market
   writes now wait for their final on-chain receipt and report reverts instead

package/README.md

@@ -6,23 +6,32 @@
 [![Node 24.x](https://img.shields.io/badge/node-24.x-339933?logo=node.js&logoColor=white)](https://nodejs.org/)
 [![docs](https://img.shields.io/badge/docs-agent--layer.tech-blue)](https://docs.agent-layer.tech/)
 
-For Openclaw:
+Install AgentLayer for the agent frameworks already present on the machine:
 
 ```bash
 npx @agentlayer.tech/wallet install --yes
 ```
 
-For Codex:
+The installer detects OpenClaw, Codex, Claude Code, and Hermes, installs the
+shared local runtime once, and connects every detected host. Without `--yes`,
+an interactive terminal asks about each detected host.
+
+To choose hosts explicitly:
 
 ```bash
-npx @agentlayer.tech/wallet install --yes && npx @agentlayer.tech/wallet codex install --yes
+npx @agentlayer.tech/wallet install --yes --hosts codex,claude-code
+npx @agentlayer.tech/wallet install --yes --hosts detected --exclude hermes
+npx @agentlayer.tech/wallet install --yes --runtime-only
+npx @agentlayer.tech/wallet detect --json
 ```
 
-For Claude Code:
+The legacy `wallet codex install`, `wallet claude-code install`, and
+`wallet hermes install` commands remain supported as explicit repair/install
+commands.
 
-```bash
-npx @agentlayer.tech/wallet install --yes && npx @agentlayer.tech/wallet claude-code install --yes
-```
+On a machine with an existing AgentLayer runtime, a plain `wallet install`
+touches only already-managed hosts. To enroll a framework installed later, run
+`wallet install --yes --hosts detected` or name it explicitly.
 
 Or install entirely from inside the Claude Code CLI, via the plugin marketplace
 (no terminal/npx needed) — two commands, then restart:
@@ -32,13 +41,6 @@ Or install entirely from inside the Claude Code CLI, via the plugin marketplace
 /plugin install agent-wallet@agentlayer
 ```
 
-For Hermes:
-
-```bash
-npx @agentlayer.tech/wallet install --yes && npx @agentlayer.tech/wallet hermes install --yes
-```
-
-
 AgentLayer is a beta local-first wallet and finance stack for agents.
 
 The repository includes:
@@ -72,7 +74,7 @@ System prerequisites:
 - `node` `24.x`
 - `npm`
 
-Install the local runtime:
+Install the local runtime and connect detected agent frameworks:
 
 ```bash
 npx @agentlayer.tech/wallet install --yes
@@ -102,13 +104,26 @@ The CLI uses a versioned runtime layout:
 ~/.openclaw/agent-wallet-runtime/current              # symlink → active release
 ```
 
-On first install, `--yes` generates local runtime secrets. The installer stores `master_key` and `approval_secret` in `~/.openclaw/sealed_keys.json`; the boot key needed to unlock that sealed bundle stays in the prompt-free local fallback by default. macOS Keychain is opt-in (`AGENT_WALLET_KEYSTORE_BACKEND=macos-keychain`) because probing it can open a system password dialog during install or startup.
+`~/.openclaw` remains the shared AgentLayer runtime root even when OpenClaw is
+not installed. A Codex-only or Claude-only install creates the runtime there
+but does not create or patch `openclaw.json`.
+
+On first install, `--yes` generates local runtime secrets. The installer stores
+`master_key` and `approval_secret` in `~/.openclaw/sealed_keys.json`. The boot
+key needed to unlock that sealed bundle uses `AGENT_WALLET_KEYSTORE_BACKEND=auto`
+by default: it prefers the native OS keystore and falls back to a local `0600`
+file only when the native backend is unavailable. On macOS this means the login
+Keychain (`service=ai.agentlayer.wallet`, `account=boot_key`). macOS may show a
+Keychain access or password confirmation depending on the current Keychain
+state; approve it only when you initiated the AgentLayer install or update.
+Existing installs keep the same boot-key value during upgrades.
 
 Useful CLI commands (require the global install above):
 
 ```bash
 wallet status                    # show active runtime version and health
 wallet doctor                    # diagnose common config problems
+wallet detect --json             # show detected and already-managed hosts
 wallet update --yes              # upgrade to the latest published version
 wallet update --yes --dry-run    # preview the upgrade without applying it
 wallet rollback                  # revert to the previous release
@@ -116,7 +131,14 @@ wallet hermes install --yes      # (re)connect Hermes to the current runtime
 wallet codex install --yes       # (re)connect Codex to the current runtime
 ```
 
-`wallet update --yes` fetches the latest npm package, installs it under `releases/<version>`, and flips the `current` symlink. Python and Node dependency snapshots are reused when the dependency fingerprint has not changed, so subsequent updates are fast. All frameworks that read from `current/` (Claude Code, Codex, Hermes) pick up the new code automatically on their next session start; OpenClaw requires a gateway restart to reload its TypeScript extension.
+`wallet update --yes` fetches the latest npm package, installs it under
+`releases/<version>`, and flips the `current` symlink. Updates repair only hosts
+already recorded as AgentLayer-managed; a newly detected framework is never
+silently enrolled during update. Python and Node dependency snapshots are
+reused when the dependency fingerprint has not changed, so subsequent updates
+are fast. All frameworks that read from `current/` (Claude Code, Codex, Hermes)
+pick up the new code automatically on their next session start; OpenClaw
+requires a gateway restart to reload its TypeScript extension.
 
 ## Native OpenClaw plugin installs
 
@@ -280,10 +302,10 @@ For the default Solana flow, run the installer directly:
 npx @agentlayer.tech/wallet install --yes
 ```
 
-That installs the runtime, patches the OpenClaw plugin config, generates local
+That installs the runtime, connects each detected framework, generates local
 runtime secrets when missing, and creates the first encrypted per-user Solana
-mainnet wallet. The agent receives the public address and guarded wallet tools,
-not the private key.
+mainnet wallet. `openclaw.json` is patched only when OpenClaw is selected. The
+agent receives the public address and guarded wallet tools, not the private key.
 
 BTC and EVM are separate host-side setup flows.
 
@@ -377,10 +399,11 @@ The installer then:
 - creates `agent-wallet/.env` from `agent-wallet/.env.example` if it does not exist
 - creates `agent-wallet/.runtime-venv` and installs the Python backend
 - installs Node dependencies for `wdk-btc-wallet`, `wdk-evm-wallet`, and `flash-sdk-bridge`
-- creates a minimal `~/.openclaw/openclaw.json` if one does not exist
 - if the required secrets are already present, writes or updates `~/.openclaw/sealed_keys.json`
-- if the required secrets are already present, patches `~/.openclaw/openclaw.json` to load the `agent-wallet` extension and point it at the installed runtime
-- `wallet hermes install --yes` additionally connects Hermes Agent to the same runtime without copying wallet tools or policy
+- detects OpenClaw, Codex, Claude Code, and Hermes before changing host config
+- connects the selected hosts to `agent-wallet-runtime/current`
+- creates or patches `~/.openclaw/openclaw.json` only when OpenClaw is selected
+- records non-secret ownership metadata so later updates repair only managed hosts
 
 When the installer reaches the final config step, the default plugin config is:
 

package/VERSION

@@ -1 +1 @@
-0.1.90
+0.1.91

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.91"
 
 __all__ = [
     "config",

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.91",
   "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.91"
 description = "Plugin-friendly wallet backend for OpenClaw agents"
 requires-python = ">=3.10"
 dependencies = [

package/agent-wallet/scripts/install_agent_wallet.py

@@ -7,13 +7,20 @@ import hashlib
 import json
 import os
 import platform
+import re
 import shutil
 import subprocess
 import sys
 import tempfile
+import urllib.error
+import urllib.request
 import venv
 from pathlib import Path
 
+WELCOME_INVITE_PATTERN = re.compile(r"^alw_[A-Za-z0-9_-]{43}$")
+DEFAULT_ONBOARDING_BIND_URL = "https://www.agent-layer.tech/api/onboarding/bind-wallet"
+ONBOARDING_HTTP_TIMEOUT_SECONDS = 5.0
+
 INCLUDED_RUNTIME_ROOT_FILES = [
     ".env.example",
     "AGENTS.md",
@@ -192,9 +199,16 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--network", default="mainnet")
     parser.add_argument("--rpc-url", default="")
     parser.add_argument("--rpc-urls", default="")
+    parser.add_argument("--invite", default="")
     parser.add_argument("--sign-only", action=argparse.BooleanOptionalAction, default=False)
     parser.add_argument("--sync-runtime", action=argparse.BooleanOptionalAction, default=True)
     parser.add_argument("--install-from-runtime", action=argparse.BooleanOptionalAction, default=False)
+    parser.add_argument(
+        "--configure-openclaw",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Patch openclaw.json during install (disabled by the universal host orchestrator).",
+    )
     parser.add_argument("--skip-python-setup", action=argparse.BooleanOptionalAction, default=False)
     parser.add_argument("--skip-node-setup", action=argparse.BooleanOptionalAction, default=False)
     parser.add_argument("--dry-run", action=argparse.BooleanOptionalAction, default=False)
@@ -856,6 +870,149 @@ def _bootstrap_evm_wallet(
     }
 
 
+def _onboarding_bind_url() -> str:
+    return (
+        os.getenv("AGENTLAYER_ONBOARDING_BIND_URL", "").strip()
+        or DEFAULT_ONBOARDING_BIND_URL
+    )
+
+
+def _onboarding_error_code(payload: object, fallback: str) -> str:
+    if not isinstance(payload, dict):
+        return fallback
+    code = str(payload.get("error") or "").strip().lower()
+    allowed = {
+        "address_already_used",
+        "internal_error",
+        "invalid_base_address",
+        "invalid_invite",
+        "invite_already_bound",
+        "invite_expired",
+        "invite_revoked",
+        "request_too_large",
+    }
+    return code if code in allowed else fallback
+
+
+def _decode_onboarding_response(raw: bytes) -> object:
+    try:
+        return json.loads(raw.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError):
+        return {}
+
+
+def _bind_welcome_invite(
+    invite: str,
+    address: str,
+    *,
+    api_url: str | None = None,
+    timeout_seconds: float = ONBOARDING_HTTP_TIMEOUT_SECONDS,
+    opener: object = urllib.request.urlopen,
+    attempts: int = 2,
+) -> dict[str, object]:
+    normalized_invite = invite.strip()
+    normalized_address = address.strip()
+    if not WELCOME_INVITE_PATTERN.fullmatch(normalized_invite):
+        return {"ok": False, "status": "invalid_invite", "retryable": False}
+    if not re.fullmatch(r"0x[0-9a-fA-F]{40}", normalized_address):
+        return {"ok": False, "status": "invalid_base_address", "retryable": False}
+
+    body = json.dumps({"address": normalized_address}).encode("utf-8")
+    request = urllib.request.Request(
+        api_url or _onboarding_bind_url(),
+        data=body,
+        method="POST",
+        headers={
+            "Authorization": f"Bearer {normalized_invite}",
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "User-Agent": "AgentLayer-Wallet-Installer",
+        },
+    )
+    max_attempts = max(1, min(int(attempts), 3))
+    for attempt in range(max_attempts):
+        try:
+            with opener(request, timeout=timeout_seconds) as response:  # type: ignore[operator]
+                status_code = int(getattr(response, "status", 200))
+                payload = _decode_onboarding_response(response.read(65_536))
+            if status_code < 200 or status_code >= 300 or not isinstance(payload, dict):
+                if status_code >= 500 and attempt + 1 < max_attempts:
+                    continue
+                return {
+                    "ok": False,
+                    "status": _onboarding_error_code(payload, "service_error"),
+                    "retryable": status_code >= 500,
+                }
+            binding_status = str(payload.get("status") or "")
+            response_address = str(payload.get("address") or "")
+            if (
+                payload.get("ok") is not True
+                or binding_status not in {"bound", "already_bound"}
+                or response_address.lower() != normalized_address.lower()
+            ):
+                return {"ok": False, "status": "invalid_response", "retryable": True}
+            return {
+                "ok": True,
+                "status": binding_status,
+                "network": "base",
+                "address": response_address,
+            }
+        except urllib.error.HTTPError as exc:
+            payload = _decode_onboarding_response(exc.read(65_536))
+            if exc.code >= 500 and attempt + 1 < max_attempts:
+                continue
+            return {
+                "ok": False,
+                "status": _onboarding_error_code(payload, "service_error"),
+                "retryable": exc.code >= 500,
+            }
+        except (urllib.error.URLError, TimeoutError, OSError):
+            if attempt + 1 < max_attempts:
+                continue
+            return {"ok": False, "status": "network_error", "retryable": True}
+    return {"ok": False, "status": "network_error", "retryable": True}
+
+
+def _bind_invite_after_evm_onboard(
+    invite: str,
+    evm_onboard_result: dict[str, object] | None,
+    *,
+    api_url: str | None = None,
+    opener: object = urllib.request.urlopen,
+) -> dict[str, object] | None:
+    if not invite.strip():
+        return None
+    if not isinstance(evm_onboard_result, dict) or not evm_onboard_result.get("ok"):
+        return {"ok": False, "status": "pending_evm_wallet", "retryable": True}
+    address = str(evm_onboard_result.get("address") or "").strip()
+    if not address:
+        return {"ok": False, "status": "pending_evm_wallet", "retryable": True}
+    return _bind_welcome_invite(
+        invite,
+        address,
+        api_url=api_url,
+        opener=opener,
+    )
+
+
+def _invite_binding_warning(binding_result: dict[str, object]) -> str:
+    """Describe a failed invite bind without claiming it can always be retried."""
+    status = str(binding_result.get("status") or "unknown")
+    if status == "invite_already_bound":
+        return (
+            "warning: the welcome invite is already bound to a different Base "
+            "wallet and cannot be used with this wallet. Status: "
+            + status
+        )
+    if binding_result.get("retryable") is True:
+        return (
+            "warning: the welcome invite was not bound; the invite remains "
+            "available for a safe retry. Status: "
+            + status
+        )
+    return "warning: the welcome invite was not bound and cannot be retried. Status: " + status
+
+
 def main() -> None:
     args = build_parser().parse_args()
     source_package_root = Path(args.package_root).expanduser().resolve()
@@ -909,6 +1066,7 @@ def main() -> None:
         wdk_evm_root = source_wdk_evm_root
 
     install_config_script = package_root / "scripts" / "install_openclaw_local_config.py"
+    install_sealed_keys_script = package_root / "scripts" / "install_openclaw_sealed_keys.py"
     if args.install_from_runtime:
         default_source_env_path = source_package_root / ".env"
         default_source_venv_path = source_package_root / ".venv"
@@ -923,7 +1081,7 @@ def main() -> None:
     env_created = _ensure_env_file(env_path, env_example_path)
     boot_key_file_env_updated = _ensure_runtime_boot_key_file_env(env_path)
     flash_bridge_env = _ensure_flash_bridge_env(env_path, package_root)
-    config_created = _ensure_openclaw_config(config_path)
+    config_created = _ensure_openclaw_config(config_path) if args.configure_openclaw else False
 
     python_bin = Path(sys.executable)
     venv_created = False
@@ -988,23 +1146,33 @@ def main() -> None:
     pending_env = _pending_env_names() if backend_enabled else []
     configured = False
     configure_stdout = ""
+    sealed_keys_result: dict[str, object] | None = None
     solana_onboard_result: dict[str, object] | None = None
     evm_onboard_result: dict[str, object] | None = None
+    invite_binding_result: dict[str, object] | None = None
     if backend_enabled and not pending_env and not args.dry_run:
-        result = subprocess.run(
-            _build_next_steps(
-                python_bin,
-                install_config_script,
-                args,
-                package_root=package_root,
-                extension_path=extension_path,
-            ),
+        sealed_result = subprocess.run(
+            [str(python_bin), str(install_sealed_keys_script)],
             capture_output=True,
             text=True,
             check=True,
         )
-        configured = True
-        configure_stdout = result.stdout
+        sealed_keys_result = json.loads(sealed_result.stdout)
+        if args.configure_openclaw:
+            result = subprocess.run(
+                _build_next_steps(
+                    python_bin,
+                    install_config_script,
+                    args,
+                    package_root=package_root,
+                    extension_path=extension_path,
+                ),
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+            configured = True
+            configure_stdout = result.stdout
         solana_onboard_result = _bootstrap_solana_wallet(
             python_bin,
             package_root,
@@ -1027,6 +1195,21 @@ def main() -> None:
                 file=sys.stderr,
             )
 
+    if args.invite.strip():
+        if args.dry_run:
+            invite_binding_result = {
+                "ok": False,
+                "status": "skipped_dry_run",
+                "retryable": True,
+            }
+        else:
+            invite_binding_result = _bind_invite_after_evm_onboard(
+                args.invite,
+                evm_onboard_result,
+            )
+        if invite_binding_result and not invite_binding_result.get("ok"):
+            print(_invite_binding_warning(invite_binding_result), file=sys.stderr)
+
     print(
         json.dumps(
             {
@@ -1037,6 +1220,7 @@ def main() -> None:
                 "flash_bridge_env": flash_bridge_env,
                 "config_path": str(config_path),
                 "config_created": config_created,
+                "configure_openclaw": bool(args.configure_openclaw),
                 "package_root": str(package_root),
                 "extension_path": str(extension_path),
                 "wdk_btc_root": str(wdk_btc_root),
@@ -1051,8 +1235,10 @@ def main() -> None:
                 "runtime_sync": runtime_sync,
                 "configured": configured,
                 "pending_env": pending_env,
+                "sealed_keys": sealed_keys_result,
                 "solana_wallet": solana_onboard_result,
                 "evm_wallet": evm_onboard_result,
+                "invite_binding": invite_binding_result,
                 "next_configure_command": _build_next_steps(
                     python_bin,
                     install_config_script,

package/agent-wallet/scripts/install_openclaw_local_config.py

@@ -271,7 +271,10 @@ def _maybe_install_sealed_keys() -> str | None:
         updates["wdk_evm_wallet_password"] = secrets.token_urlsafe(24)
     if not updates:
         return None
-    return str(seal_keys(boot_key, {**existing, **updates}))
+    merged = {**existing, **updates}
+    if merged == existing:
+        return str(sealed_path)
+    return str(seal_keys(boot_key, merged))
 
 
 def _require_hardened_runtime_secrets(backend: str) -> str | None:

package/agent-wallet/scripts/install_openclaw_sealed_keys.py

@@ -94,15 +94,19 @@ def main() -> None:
             "and/or SOLANA_AGENT_PRIVATE_KEY in the environment."
         )
 
-    path = seal_keys(boot_key, secrets)
+    changed = not sealed_path.exists() or secrets != existing
+    path = seal_keys(boot_key, secrets) if changed else sealed_path
     print(
         json.dumps(
             {
                 "ok": True,
                 "path": str(path),
                 "stored_keys": sorted(secrets.keys()),
-                "updated_keys": sorted(set(updates.keys()) | set(generated_keys)),
+                "updated_keys": (
+                    sorted(set(updates.keys()) | set(generated_keys)) if changed else []
+                ),
                 "replaced": bool(args.replace),
+                "changed": changed,
             },
             indent=2,
         )