@agentlayer.tech/wallet 0.1.73 → 0.1.75

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.73",
+  "version": "0.1.75",
   "contracts": {
     "tools": [
       "agentlayer_autonomous_approve",

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

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

package/CHANGELOG.md

@@ -2,6 +2,78 @@
 
 ## Unreleased
 
+## v0.1.75 - 2026-07-11
+
+- Added a persistent, non-secret ownership registry for OpenClaw, Hermes,
+  Codex, and Claude Code integrations. Explicit installs are now distinguishable
+  from unrelated external plugins across runtime upgrades.
+
+- Fixed `wallet update` so managed framework integrations advance with the
+  verified `current` runtime. OpenClaw config and Hermes paths are repaired,
+  while Codex and Claude Code registrations and versioned caches are refreshed
+  through their host CLIs.
+
+- Added guarded adoption for legacy AgentLayer installs. Existing integrations
+  are adopted only when their registration and plugin manifests both identify
+  AgentLayer; unowned symlinks and external plugins remain untouched.
+
+- Added per-framework synchronization details to `wallet status` and
+  `wallet doctor`, including failed host registration and restart requirements.
+  npm-exec installs also refresh an already-installed stale global CLI without
+  making global installation mandatory.
+
+- Expanded installer regression coverage for managed upgrades, unmanaged
+  integration preservation, global CLI refresh, host registration, and
+  hermetic framework/npm homes.
+
+## v0.1.74 - 2026-07-10
+
+- Added a guarded npm beta-promotion workflow that acceptance-tests the exact
+  registry artifact, verifies its integrity, rejects downgrades, serializes with
+  publish jobs, and restores the previous `latest` tag if verification fails.
+
+- Added a stable per-home identity and verified PID ownership record for the
+  local EVM daemon. Restarts now signal only the confirmed listener, while a
+  bounded single-listener compatibility path upgrades pre-identity daemons.
+
+- Disabled implicit Argon2id-to-HKDF rewrites during normal wallet reads.
+  Opt-in envelope migration now creates and verifies an Argon2id rollback
+  backup, restores the original on write failure, and refuses stale restores
+  after logical secret contents change.
+
+- Persisted the verified boot-key keystore backend under each OpenClaw home so
+  `auto` selection remains stable across updates and desktop session changes.
+  Explicit backend overrides still work, and temporary fallback use does not
+  overwrite the pinned backend.
+
+- Preserved upgrades from pre-resolver runtimes by ordering the legacy Node
+  fallback as keystore, current runtime env, then legacy files. Installer output
+  now reports the non-secret boot-key source, and CI covers conflicting legacy
+  sources, staged verification failures, editor migration, and EVM wrong-home
+  daemon recovery.
+
+- Replaced automatic editor reinstallation after every runtime update with a
+  narrow migration of stale runtime-owned symlinks and Hermes env paths. Codex
+  and Claude MCP source manifests are now immutable; only user-owned Claude
+  cache copies may receive a custom `OPENCLAW_HOME` pin. The versioned runtime
+  now includes the previously omitted `claude-code/` bridge.
+
+- Staged normal installs under hidden `releases/.staging-*` directories and
+  verify them before switching `current`. Failed candidates are moved to
+  `.failed-*`, excluded from `available_releases`, and recorded in an update
+  journal; on failure, existing `current` and `previous` pointers remain untouched.
+
+- Centralized installer boot-key selection in the active Python runtime. When
+  sealed secrets exist, conflicting env, keystore, and legacy-file candidates
+  are tested against `sealed_keys.json`; a stale higher-priority value can no
+  longer mask the key that actually decrypts the bundle. Older runtimes retain
+  the existing JavaScript fallback for upgrade compatibility.
+
+- Removed a test-only `OPENCLAW_HOME` pin that leaked into the published Claude
+  Code MCP manifest. Installer regression tests now isolate every editor home,
+  assert that tracked plugin sources remain unchanged, and inspect the packed
+  npm MCP manifests for temporary or user-specific absolute paths.
+
 ## v0.1.73 - 2026-07-09
 
 - Fixed CLI installer/update boot-key precedence when recovering an existing

package/RELEASING.md

@@ -166,10 +166,29 @@ The GitHub Releases page should contain a new prerelease named
 
 ### Promote a beta to stable
 
-Once a beta checks out, ship the same version as a stable `latest` release by
-following the **Stable Release** steps with the promoted version number (e.g.
-`0.1.11`). The update notice that runtimes show to agents reads the `latest`
-dist-tag, so users are only nudged toward promoted releases, never betas.
+Once a beta checks out, promote the exact published tarball instead of rebuilding
+it under a different version:
+
+1. Open the `promote npm beta` workflow in GitHub Actions.
+2. Enter the current beta version, for example `0.1.11-beta.1`.
+3. Enable the confirmation input and run the workflow.
+
+The workflow verifies that the version is the current `beta`, refuses to move
+`latest` backward, records its registry integrity, and installs that exact npm
+artifact into an isolated OpenClaw home. Only after acceptance succeeds does it
+move `latest`; if post-write verification fails, the previous `latest` is
+restored. The existing GitHub prerelease is then marked stable.
+
+Because npm packages are immutable, the promoted artifact keeps its prerelease
+version string while becoming the stable `latest` channel. This guarantees that
+production receives the same bytes tested on beta.
+
+The workflow requires a repository secret named `NPM_PROMOTION_TOKEN`. npm OIDC
+trusted publishing only authorizes publish operations, not `dist-tag` changes,
+so this must be a granular token scoped to `@agentlayer.tech/wallet` with package
+write access and bypass-2FA enabled. Do not reuse a broad account token.
+Configure required reviewers and main-branch deployment protection on the
+`npm-production` GitHub environment before using promotion in production.
 
 ## What Ships
 

package/VERSION

@@ -1 +1 @@
-0.1.73
+0.1.75

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.73"
+__version__ = "0.1.75"
 
 __all__ = [
     "config",

package/agent-wallet/agent_wallet/boot_key_migration.py

@@ -16,7 +16,12 @@ from agent_wallet.config import (
     settings,
 )
 from agent_wallet.file_ops import atomic_write_text
-from agent_wallet.keystore import BOOT_KEY_ITEM, PlaintextFileStore, resolve_keystore
+from agent_wallet.keystore import (
+    BOOT_KEY_ITEM,
+    PlaintextFileStore,
+    record_keystore_backend,
+    resolve_keystore,
+)
 
 _ENV_LINE_PREFIX = "AGENT_WALLET_BOOT_KEY="
 
@@ -129,6 +134,8 @@ def migrate_boot_key_to_keystore() -> dict:
     # Do not sweep into a plaintext fallback: that offers no at-rest improvement,
     # and the user explicitly chose to stay on the current file in that case.
     if isinstance(store, PlaintextFileStore):
+        if read_boot_key_from_keystore():
+            record_keystore_backend(store)
         return {"migrated": False, "backend": store.backend_id, "swept_env_files": 0,
                 "removed_boot_key_file": False, "reason": "no-os-keystore"}
 
@@ -145,12 +152,13 @@ def migrate_boot_key_to_keystore() -> dict:
             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 read_boot_key_from_keystore() != legacy_key:
+        if store.get(BOOT_KEY_ITEM) != legacy_key:
             return {"migrated": False, "backend": store.backend_id, "swept_env_files": 0,
                     "removed_boot_key_file": False, "reason": "verify-failed"}
         authoritative = legacy_key
         first_time = True
 
+    record_keystore_backend(store)
     swept, removed = _sweep_plaintext(home, authoritative)
     migrated = first_time or swept > 0 or removed
     return {"migrated": migrated, "backend": store.backend_id, "swept_env_files": swept,

package/agent-wallet/agent_wallet/boot_key_recovery.py

@@ -8,8 +8,8 @@ wallet files. See BOOT_KEY_KEYCHAIN_ARCHITECTURE.md.
 
 from __future__ import annotations
 
-from agent_wallet.config import read_boot_key_from_keystore, resolve_boot_key
-from agent_wallet.keystore import BOOT_KEY_ITEM, resolve_keystore
+from agent_wallet.config import clear_secret_caches, resolve_boot_key
+from agent_wallet.keystore import BOOT_KEY_ITEM, record_keystore_backend, resolve_keystore
 from agent_wallet.wallet_layer.base import WalletBackendError
 
 _EXPORT_WARNING = (
@@ -35,11 +35,13 @@ def import_boot_key(value: str) -> dict:
         raise WalletBackendError("A non-empty boot key is required for import.")
     store = resolve_keystore()
     store.set(BOOT_KEY_ITEM, key)
-    if read_boot_key_from_keystore() != key:
+    if store.get(BOOT_KEY_ITEM) != key:
         raise WalletBackendError(
             f"Boot key import could not be verified from the {store.backend_id} keystore."
         )
-    return {"imported": True, "backend": store.backend_id}
+    state = record_keystore_backend(store)
+    clear_secret_caches()
+    return {"imported": True, "backend": store.backend_id, "backend_state": state}
 
 
 def export_warning() -> str:

package/agent-wallet/agent_wallet/config.py

@@ -1,7 +1,9 @@
 """Configuration for agent wallet backends."""
 
+import hashlib
 import os
 from pathlib import Path
+from typing import Iterator
 
 from pydantic_settings import BaseSettings
 
@@ -387,13 +389,16 @@ def _env_bool(name: str, default: bool) -> bool:
 
 
 def envelope_kdf_migration_enabled() -> bool:
-    """Whether argon2id envelopes are lazily rewritten to hkdf-sha256 after a
-    successful decrypt. Disable with AGENT_WALLET_ENVELOPE_KDF_MIGRATION=0
-    (e.g. when a rollback to a pre-hkdf runtime must stay possible)."""
-    return _env_bool("AGENT_WALLET_ENVELOPE_KDF_MIGRATION", True)
+    """Whether an explicit read may migrate argon2id envelopes with backups.
+
+    Disabled by default so normal reads never change storage or break rollback
+    to a pre-HKDF runtime. Opt in with AGENT_WALLET_ENVELOPE_KDF_MIGRATION=1.
+    """
+    return _env_bool("AGENT_WALLET_ENVELOPE_KDF_MIGRATION", False)
 
 
-_boot_key_keystore_cache: dict[str, str] = {}
+_boot_key_keystore_cache: dict[tuple[str, str, str], str] = {}
+_boot_key_validation_cache: dict[tuple[str, str, int, int], bool] = {}
 
 
 def clear_secret_caches() -> None:
@@ -405,6 +410,7 @@ def clear_secret_caches() -> None:
     directly in tests that rotate keystore contents in-process.
     """
     _boot_key_keystore_cache.clear()
+    _boot_key_validation_cache.clear()
     from agent_wallet.keystore import clear_keystore_cache
 
     clear_keystore_cache()
@@ -425,40 +431,136 @@ def read_boot_key_from_keystore() -> str:
     try:
         from agent_wallet.keystore import BOOT_KEY_ITEM, resolve_keystore
 
-        service_key = os.getenv("AGENT_WALLET_KEYSTORE_SERVICE", "").strip()
-        cached = _boot_key_keystore_cache.get(service_key)
+        cache_key = (
+            os.getenv("AGENT_WALLET_KEYSTORE_BACKEND", "auto").strip().lower(),
+            os.getenv("AGENT_WALLET_KEYSTORE_SERVICE", "").strip(),
+            str(resolve_openclaw_home().resolve()),
+        )
+        cached = _boot_key_keystore_cache.get(cache_key)
         if cached:
             return cached
         value = resolve_keystore().get(BOOT_KEY_ITEM)
         text = value.strip() if isinstance(value, str) else ""
         if text:
-            _boot_key_keystore_cache[service_key] = text
+            _boot_key_keystore_cache[cache_key] = text
         return text
     except Exception:
         return ""
 
 
+def _read_boot_key_file(path_value: str) -> str:
+    if not path_value.strip():
+        return ""
+    try:
+        return Path(path_value).expanduser().read_text(encoding="utf-8").strip()
+    except OSError:
+        return ""
+
+
+def _boot_key_candidates() -> Iterator[tuple[str, str]]:
+    seen: set[str] = set()
+
+    def candidate(source: str, value: str) -> tuple[str, str] | None:
+        if not value or value in seen:
+            return None
+        seen.add(value)
+        return source, value
+
+    for item in (
+        candidate("environment", os.getenv("AGENT_WALLET_BOOT_KEY", "").strip()),
+        candidate("runtime_env", settings.agent_wallet_boot_key.strip()),
+    ):
+        if item:
+            yield item
+
+    keystore_item = candidate("keystore", read_boot_key_from_keystore())
+    if keystore_item:
+        yield keystore_item
+
+    configured_file = os.getenv(
+        "AGENT_WALLET_BOOT_KEY_FILE", settings.agent_wallet_boot_key_file
+    ).strip()
+    configured_item = candidate("configured_file", _read_boot_key_file(configured_file))
+    if configured_item:
+        yield configured_item
+
+    default_file = resolve_openclaw_home() / "agent-wallet-runtime" / "boot-key"
+    if not configured_file or Path(configured_file).expanduser() != default_file:
+        default_item = candidate("default_file", _read_boot_key_file(str(default_file)))
+        if default_item:
+            yield default_item
+
+
+def _boot_key_unlocks_sealed_file(boot_key: str) -> bool | None:
+    sealed_path = resolve_openclaw_home() / "sealed_keys.json"
+    try:
+        stat = sealed_path.stat()
+    except FileNotFoundError:
+        return None
+    except OSError:
+        return False
+
+    cache_key = (boot_key, str(sealed_path), stat.st_mtime_ns, stat.st_size)
+    cached = _boot_key_validation_cache.get(cache_key)
+    if cached is not None:
+        return cached
+    try:
+        from agent_wallet.sealed_keys import unseal_keys
+
+        unseal_keys(boot_key)
+        valid = True
+    except Exception:
+        valid = False
+    if len(_boot_key_validation_cache) >= 8:
+        _boot_key_validation_cache.clear()
+    _boot_key_validation_cache[cache_key] = valid
+    return valid
+
+
+def _resolve_boot_key_candidate() -> tuple[str, str, bool, list[str], bool]:
+    rejected: list[str] = []
+    for source, value in _boot_key_candidates():
+        verified = _boot_key_unlocks_sealed_file(value)
+        if verified is not False:
+            return value, source, verified is True, rejected, bool(rejected)
+        rejected.append(source)
+    return "", "none", False, rejected, len(rejected) > 1
+
+
 def resolve_boot_key() -> str:
-    """Resolve the boot key used to unlock sealed secrets from disk.
+    """Resolve a boot key, verifying candidates against sealed secrets when present.
 
-    Precedence (superset of the legacy lookup, so existing installs keep working):
+    Precedence remains compatible with legacy installs:
       1. AGENT_WALLET_BOOT_KEY env / settings override
       2. OS keystore (the hardened path)
       3. AGENT_WALLET_BOOT_KEY_FILE / boot-key file (legacy)
+
+    A stale higher-priority candidate cannot mask a lower-priority key that
+    actually unlocks ``sealed_keys.json``.
     """
-    direct = os.getenv("AGENT_WALLET_BOOT_KEY", settings.agent_wallet_boot_key).strip()
-    if direct:
-        return direct
-    from_keystore = read_boot_key_from_keystore()
-    if from_keystore:
-        return from_keystore
-    key_file = os.getenv("AGENT_WALLET_BOOT_KEY_FILE", settings.agent_wallet_boot_key_file).strip()
-    if not key_file:
-        return ""
-    try:
-        return Path(key_file).expanduser().read_text(encoding="utf-8").strip()
-    except OSError:
-        return ""
+    return _resolve_boot_key_candidate()[0]
+
+
+def resolve_boot_key_for_installer() -> str:
+    """Stable installer bridge; older runtimes lack this symbol and use JS fallback."""
+    return resolve_boot_key()
+
+
+def boot_key_resolution_status() -> dict[str, object]:
+    """Return non-secret diagnostics for doctor/install reporting."""
+    from agent_wallet.keystore import keystore_backend_status
+
+    value, source, verified, rejected, conflict = _resolve_boot_key_candidate()
+    fingerprint = hashlib.sha256(value.encode("utf-8")).hexdigest()[:12] if value else None
+    return {
+        "available": bool(value),
+        "source": source,
+        "sealed_keys_verified": verified,
+        "conflict_detected": conflict,
+        "rejected_sources": rejected,
+        "fingerprint": fingerprint,
+        "keystore": keystore_backend_status(),
+    }
 
 
 def _reject_legacy_runtime_secret_env(var_name: str) -> None:

package/agent-wallet/agent_wallet/encrypted_storage.py

@@ -20,6 +20,7 @@ USER_SCOPED_KEY_SALT = b"openclaw-agent-wallet-user-key-v1"
 
 KDF_ARGON2ID = "argon2id"
 KDF_HKDF_SHA256 = "hkdf-sha256"
+ARGON2ID_BACKUP_SUFFIX = ".argon2id.bak"
 _HKDF_INFO = b"openclaw-agent-wallet-envelope-hkdf-v1"
 
 
@@ -201,6 +202,89 @@ def decrypt_secret_material(
     return plaintext.decode("utf-8")
 
 
+def migrate_envelope_to_hkdf(
+    path: Path,
+    secret_material: str,
+    *,
+    master_key: str,
+    metadata: dict[str, Any] | None = None,
+) -> Path | None:
+    """Rewrite one verified argon2id envelope with a rollback-safe backup."""
+    raw_text = path.read_text(encoding="utf-8")
+    if envelope_kdf(raw_text) != KDF_ARGON2ID:
+        return None
+    if decrypt_secret_material(raw_text, master_key=master_key) != secret_material:
+        raise WalletBackendError("Argon2id envelope verification failed before migration.")
+
+    backup = path.with_name(path.name + ARGON2ID_BACKUP_SUFFIX)
+    if backup.exists():
+        backup_text = backup.read_text(encoding="utf-8")
+        if envelope_kdf(backup_text) != KDF_ARGON2ID:
+            raise WalletBackendError(f"Envelope migration backup is invalid: {backup}")
+        if decrypt_secret_material(backup_text, master_key=master_key) != secret_material:
+            raise WalletBackendError(f"Envelope migration backup does not match: {backup}")
+    else:
+        atomic_write_text(backup, raw_text, mode=0o600)
+        if backup.read_text(encoding="utf-8") != raw_text:
+            raise WalletBackendError(f"Envelope migration backup could not be verified: {backup}")
+
+    if metadata is None:
+        try:
+            parsed = json.loads(raw_text)
+            original_metadata = parsed.get("metadata") if isinstance(parsed, dict) else None
+        except ValueError:
+            original_metadata = None
+        metadata = original_metadata if isinstance(original_metadata, dict) else None
+
+    migrated = encrypt_secret_material(
+        secret_material,
+        master_key=master_key,
+        metadata=metadata,
+        kdf=KDF_HKDF_SHA256,
+    )
+    if decrypt_secret_material(migrated, master_key=master_key) != secret_material:
+        raise WalletBackendError("HKDF envelope verification failed before migration.")
+    if path.read_text(encoding="utf-8") != raw_text:
+        raise WalletBackendError(f"Envelope changed during migration: {path}")
+
+    try:
+        atomic_write_text(path, migrated, mode=0o600)
+        written = path.read_text(encoding="utf-8")
+        if decrypt_secret_material(written, master_key=master_key) != secret_material:
+            raise WalletBackendError("HKDF envelope verification failed after migration.")
+    except Exception:
+        atomic_write_text(path, raw_text, mode=0o600)
+        raise
+    return backup
+
+
+def restore_argon2id_envelope(path: Path, *, master_key: str) -> bool:
+    """Restore a migration backup only when it contains the same plaintext."""
+    backup = path.with_name(path.name + ARGON2ID_BACKUP_SUFFIX)
+    if not backup.exists():
+        return False
+    current_text = path.read_text(encoding="utf-8")
+    backup_text = backup.read_text(encoding="utf-8")
+    current_secret = decrypt_secret_material(current_text, master_key=master_key)
+    backup_secret = decrypt_secret_material(backup_text, master_key=master_key)
+    if current_secret != backup_secret:
+        raise WalletBackendError(
+            f"Refusing to restore stale envelope backup with different contents: {backup}"
+        )
+    if envelope_kdf(backup_text) != KDF_ARGON2ID:
+        raise WalletBackendError(f"Envelope migration backup is invalid: {backup}")
+    atomic_write_text(path, backup_text, mode=0o600)
+    return True
+
+
+def remove_envelope_migration_backup(path: Path) -> None:
+    """Discard a rollback backup after the envelope's logical content changes."""
+    try:
+        path.with_name(path.name + ARGON2ID_BACKUP_SUFFIX).unlink()
+    except FileNotFoundError:
+        pass
+
+
 def load_wallet_secret_material(
     path: Path,
     *,
@@ -227,3 +311,4 @@ def write_encrypted_wallet_file(
         metadata=metadata,
     )
     atomic_write_text(path, payload, mode=0o600)
+    remove_envelope_migration_backup(path)