@agentlayer.tech/wallet 0.1.74 → 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.74",
+  "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.74",
+  "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,32 @@
 
 ## 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.

package/VERSION

@@ -1 +1 @@
-0.1.74
+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.74"
+__version__ = "0.1.75"
 
 __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.74",
+  "version": "0.1.75",
   "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.74"
+version = "0.1.75"
 description = "Plugin-friendly wallet backend for OpenClaw agents"
 requires-python = ">=3.10"
 dependencies = [

package/bin/openclaw-agent-wallet.mjs

@@ -392,6 +392,60 @@ function updateJournalPath(env = process.env) {
   return path.join(resolveRuntimeBase(env), "update-journal.json");
 }
 
+function integrationRegistryPath(env = process.env) {
+  return path.join(resolveRuntimeBase(env), "integrations.json");
+}
+
+function readIntegrationRegistry(env = process.env) {
+  const payload = readJsonFile(integrationRegistryPath(env));
+  if (!payload || payload.schema_version !== 1 || typeof payload.integrations !== "object") {
+    return { schema_version: 1, integrations: {} };
+  }
+  return payload;
+}
+
+function recordManagedIntegration(name, details = {}, env = process.env) {
+  const registry = readIntegrationRegistry(env);
+  registry.integrations[name] = {
+    ...details,
+    managed: true,
+    installed_version: packageVersion,
+    updated_at: new Date().toISOString(),
+  };
+  registry.updated_at = new Date().toISOString();
+  writeJsonFileAtomic(integrationRegistryPath(env), registry);
+  return registry.integrations[name];
+}
+
+function managedIntegration(name, env = process.env) {
+  const entry = readIntegrationRegistry(env).integrations[name];
+  return entry && entry.managed === true ? entry : null;
+}
+
+function integrationSyncStatus(env = process.env) {
+  const active = activeVersion(env);
+  const registry = readIntegrationRegistry(env);
+  const integrations = Object.entries(registry.integrations)
+    .filter(([, entry]) => entry?.managed === true)
+    .sort(([left], [right]) => left.localeCompare(right))
+    .map(([name, entry]) => {
+      const versionInSync = active === null || entry.installed_version === active;
+      const registrationOk = entry.registration_ok !== false;
+      return {
+        name,
+        installed_version: entry.installed_version || null,
+        active_version: active,
+        in_sync: versionInSync && registrationOk,
+        registration_ok: registrationOk,
+        restart_required: Boolean(entry.restart_required),
+      };
+    });
+  return {
+    in_sync: integrations.every((entry) => entry.in_sync),
+    integrations,
+  };
+}
+
 function writeUpdateJournal(state, details = {}, env = process.env) {
   writeJsonFile(updateJournalPath(env), {
     schema_version: 1,
@@ -944,6 +998,22 @@ function writeJsonFile(pathname, value) {
   fs.writeFileSync(pathname, `${JSON.stringify(value, null, 2)}\n`);
 }
 
+function writeJsonFileAtomic(pathname, value, mode = 0o600) {
+  fs.mkdirSync(path.dirname(pathname), { recursive: true });
+  const tempPath = `${pathname}.tmp-${process.pid}-${Date.now()}`;
+  try {
+    fs.writeFileSync(tempPath, `${JSON.stringify(value, null, 2)}\n`, { mode });
+    fs.renameSync(tempPath, pathname);
+    fs.chmodSync(pathname, mode);
+  } finally {
+    try {
+      fs.rmSync(tempPath, { force: true });
+    } catch {
+      // ignored
+    }
+  }
+}
+
 function currentBootKey(env = process.env) {
   const currentRoot = resolvedCurrentRuntimeRoot(env);
   if (!currentRoot) return "";
@@ -1301,6 +1371,16 @@ function runDoctor(args = []) {
     fix: rsync.in_sync === false ? "npm run release:local" : "",
   });
 
+  const integrationSync = integrationSyncStatus(env);
+  checks.push({
+    name: "framework_integrations_in_sync",
+    ok: true,
+    in_sync: integrationSync.in_sync,
+    integrations: integrationSync.integrations,
+    error: "",
+    fix: integrationSync.in_sync ? "" : "wallet update --yes",
+  });
+
   const ok = checks.every((c) => c.ok);
   console.log(
     JSON.stringify(
@@ -1336,6 +1416,7 @@ function runStatus(args = []) {
     failed_releases: listFailedReleases(),
     update_available: computeUpdateAvailability(),
     runtime_in_sync: computeRuntimeInSync(),
+    framework_integrations: integrationSyncStatus(),
   };
   if (hasFlag(args, "--verbose")) {
     payload.verbose = true;
@@ -1562,7 +1643,20 @@ function runInstall(args, { commandName = "install" } = {}) {
   switchSymlink(currentPath, releaseRoot);
   writeUpdateJournal("committed", { release_root: releaseRoot, previous_runtime: previousTarget }, env);
 
+  recordManagedIntegration(
+    "openclaw",
+    {
+      config_path: path.resolve(
+        expandHome(parseFlagValue(args, "--config-path") || path.join(resolveOpenclawHome(env), "openclaw.json")),
+      ),
+      extension_path: path.join(currentPath, ".openclaw", "extensions", "agent-wallet"),
+      package_root: path.join(currentPath, "agent-wallet"),
+    },
+    env,
+  );
+
   const integrationRefresh = repairInstalledEditorIntegrations(env);
+  const globalCliRefresh = refreshGlobalCliIfNeeded(env);
 
   const pythonInfo = activePythonRuntimeInfo(env);
   const nodeInfo = activeNodeRuntimeInfo(env)
@@ -1586,6 +1680,7 @@ function runInstall(args, { commandName = "install" } = {}) {
         staged: Boolean(stagingRoot),
         release_state: "verified",
         integration_refresh: integrationRefresh,
+        global_cli_refresh: globalCliRefresh,
       },
       null,
       2,
@@ -2001,6 +2096,14 @@ function runHermesInstall(args) {
     }
   }
 
+  recordManagedIntegration("hermes", {
+    hermes_home: hermesHome,
+    plugin_target: pluginTarget,
+    env_path: hermesEnvPath,
+    restart_required: true,
+    ...(enable.skipped ? {} : { registration_ok: enable.ok }),
+  });
+
   console.log(
     JSON.stringify(
       {
@@ -2086,6 +2189,15 @@ function runCodexInstall(args) {
     }
   }
 
+  recordManagedIntegration("codex", {
+    codex_home: codexHome,
+    plugin_target: pluginTarget,
+    marketplace_path: marketplace.marketplace_path,
+    marketplace_name: marketplace.marketplace_name,
+    restart_required: true,
+    ...(add.skipped ? {} : { registration_ok: add.ok }),
+  });
+
   console.log(
     JSON.stringify(
       {
@@ -2281,6 +2393,16 @@ function runClaudeCodeInstall(args) {
     }
   }
 
+  recordManagedIntegration("claude-code", {
+    marketplace_dir: marketplaceDir,
+    plugin_target: pluginLink,
+    cache_root: path.resolve(
+      expandHome(process.env.AGENT_WALLET_CLAUDE_CODE_CACHE_ROOT || "~/.claude/plugins/cache"),
+    ),
+    restart_required: true,
+    ...(enable.skipped ? {} : { registration_ok: enable.ok }),
+  });
+
   const ok = enable.skipped || enable.ok;
   const pinnedCache = pinClaudeCacheCopies();
   const pluginDirFlagFull = `claude --plugin-dir ${pluginSource}`;
@@ -2328,7 +2450,7 @@ function pathEntryExists(pathname) {
   }
 }
 
-function repairRuntimeSymlink(name, linkPath, desiredTarget, env = process.env) {
+function repairRuntimeSymlink(name, linkPath, desiredTarget, env = process.env, { allowExternal = false } = {}) {
   let rawTarget;
   try {
     const stat = fs.lstatSync(linkPath);
@@ -2348,7 +2470,7 @@ function repairRuntimeSymlink(name, linkPath, desiredTarget, env = process.env)
   if (absoluteTarget === path.resolve(desiredTarget) || absoluteTarget.startsWith(`${logicalCurrent}${path.sep}`)) {
     return { name, attempted: true, ok: true, repaired: false, reason: "already current" };
   }
-  if (!runtimeReleasePath(absoluteTarget, env)) {
+  if (!allowExternal && !runtimeReleasePath(absoluteTarget, env)) {
     return { name, attempted: false, ok: true, repaired: false, reason: "external target preserved" };
   }
   if (!fs.existsSync(desiredTarget)) {
@@ -2358,8 +2480,7 @@ function repairRuntimeSymlink(name, linkPath, desiredTarget, env = process.env)
   return { name, attempted: true, ok: true, repaired: true, target: desiredTarget };
 }
 
-function repairHermesEnv(env = process.env) {
-  const envPath = path.join(resolveHermesHome(env), ".env");
+function repairHermesEnv(envPath, env = process.env) {
   const existing = readEnvFile(envPath);
   const repaired = [];
   const currentPackage = path.join(currentRuntimePath(env), "agent-wallet");
@@ -2379,44 +2500,378 @@ function repairHermesEnv(env = process.env) {
   return repaired;
 }
 
+function legacyHermesIntegration(env = process.env) {
+  const hermesHome = resolveHermesHome(env);
+  const pluginTarget = path.join(hermesHome, "plugins", "agent_wallet");
+  let target;
+  try {
+    if (!fs.lstatSync(pluginTarget).isSymbolicLink()) return null;
+    target = path.resolve(path.dirname(pluginTarget), fs.readlinkSync(pluginTarget));
+  } catch {
+    return null;
+  }
+  const manifest = readTextIfExists(path.join(target, "plugin.yaml"));
+  if (!/^name:\s*agent[-_]wallet\s*$/m.test(manifest)) return null;
+  return recordManagedIntegration(
+    "hermes",
+    {
+      hermes_home: hermesHome,
+      plugin_target: pluginTarget,
+      env_path: path.join(hermesHome, ".env"),
+      adopted_legacy_install: true,
+    },
+    env,
+  );
+}
+
+function repairOpenclawIntegration(env = process.env) {
+  const entry = managedIntegration("openclaw", env);
+  if (!entry) {
+    return { name: "openclaw", attempted: false, ok: true, repaired: false, reason: "not managed" };
+  }
+  const configPath = path.resolve(
+    expandHome(entry.config_path || path.join(resolveOpenclawHome(env), "openclaw.json")),
+  );
+  let config;
+  try {
+    config = readJsonFile(configPath);
+  } catch (error) {
+    return { name: "openclaw", attempted: true, ok: false, repaired: false, error: error.message };
+  }
+  if (!config || typeof config !== "object") {
+    return { name: "openclaw", attempted: true, ok: false, repaired: false, error: `missing ${configPath}` };
+  }
+
+  const currentRoot = currentRuntimePath(env);
+  const extensionPath = path.join(currentRoot, ".openclaw", "extensions", "agent-wallet");
+  const packageRootPath = path.join(currentRoot, "agent-wallet");
+  const pythonBin = resolveVenvPython(currentRoot);
+  const plugins = config.plugins && typeof config.plugins === "object" ? config.plugins : (config.plugins = {});
+  const load = plugins.load && typeof plugins.load === "object" ? plugins.load : (plugins.load = {});
+  const paths = Array.isArray(load.paths) ? load.paths : [];
+  load.paths = [
+    ...paths.filter((item) => {
+      const value = String(item || "");
+      return !value.replaceAll("\\", "/").endsWith("/.openclaw/extensions/agent-wallet");
+    }),
+    extensionPath,
+  ];
+  const entries = plugins.entries && typeof plugins.entries === "object" ? plugins.entries : (plugins.entries = {});
+  const walletEntry = entries["agent-wallet"];
+  if (!walletEntry || typeof walletEntry !== "object") {
+    return {
+      name: "openclaw",
+      attempted: false,
+      ok: true,
+      repaired: false,
+      reason: "plugin entry not configured",
+    };
+  }
+  walletEntry.enabled = true;
+  walletEntry.config = walletEntry.config && typeof walletEntry.config === "object" ? walletEntry.config : {};
+  walletEntry.config.packageRoot = packageRootPath;
+  if (pythonBin) walletEntry.config.pythonBin = pythonBin;
+  writeJsonFileAtomic(configPath, config);
+  recordManagedIntegration(
+    "openclaw",
+    {
+      config_path: configPath,
+      extension_path: extensionPath,
+      package_root: packageRootPath,
+      restart_required: true,
+    },
+    env,
+  );
+  return {
+    name: "openclaw",
+    attempted: true,
+    ok: true,
+    repaired: true,
+    config_path: configPath,
+    restart_required: true,
+  };
+}
+
+function symlinkManifestMatches(linkPath, manifestRelativePath, expectedName) {
+  let target;
+  try {
+    if (!fs.lstatSync(linkPath).isSymbolicLink()) return false;
+    target = path.resolve(path.dirname(linkPath), fs.readlinkSync(linkPath));
+  } catch {
+    return false;
+  }
+  try {
+    const manifest = readJsonFile(path.join(target, manifestRelativePath));
+    return manifest && manifest.name === expectedName;
+  } catch {
+    return false;
+  }
+}
+
+function legacyCodexIntegration(env = process.env) {
+  const marketplacePath = resolveCodexMarketplacePath(env);
+  let marketplace;
+  try {
+    marketplace = readJsonFile(marketplacePath);
+  } catch {
+    return null;
+  }
+  const pluginTarget = path.join(resolveCodexPluginInstallRoot(env), "agent-wallet");
+  const registered = Array.isArray(marketplace?.plugins) && marketplace.plugins.some(
+    (item) => item?.name === "agent-wallet" && item?.source?.source === "local",
+  );
+  if (!registered || !symlinkManifestMatches(pluginTarget, ".codex-plugin/plugin.json", "agent-wallet")) {
+    return null;
+  }
+  return recordManagedIntegration(
+    "codex",
+    {
+      codex_home: resolveCodexHome(env),
+      plugin_target: pluginTarget,
+      marketplace_path: marketplacePath,
+      marketplace_name: String(marketplace.name || "local"),
+      adopted_legacy_install: true,
+    },
+    env,
+  );
+}
+
+function legacyClaudeCodeIntegration(env = process.env) {
+  const marketplaceDir = resolveClaudeCodeMarketplaceDir(env);
+  let manifest;
+  try {
+    manifest = readJsonFile(path.join(marketplaceDir, ".claude-plugin", "marketplace.json"));
+  } catch {
+    return null;
+  }
+  const pluginTarget = path.join(marketplaceDir, "plugins", "agent-wallet");
+  const registered = manifest?.name === CLAUDE_CODE_MARKETPLACE_NAME &&
+    Array.isArray(manifest.plugins) && manifest.plugins.some((item) => item?.name === "agent-wallet");
+  if (!registered || !symlinkManifestMatches(pluginTarget, ".claude-plugin/plugin.json", "agent-wallet")) {
+    return null;
+  }
+  return recordManagedIntegration(
+    "claude-code",
+    {
+      marketplace_dir: marketplaceDir,
+      plugin_target: pluginTarget,
+      cache_root: path.resolve(
+        expandHome(env.AGENT_WALLET_CLAUDE_CODE_CACHE_ROOT || "~/.claude/plugins/cache"),
+      ),
+      adopted_legacy_install: true,
+    },
+    env,
+  );
+}
+
+function runHostRefresh(command, args, env = process.env) {
+  const binary = commandPath(command);
+  if (!binary) {
+    return {
+      attempted: false,
+      ok: false,
+      error: `${command} CLI not found`,
+      fix: args.join(" "),
+    };
+  }
+  const result = spawnSync(binary, args, { cwd: packageRoot, encoding: "utf8", env });
+  return {
+    attempted: true,
+    ok: result.status === 0,
+    error: result.status === 0 ? "" : (result.stderr || result.stdout || "").trim(),
+    fix: result.status === 0 ? "" : `${command} ${args.join(" ")}`,
+  };
+}
+
+function globalNpmPackageInfo(env = process.env) {
+  const npmBin = commandPath("npm");
+  if (!npmBin) return null;
+  const rootResult = spawnSync(npmBin, ["root", "--global"], { encoding: "utf8", env });
+  if (rootResult.status !== 0) return null;
+  const packageRoot = path.join(rootResult.stdout.trim(), ...packageJson.name.split("/"));
+  try {
+    const manifest = readJsonFile(path.join(packageRoot, "package.json"));
+    if (manifest?.name !== packageJson.name) return null;
+    return { npm_bin: npmBin, package_root: packageRoot, version: manifest.version || null };
+  } catch {
+    return null;
+  }
+}
+
+function refreshGlobalCliIfNeeded(env = process.env) {
+  const installed = globalNpmPackageInfo(env);
+  if (!installed) {
+    return { attempted: false, ok: true, reason: "global package is not installed" };
+  }
+  if (installed.version === packageVersion) {
+    return { attempted: false, ok: true, reason: "already current", version: packageVersion };
+  }
+  const fromNpmCache = path.resolve(packageRoot).split(path.sep).includes("_npx");
+  const forced = env.AGENT_WALLET_FORCE_GLOBAL_CLI_REFRESH === "1";
+  if (!fromNpmCache && !forced) {
+    return {
+      attempted: false,
+      ok: false,
+      reason: "installer is not running from npm exec",
+      installed_version: installed.version,
+      target_version: packageVersion,
+      fix: `npm install --global ${packageJson.name}@${packageVersion}`,
+    };
+  }
+  const packageSpec = `${packageJson.name}@${packageVersion}`;
+  const result = spawnSync(
+    installed.npm_bin,
+    ["install", "--global", "--no-audit", "--no-fund", packageSpec],
+    { encoding: "utf8", env },
+  );
+  return {
+    attempted: true,
+    ok: result.status === 0,
+    previous_version: installed.version,
+    target_version: packageVersion,
+    error: result.status === 0 ? "" : (result.stderr || result.stdout || "").trim(),
+    fix: result.status === 0 ? "" : `npm install --global ${packageSpec}`,
+  };
+}
+
+function refreshCodexIntegration(entry, env = process.env) {
+  const pluginTarget = path.resolve(
+    expandHome(entry.plugin_target || path.join(resolveCodexPluginInstallRoot(env), "agent-wallet")),
+  );
+  const marketplacePath = path.resolve(
+    expandHome(entry.marketplace_path || resolveCodexMarketplacePath(env)),
+  );
+  const link = repairRuntimeSymlink(
+    "codex",
+    pluginTarget,
+    path.join(currentRuntimePath(env), "codex", "plugins", "agent-wallet"),
+    env,
+    { allowExternal: true },
+  );
+  if (!link.ok) return link;
+  const marketplace = ensureCodexMarketplaceEntry({ marketplacePath, pluginName: "agent-wallet" });
+  const registration = runHostRefresh(
+    "codex",
+    ["plugin", "add", `agent-wallet@${marketplace.marketplace_name}`],
+    { ...env, CODEX_HOME: entry.codex_home || resolveCodexHome(env) },
+  );
+  recordManagedIntegration(
+    "codex",
+    {
+      ...entry,
+      plugin_target: pluginTarget,
+      marketplace_path: marketplacePath,
+      marketplace_name: marketplace.marketplace_name,
+      registration_ok: registration.ok,
+      restart_required: true,
+    },
+    env,
+  );
+  return {
+    ...link,
+    ok: link.ok && registration.ok,
+    registration,
+    restart_required: true,
+  };
+}
+
+function refreshClaudeCodeIntegration(entry, env = process.env) {
+  const marketplaceDir = path.resolve(
+    expandHome(entry.marketplace_dir || resolveClaudeCodeMarketplaceDir(env)),
+  );
+  const cacheRoot = path.resolve(
+    expandHome(entry.cache_root || env.AGENT_WALLET_CLAUDE_CODE_CACHE_ROOT || "~/.claude/plugins/cache"),
+  );
+  const pluginTarget = path.resolve(
+    expandHome(entry.plugin_target || path.join(marketplaceDir, "plugins", "agent-wallet")),
+  );
+  const link = repairRuntimeSymlink(
+    "claude-code",
+    pluginTarget,
+    path.join(currentRuntimePath(env), "claude-code", "plugins", "agent-wallet"),
+    env,
+    { allowExternal: true },
+  );
+  if (!link.ok) return link;
+  ensureClaudeCodeMarketplace(
+    marketplaceDir,
+    path.join(currentRuntimePath(env), "claude-code", "plugins", "agent-wallet"),
+    true,
+  );
+  const marketplaceAdd = runHostRefresh(
+    "claude",
+    ["plugin", "marketplace", "add", marketplaceDir, "--scope", "user"],
+    env,
+  );
+  const registration = marketplaceAdd.ok
+    ? runHostRefresh(
+        "claude",
+        ["plugin", "install", `agent-wallet@${CLAUDE_CODE_MARKETPLACE_NAME}`, "--scope", "user"],
+        env,
+      )
+    : { attempted: false, ok: false, error: "marketplace refresh failed", fix: marketplaceAdd.fix };
+  const cachePins = pinClaudeCacheCopies({
+    ...env,
+    AGENT_WALLET_CLAUDE_CODE_CACHE_ROOT: cacheRoot,
+  });
+  recordManagedIntegration(
+    "claude-code",
+    {
+      ...entry,
+      marketplace_dir: marketplaceDir,
+      plugin_target: pluginTarget,
+      cache_root: cacheRoot,
+      registration_ok: registration.ok,
+      restart_required: true,
+    },
+    env,
+  );
+  return {
+    ...link,
+    ok: link.ok && marketplaceAdd.ok && registration.ok,
+    marketplace_add: marketplaceAdd,
+    registration,
+    cache_pins: cachePins,
+    restart_required: true,
+  };
+}
+
 function repairInstalledEditorIntegrations(env = process.env) {
-  const results = [];
+  const results = [repairOpenclawIntegration(env)];
   const currentRoot = currentRuntimePath(env);
-  const hermesTarget = path.join(resolveHermesHome(env), "plugins", "agent_wallet");
-  if (pathEntryExists(hermesTarget) || fs.existsSync(path.join(resolveHermesHome(env), ".env"))) {
+  const hermesEntry = managedIntegration("hermes", env) || legacyHermesIntegration(env);
+  if (hermesEntry) {
+    const hermesTarget = path.resolve(expandHome(hermesEntry.plugin_target));
+    const hermesEnvPath = path.resolve(expandHome(hermesEntry.env_path));
     const result = repairRuntimeSymlink(
       "hermes",
       hermesTarget,
       path.join(currentRoot, "hermes", "plugins", "agent_wallet"),
       env,
+      { allowExternal: true },
     );
-    result.env_repaired = repairHermesEnv(env);
+    result.env_repaired = repairHermesEnv(hermesEnvPath, env);
+    result.restart_required = true;
+    if (result.ok) {
+      recordManagedIntegration(
+        "hermes",
+        {
+          ...hermesEntry,
+          plugin_target: hermesTarget,
+          env_path: hermesEnvPath,
+          restart_required: true,
+        },
+        env,
+      );
+    }
     results.push(result);
   }
 
-  const codexTarget = path.join(resolveCodexPluginInstallRoot(env), "agent-wallet");
-  if (pathEntryExists(codexTarget)) {
-    results.push(
-      repairRuntimeSymlink(
-        "codex",
-        codexTarget,
-        path.join(currentRoot, "codex", "plugins", "agent-wallet"),
-        env,
-      ),
-    );
-  }
+  const codexEntry = managedIntegration("codex", env) || legacyCodexIntegration(env);
+  if (codexEntry) results.push(refreshCodexIntegration(codexEntry, env));
 
-  const claudeTarget = path.join(resolveClaudeCodeMarketplaceDir(env), "plugins", "agent-wallet");
-  if (pathEntryExists(claudeTarget)) {
-    const result = repairRuntimeSymlink(
-      "claude-code",
-      claudeTarget,
-      path.join(currentRoot, "claude-code", "plugins", "agent-wallet"),
-      env,
-    );
-    result.cache_pins = pinClaudeCacheCopies(env);
-    results.push(result);
-  }
+  const claudeEntry = managedIntegration("claude-code", env) || legacyClaudeCodeIntegration(env);
+  if (claudeEntry) results.push(refreshClaudeCodeIntegration(claudeEntry, env));
   return results;
 }
 

package/claude-code/plugins/agent-wallet/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-wallet",
   "displayName": "Agent Wallet",
-  "version": "0.1.74",
+  "version": "0.1.75",
   "description": "Claude Code bridge for the existing AgentLayer wallet runtime. Connects to Solana, Bitcoin, and EVM wallets without creating a new one.",
   "author": {
     "name": "AgentLayer"

package/codex/plugins/agent-wallet/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-wallet",
-  "version": "0.1.74",
+  "version": "0.1.75",
   "description": "Codex plugin bridge for the AgentLayer wallet runtime.",
   "author": {
     "name": "AgentLayer"

package/hermes/plugins/agent_wallet/plugin.yaml

@@ -1,5 +1,5 @@
 name: agent-wallet
-version: 0.1.74
+version: 0.1.75
 description: Thin Hermes Agent bridge to the existing AgentLayer/OpenClaw wallet backend
 provides_tools:
   - agent_wallet_tools

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentlayer.tech/wallet",
-  "version": "0.1.74",
+  "version": "0.1.75",
   "description": "NPM installer for the OpenClaw Agent Wallet local runtime.",
   "type": "module",
   "repository": {

package/wdk-btc-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-btc-wallet",
-  "version": "0.1.74",
+  "version": "0.1.75",
   "private": true,
   "type": "module",
   "description": "Separate BTC-only wallet service built on Tether WDK.",

package/wdk-evm-wallet/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wdk-evm-wallet",
-  "version": "0.1.74",
+  "version": "0.1.75",
   "private": true,
   "type": "module",
   "description": "Separate EVM wallet service built on Tether WDK.",