@okxweb3/a2a-node 0.1.4 → 0.1.6-beta-c3024b2b0b-260706164140

package/dist/index.js

@@ -1697,6 +1697,520 @@ var init_session_store = __esm({
   }
 });
 
+// src/daemon-lock.ts
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err2) {
+    return err2.code === "EPERM";
+  }
+}
+function ownerPath(lockPath) {
+  return (0, import_node_path4.join)(lockPath, OWNER_FILE);
+}
+async function readDaemonLock(lockPath) {
+  let metadata = null;
+  try {
+    const raw = await (0, import_promises.readFile)(ownerPath(lockPath), "utf8");
+    metadata = JSON.parse(raw);
+  } catch (err2) {
+    const code2 = err2.code;
+    if (code2 === "ENOENT") {
+      try {
+        const info = await (0, import_promises.stat)(lockPath);
+        const stale = Date.now() - info.mtimeMs > EMPTY_LOCK_STALE_MS;
+        return { metadata: null, running: !stale, stale, path: lockPath };
+      } catch (statErr) {
+        const statCode = statErr.code;
+        if (statCode === "ENOENT") {
+          return { metadata: null, running: false, stale: false, path: lockPath };
+        }
+        throw statErr;
+      }
+    }
+    if (err2 instanceof SyntaxError) {
+      return { metadata: null, running: false, stale: true, path: lockPath };
+    }
+    throw err2;
+  }
+  const running = Number.isInteger(metadata.pid) && metadata.pid > 0 && isProcessAlive(metadata.pid);
+  return { metadata, running, stale: !running, path: lockPath };
+}
+async function markDaemonReady(lockPath) {
+  const current = await readDaemonLock(lockPath);
+  const metadata = current.metadata;
+  if (!metadata || metadata.pid !== process.pid) {
+    return;
+  }
+  await (0, import_promises.writeFile)(ownerPath(lockPath), `${JSON.stringify({
+    ...metadata,
+    ready: true,
+    readyAt: (/* @__PURE__ */ new Date()).toISOString()
+  }, null, 2)}
+`, "utf8");
+}
+async function removeLock(lockPath) {
+  await (0, import_promises.rm)(lockPath, { recursive: true, force: true });
+}
+async function acquireDaemonLock(paths, entry) {
+  const metadata = {
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    cwd: process.cwd(),
+    entry,
+    homeDir: paths.homeDir,
+    capabilities: DAEMON_CAPABILITIES,
+    ready: false
+  };
+  ensureTaskDir(paths.runDir);
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      await (0, import_promises.mkdir)(paths.daemonLockPath, { mode: A2A_TASK_DIR_MODE });
+      await chmodBestEffort(paths.daemonLockPath, A2A_TASK_DIR_MODE);
+      await (0, import_promises.writeFile)(ownerPath(paths.daemonLockPath), `${JSON.stringify(metadata, null, 2)}
+`, "utf8");
+      return {
+        metadata,
+        release: async () => {
+          const current = await readDaemonLock(paths.daemonLockPath);
+          if (current.metadata?.pid === process.pid) {
+            await removeLock(paths.daemonLockPath);
+          }
+        }
+      };
+    } catch (err2) {
+      const code2 = err2.code;
+      if (code2 !== "EEXIST") {
+        throw err2;
+      }
+      const current = await readDaemonLock(paths.daemonLockPath);
+      if (current.running) {
+        return null;
+      }
+      if (!current.stale) {
+        return null;
+      }
+      await removeLock(paths.daemonLockPath);
+    }
+  }
+  return null;
+}
+async function chmodBestEffort(path, mode) {
+  try {
+    await (0, import_promises.chmod)(path, mode);
+  } catch (err2) {
+    const code2 = err2.code;
+    if (code2 !== "EPERM" && code2 !== "EACCES") {
+      throw err2;
+    }
+  }
+}
+var import_promises, import_node_path4, OWNER_FILE, EMPTY_LOCK_STALE_MS, DAEMON_CAPABILITY_AI_DISPATCH, DAEMON_CAPABILITIES;
+var init_daemon_lock = __esm({
+  "src/daemon-lock.ts"() {
+    "use strict";
+    import_promises = require("node:fs/promises");
+    import_node_path4 = require("node:path");
+    init_paths();
+    init_a2a_paths();
+    OWNER_FILE = "owner.json";
+    EMPTY_LOCK_STALE_MS = 1e4;
+    DAEMON_CAPABILITY_AI_DISPATCH = "ai-dispatch";
+    DAEMON_CAPABILITIES = [
+      DAEMON_CAPABILITY_AI_DISPATCH
+    ];
+  }
+});
+
+// src/daemon.ts
+var daemon_exports = {};
+__export(daemon_exports, {
+  ensureDaemonReady: () => ensureDaemonReady,
+  getDaemonStatus: () => getDaemonStatus,
+  startDaemon: () => startDaemon,
+  stopDaemon: () => stopDaemon
+});
+async function readPid(pidPath) {
+  try {
+    const raw = await (0, import_promises2.readFile)(pidPath, "utf8");
+    const pid = Number.parseInt(raw.trim(), 10);
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch (err2) {
+    const code2 = err2.code;
+    if (code2 === "ENOENT") {
+      return null;
+    }
+    throw err2;
+  }
+}
+async function removePid(pidPath) {
+  try {
+    await (0, import_promises2.unlink)(pidPath);
+  } catch (err2) {
+    const code2 = err2.code;
+    if (code2 !== "ENOENT") {
+      throw err2;
+    }
+  }
+}
+async function ensureDaemonDirs(homeDir) {
+  const paths = resolveTaskPaths(homeDir);
+  ensureTaskDir(paths.jobsDir);
+  ensureTaskDir(paths.runDir);
+  ensureTaskDir(paths.logsDir);
+  ensureTaskDir(paths.commandsDir);
+  ensureTaskDir(paths.downloadsDir);
+  ensureTaskDir(paths.xmtpDir);
+  ensureTaskDir(paths.sqliteDir);
+  return paths;
+}
+async function ensureAiWorkspace(paths) {
+  const aiWorkingDir = paths.workspaceDir;
+  await (0, import_promises2.rm)(aiWorkingDir, { recursive: true, force: true });
+  ensureTaskDir(aiWorkingDir);
+  return aiWorkingDir;
+}
+async function waitForImmediateExit(child, timeoutMs) {
+  return await new Promise((resolve6) => {
+    let timer;
+    const onExit = () => {
+      clearTimeout(timer);
+      resolve6(true);
+    };
+    timer = setTimeout(() => {
+      child.off("exit", onExit);
+      resolve6(false);
+    }, timeoutMs);
+    child.once("exit", onExit);
+  });
+}
+async function getDaemonStatus(homeDir) {
+  const paths = resolveTaskPaths(homeDir);
+  const pid = await readPid(paths.pidPath);
+  const lock = await readDaemonLock(paths.daemonLockPath);
+  const lockPid = lock.metadata?.pid ?? null;
+  const lockReadyStateKnown = !!lock.metadata && (typeof lock.metadata.ready === "boolean" || typeof lock.metadata.readyAt === "string");
+  const lockReady = lockReadyStateKnown ? lock.metadata?.ready === true || typeof lock.metadata?.readyAt === "string" : true;
+  if (lock.running) {
+    return {
+      running: true,
+      pid: lockPid ?? pid,
+      stale: false,
+      capabilities: lock.metadata?.capabilities ?? [],
+      ready: lockReady,
+      readyAt: lock.metadata?.readyAt ?? null,
+      readyStateKnown: lockReadyStateKnown,
+      pidPath: paths.pidPath,
+      lockPath: paths.daemonLockPath,
+      lockPid,
+      lockStale: false
+    };
+  }
+  if (!pid) {
+    return {
+      running: false,
+      pid: null,
+      stale: lock.stale,
+      capabilities: [],
+      ready: false,
+      readyAt: null,
+      readyStateKnown: false,
+      pidPath: paths.pidPath,
+      lockPath: paths.daemonLockPath,
+      lockPid,
+      lockStale: lock.stale
+    };
+  }
+  const running = isProcessAlive(pid);
+  return {
+    running,
+    pid,
+    stale: !running || lock.stale,
+    capabilities: running ? lock.metadata?.capabilities ?? [] : [],
+    ready: running && !lockReadyStateKnown ? true : running && lockReady,
+    readyAt: running ? lock.metadata?.readyAt ?? null : null,
+    readyStateKnown: running && lockReadyStateKnown,
+    pidPath: paths.pidPath,
+    lockPath: paths.daemonLockPath,
+    lockPid,
+    lockStale: lock.stale
+  };
+}
+async function startDaemon(homeDir) {
+  const paths = await ensureDaemonDirs(homeDir);
+  const aiWorkingDir = await ensureAiWorkspace(paths);
+  const current = await getDaemonStatus(homeDir);
+  if (current.running) {
+    return {
+      ...current,
+      started: false,
+      logPath: paths.listenerLogPath
+    };
+  }
+  if (current.stale) {
+    await removePid(paths.pidPath);
+  }
+  const store = new SessionStore({ homeDir });
+  try {
+    store.setSetting("ai_working_dir", aiWorkingDir);
+    store.resetGlobalSession(SYSTEM_NOTIFICATION_SESSION_KEY);
+  } finally {
+    store.close();
+  }
+  const logFd = (0, import_node_fs3.openSync)(paths.listenerLogPath, "a");
+  const entry = process.env.OKX_AGENT_TASK_CLI_PATH || (0, import_node_path5.join)(__dirname, "cli.js");
+  const daemonCwd = (0, import_node_path5.join)(__dirname, "..");
+  const child = (0, import_node_child_process.spawn)(process.execPath, [entry, "run"], {
+    cwd: daemonCwd,
+    detached: true,
+    // win32: keep the detached daemon from flashing/holding a console window.
+    // Ignored on every non-win32 platform.
+    windowsHide: true,
+    env: {
+      ...process.env,
+      OKX_AGENT_TASK_HOME: paths.homeDir,
+      OKX_AGENT_TASK_DAEMON: "1",
+      OKX_A2A_AI_CWD: aiWorkingDir,
+      OKX_AGENT_TASK_AI_CWD: aiWorkingDir
+    },
+    stdio: ["ignore", logFd, logFd]
+  });
+  (0, import_node_fs3.closeSync)(logFd);
+  child.unref();
+  await (0, import_promises2.writeFile)(paths.pidPath, `${child.pid ?? ""}
+`, "utf8");
+  if (await waitForImmediateExit(child, START_EXIT_CHECK_MS)) {
+    const status = await getDaemonStatus(homeDir);
+    if (status.running && status.lockPid) {
+      await (0, import_promises2.writeFile)(paths.pidPath, `${status.lockPid}
+`, "utf8");
+    } else {
+      await removePid(paths.pidPath);
+    }
+    return {
+      ...status,
+      started: false,
+      logPath: paths.listenerLogPath
+    };
+  }
+  return {
+    running: true,
+    pid: child.pid ?? null,
+    stale: false,
+    capabilities: DAEMON_CAPABILITIES,
+    ready: false,
+    readyAt: null,
+    readyStateKnown: true,
+    pidPath: paths.pidPath,
+    lockPath: paths.daemonLockPath,
+    lockPid: child.pid ?? null,
+    lockStale: false,
+    started: true,
+    logPath: paths.listenerLogPath
+  };
+}
+async function waitForExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isProcessAlive(pid)) {
+      return true;
+    }
+    await new Promise((resolve6) => setTimeout(resolve6, 100));
+  }
+  return !isProcessAlive(pid);
+}
+function signalProcess(pid, signal) {
+  try {
+    process.kill(pid, signal);
+    return true;
+  } catch (err2) {
+    const code2 = err2.code;
+    if (code2 === "ESRCH") {
+      return false;
+    }
+    throw err2;
+  }
+}
+async function stopDaemon(homeDir) {
+  const paths = resolveTaskPaths(homeDir);
+  const current = await getDaemonStatus(homeDir);
+  if (!current.pid) {
+    return { ...current, stopped: false };
+  }
+  if (!current.running) {
+    await removePid(paths.pidPath);
+    return {
+      running: false,
+      pid: current.pid,
+      stale: false,
+      capabilities: [],
+      ready: false,
+      readyAt: null,
+      readyStateKnown: false,
+      pidPath: paths.pidPath,
+      lockPath: paths.daemonLockPath,
+      lockPid: current.lockPid,
+      lockStale: current.lockStale,
+      stopped: false
+    };
+  }
+  const signalled = signalProcess(current.pid, "SIGTERM");
+  let forced = false;
+  let exited = !signalled || await waitForExit(current.pid, STOP_GRACE_MS);
+  if (!exited) {
+    forced = true;
+    const killed = signalProcess(current.pid, "SIGKILL");
+    exited = !killed || await waitForExit(current.pid, FORCE_KILL_GRACE_MS);
+  }
+  if (exited) {
+    await removePid(paths.pidPath);
+  }
+  return {
+    running: !exited,
+    pid: current.pid,
+    stale: false,
+    capabilities: exited ? [] : current.capabilities,
+    ready: !exited && current.ready,
+    readyAt: !exited ? current.readyAt : null,
+    readyStateKnown: !exited && current.readyStateKnown,
+    pidPath: paths.pidPath,
+    lockPath: paths.daemonLockPath,
+    lockPid: current.lockPid,
+    lockStale: current.lockStale,
+    stopped: exited,
+    forced
+  };
+}
+async function ensureDaemonReady(options = {}) {
+  const paths = resolveTaskPaths(options.homeDir);
+  const commandName = options.commandName ?? "command";
+  const timeoutMs = options.timeoutMs ?? readReadyTimeoutMs(options.env ?? process.env);
+  let status = await getDaemonStatus(options.homeDir);
+  let started = false;
+  let logPath = paths.listenerLogPath;
+  if (!status.running) {
+    options.stderr?.write(`[okx-a2a] ${commandName} requires the daemon; starting daemon...
+`);
+    const startResult = await startDaemon(options.homeDir);
+    started = startResult.started;
+    logPath = startResult.logPath;
+    status = startResult;
+    if (!status.running) {
+      throw new Error(
+        `${commandName} requires the daemon, but automatic daemon start failed. Check ${logPath} or run \`okx-a2a daemon restart\`.`
+      );
+    }
+    status = await waitForDaemonReady({
+      homeDir: options.homeDir,
+      timeoutMs,
+      requiredCapabilities: options.requiredCapabilities,
+      requireKnownReadyState: true,
+      logPath,
+      commandName
+    });
+    options.stderr?.write(`[okx-a2a] daemon ready pid=${status.pid ?? "(unknown)"} log=${logPath}
+`);
+  } else if (status.readyStateKnown && !status.ready) {
+    status = await waitForDaemonReady({
+      homeDir: options.homeDir,
+      timeoutMs,
+      requiredCapabilities: options.requiredCapabilities,
+      requireKnownReadyState: false,
+      logPath,
+      commandName
+    });
+  }
+  assertRequiredCapabilities(status, options.requiredCapabilities, commandName);
+  return {
+    ...status,
+    started,
+    logPath
+  };
+}
+async function waitForDaemonReady(options) {
+  const deadline = Date.now() + Math.max(0, options.timeoutMs);
+  let lastStatus = await getDaemonStatus(options.homeDir);
+  while (Date.now() <= deadline) {
+    const status = await getDaemonStatus(options.homeDir);
+    lastStatus = status;
+    if (!status.running) {
+      if (status.stale) {
+        throw new Error(
+          `${options.commandName} requires the daemon, but the daemon exited before becoming ready. Check ${options.logPath} or run \`okx-a2a daemon restart\`.`
+        );
+      }
+    } else if (isReadyForCommand(status, options.requiredCapabilities, options.requireKnownReadyState)) {
+      return status;
+    } else if (status.ready && findMissingCapabilities(status, options.requiredCapabilities).length > 0) {
+      assertRequiredCapabilities(status, options.requiredCapabilities, options.commandName);
+    }
+    await sleep(Math.min(READY_POLL_MS, Math.max(1, deadline - Date.now() + 1)));
+  }
+  const missing = findMissingCapabilities(lastStatus, options.requiredCapabilities);
+  const capabilitySuffix = missing.length > 0 ? ` missingCapabilities=${missing.join(",")}` : "";
+  throw new Error(
+    `${options.commandName} requires the daemon, but it did not become ready within ${options.timeoutMs}ms${capabilitySuffix}. Check ${options.logPath} or run \`okx-a2a daemon restart\`.`
+  );
+}
+function isReadyForCommand(status, requiredCapabilities, requireKnownReadyState = false) {
+  if (!status.running) {
+    return false;
+  }
+  if (requireKnownReadyState && !status.readyStateKnown) {
+    return false;
+  }
+  if (status.readyStateKnown && !status.ready) {
+    return false;
+  }
+  return findMissingCapabilities(status, requiredCapabilities).length === 0;
+}
+function assertRequiredCapabilities(status, requiredCapabilities, commandName) {
+  const missing = findMissingCapabilities(status, requiredCapabilities);
+  if (missing.length === 0) {
+    return;
+  }
+  throw new Error(
+    `${commandName} requires a daemon with ${missing.join(",")} support. Run \`okx-a2a daemon restart\` first.`
+  );
+}
+function findMissingCapabilities(status, requiredCapabilities) {
+  if (!requiredCapabilities || requiredCapabilities.length === 0) {
+    return [];
+  }
+  return requiredCapabilities.filter((capability) => !status.capabilities.includes(capability));
+}
+function readReadyTimeoutMs(env) {
+  const raw = env[DAEMON_READY_TIMEOUT_ENV]?.trim();
+  if (!raw) {
+    return DEFAULT_READY_TIMEOUT_MS;
+  }
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_READY_TIMEOUT_MS;
+}
+function sleep(ms) {
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
+}
+var import_node_fs3, import_promises2, import_node_child_process, import_node_path5, STOP_GRACE_MS, FORCE_KILL_GRACE_MS, START_EXIT_CHECK_MS, DEFAULT_READY_TIMEOUT_MS, READY_POLL_MS, DAEMON_READY_TIMEOUT_ENV;
+var init_daemon = __esm({
+  "src/daemon.ts"() {
+    "use strict";
+    import_node_fs3 = require("node:fs");
+    import_promises2 = require("node:fs/promises");
+    import_node_child_process = require("node:child_process");
+    import_node_path5 = require("node:path");
+    init_paths();
+    init_session_store();
+    init_daemon_lock();
+    STOP_GRACE_MS = 5e3;
+    FORCE_KILL_GRACE_MS = 5e3;
+    START_EXIT_CHECK_MS = 750;
+    DEFAULT_READY_TIMEOUT_MS = 12e4;
+    READY_POLL_MS = 250;
+    DAEMON_READY_TIMEOUT_ENV = "OKX_A2A_DAEMON_READY_TIMEOUT_MS";
+  }
+});
+
 // ../core/src/log.ts
 function formatLogTimestamp(date = /* @__PURE__ */ new Date()) {
   return date.toLocaleString(void 0, {
@@ -2228,11 +2742,25 @@ function switchProvider(options) {
     readParentProcessCommand: options.readParentProcessCommand
   });
   if (runtime === "unknown") {
+    const stored = options.store.getDefaultAiProvider();
+    if (stored) {
+      return {
+        ok: true,
+        runtime: "unknown",
+        provider: stored,
+        previousProvider: stored,
+        changed: false,
+        action: "kept_existing",
+        userMessage: `No AI runtime detected for the current environment; keeping the existing default provider (${formatAiProviderDisplayName(stored)}).`
+      };
+    }
     return {
       ok: false,
       runtime: "unknown",
       reason: "unknown_runtime",
-      message: "Could not determine the current AI provider."
+      state: "blocked",
+      message: "Could not determine the current AI provider.",
+      userMessage: "Could not detect the current AI runtime and no default AI provider is configured. Run this from your AI environment (OpenClaw / Codex / Claude / Hermes), or set a provider manually: `okx-a2a ai-provider set --provider <codex|claude|hermes|openclaw>`."
     };
   }
   const previousProvider = options.store.getDefaultAiProvider();
@@ -2244,6 +2772,7 @@ function switchProvider(options) {
     provider: runtime,
     previousProvider,
     changed,
+    action: "switched",
     userMessage: changed ? `Switched to ${formatAiProviderDisplayName(runtime)}\uFF5CNew tasks will be handled here; unfinished tasks should be continued in their original session` : ""
   };
 }
@@ -70893,6 +71422,207 @@ var require_ws = __commonJS({
   }
 });
 
+// src/win-native-launcher.ts
+var win_native_launcher_exports = {};
+__export(win_native_launcher_exports, {
+  NATIVE_LAUNCHER_EXE_NAME: () => NATIVE_LAUNCHER_EXE_NAME,
+  buildLauncherEntryJs: () => buildLauncherEntryJs,
+  buildSeaConfig: () => buildSeaConfig,
+  ensureWindowsNativeLauncher: () => ensureWindowsNativeLauncher,
+  findWindowsNativeOkxA2aExe: () => findWindowsNativeOkxA2aExe,
+  installWindowsNativeLauncher: () => installWindowsNativeLauncher,
+  resolveRunningCliPath: () => resolveRunningCliPath
+});
+function isPostjectRunnable() {
+  try {
+    const probe = spawnSyncCompat(POSTJECT_BIN, ["--help"], {
+      stdio: "ignore",
+      windowsHide: true,
+      timeout: 3e4
+    });
+    return probe.status === 0;
+  } catch {
+    return false;
+  }
+}
+function resolvePostjectCommand() {
+  try {
+    const cliPath = (0, import_node_module.createRequire)(__filename).resolve("postject/dist/cli.js");
+    if ((0, import_node_fs16.existsSync)(cliPath)) {
+      return { command: process.execPath, prefixArgs: [cliPath] };
+    }
+  } catch {
+  }
+  if (!isPostjectRunnable()) {
+    logWinCompat(`${WIN_COMPAT_LOG_PREFIX} native launcher: installing ${POSTJECT_SPEC} globally`);
+    const install = spawnSyncCompat("npm", [
+      "install",
+      "-g",
+      POSTJECT_SPEC,
+      "--no-audit",
+      "--no-fund",
+      "--loglevel=error"
+    ], { encoding: "utf8", windowsHide: true, timeout: 18e4 });
+    if (install.status !== 0 || !isPostjectRunnable()) {
+      throw new Error(
+        `failed to install ${POSTJECT_SPEC} (needed to build okx-a2a.exe): ${String(install.stderr || install.error?.message || "unknown error").slice(0, 300)}`
+      );
+    }
+  }
+  return { command: POSTJECT_BIN, prefixArgs: [] };
+}
+function injectSeaBlob(exePath, blobPath, isMac) {
+  const { command, prefixArgs: prefixArgs2 } = resolvePostjectCommand();
+  const args = [
+    ...prefixArgs2,
+    exePath,
+    "NODE_SEA_BLOB",
+    blobPath,
+    "--sentinel-fuse",
+    SEA_SENTINEL_FUSE,
+    "--overwrite"
+  ];
+  if (isMac) {
+    args.push("--macho-segment-name", "NODE_SEA");
+  }
+  const result = spawnSyncCompat(command, args, {
+    encoding: "utf8",
+    windowsHide: true,
+    timeout: 12e4
+  });
+  if (result.status !== 0) {
+    throw new Error(
+      `postject injection failed: ${String(result.stderr || result.error?.message || `exit ${result.status}`).slice(0, 300)}`
+    );
+  }
+}
+function buildLauncherEntryJs(cliPath) {
+  const target = JSON.stringify(cliPath);
+  return [
+    'const { createRequire } = require("node:module");',
+    `const nodeRequire = createRequire(${target});`,
+    `nodeRequire(${target});`,
+    ""
+  ].join("\n");
+}
+function buildSeaConfig(entryPath, blobPath) {
+  return `${JSON.stringify(
+    {
+      main: entryPath,
+      output: blobPath,
+      disableExperimentalSEAWarning: true
+    },
+    null,
+    2
+  )}
+`;
+}
+async function installWindowsNativeLauncher(options) {
+  const nodeExe = options.nodeExe ?? process.execPath;
+  if (!(0, import_node_fs16.existsSync)(options.cliPath)) {
+    throw new Error(`cannot build okx-a2a.exe: CLI entry not found at ${options.cliPath}`);
+  }
+  if (!(0, import_node_fs16.existsSync)(nodeExe)) {
+    throw new Error(`cannot build okx-a2a.exe: node executable not found at ${nodeExe}`);
+  }
+  const exePath = (0, import_node_path22.join)(options.targetDir, NATIVE_LAUNCHER_EXE_NAME);
+  (0, import_node_fs16.mkdirSync)(options.targetDir, { recursive: true });
+  const work = (0, import_node_fs16.mkdtempSync)((0, import_node_path22.join)((0, import_node_os7.tmpdir)(), "okx-a2a-sea-"));
+  try {
+    const entryPath = (0, import_node_path22.join)(work, "launcher-entry.js");
+    const blobPath = (0, import_node_path22.join)(work, "okx-a2a.blob");
+    const configPath = (0, import_node_path22.join)(work, "sea-config.json");
+    (0, import_node_fs16.writeFileSync)(entryPath, buildLauncherEntryJs(options.cliPath), "utf8");
+    (0, import_node_fs16.writeFileSync)(configPath, buildSeaConfig(entryPath, blobPath), "utf8");
+    (0, import_node_child_process5.execFileSync)(nodeExe, ["--experimental-sea-config", configPath], {
+      stdio: "ignore",
+      windowsHide: true
+    });
+    (0, import_node_fs16.copyFileSync)(nodeExe, exePath);
+    const isMac = process.platform === "darwin";
+    if (isMac) {
+      try {
+        (0, import_node_child_process5.execFileSync)("codesign", ["--remove-signature", exePath], { stdio: "ignore" });
+      } catch {
+      }
+    }
+    injectSeaBlob(exePath, blobPath, isMac);
+    if (isMac) {
+      try {
+        (0, import_node_child_process5.execFileSync)("codesign", ["--sign", "-", exePath], { stdio: "ignore" });
+      } catch {
+      }
+    }
+    logWinCompat(
+      `${WIN_COMPAT_LOG_PREFIX} native launcher: built ${exePath} from node=${nodeExe} cli=${options.cliPath}`
+    );
+    return { exePath, cliPath: options.cliPath, nodeExe };
+  } finally {
+    (0, import_node_fs16.rmSync)(work, { recursive: true, force: true });
+  }
+}
+function findWindowsNativeOkxA2aExe(pathValue, appData, userProfile, fileExists2 = import_node_fs16.existsSync) {
+  const dirs = pathValue.split(";").map((d) => d.trim()).filter(Boolean);
+  if (appData) {
+    dirs.push((0, import_node_path22.join)(appData, "npm"));
+  }
+  if (userProfile) {
+    dirs.push((0, import_node_path22.join)(userProfile, ".local", "bin"));
+  }
+  for (const dir of dirs) {
+    const candidate = (0, import_node_path22.join)(dir, NATIVE_LAUNCHER_EXE_NAME);
+    if (fileExists2(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveRunningCliPath() {
+  const fromArgv = process.argv[1];
+  if (fromArgv && /(?:^|[\\/])cli\.js$/.test(fromArgv) && (0, import_node_fs16.existsSync)(fromArgv)) {
+    return fromArgv;
+  }
+  const beside = (0, import_node_path22.join)(__dirname, "cli.js");
+  if ((0, import_node_fs16.existsSync)(beside)) {
+    return beside;
+  }
+  if (fromArgv) {
+    return fromArgv;
+  }
+  throw new Error("could not resolve the running okx-a2a CLI path for the native launcher");
+}
+async function ensureWindowsNativeLauncher(options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform !== "win32") {
+    return null;
+  }
+  const env = options.env ?? process.env;
+  const existing = findWindowsNativeOkxA2aExe(env.PATH ?? env.Path ?? "", env.APPDATA, env.USERPROFILE);
+  if (existing) {
+    return { exePath: existing, installed: false };
+  }
+  const targetDir = env.APPDATA ? (0, import_node_path22.join)(env.APPDATA, "npm") : (0, import_node_path22.join)(env.USERPROFILE ?? (0, import_node_os7.homedir)(), ".local", "bin");
+  const result = await installWindowsNativeLauncher({ cliPath: resolveRunningCliPath(), targetDir });
+  return { exePath: result.exePath, installed: true };
+}
+var import_node_child_process5, import_node_fs16, import_node_module, import_node_os7, import_node_path22, SEA_SENTINEL_FUSE, NATIVE_LAUNCHER_EXE_NAME, POSTJECT_SPEC, POSTJECT_BIN;
+var init_win_native_launcher = __esm({
+  "src/win-native-launcher.ts"() {
+    "use strict";
+    import_node_child_process5 = require("node:child_process");
+    import_node_fs16 = require("node:fs");
+    import_node_module = require("node:module");
+    import_node_os7 = require("node:os");
+    import_node_path22 = require("node:path");
+    init_win_compat();
+    init_win_spawn();
+    SEA_SENTINEL_FUSE = "NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2";
+    NATIVE_LAUNCHER_EXE_NAME = "okx-a2a.exe";
+    POSTJECT_SPEC = "postject@1.0.0-alpha.6";
+    POSTJECT_BIN = "postject";
+  }
+});
+
 // src/update-cli.ts
 var update_cli_exports = {};
 __export(update_cli_exports, {
@@ -70918,6 +71648,8 @@ __export(update_cli_exports, {
   parseUpdateArgs: () => parseUpdateArgs,
   printSetupUsage: () => printSetupUsage,
   printUpdateUsage: () => printUpdateUsage,
+  resolveHermesConfigPath: () => resolveHermesConfigPath,
+  resolveHermesPluginYamlPath: () => resolveHermesPluginYamlPath,
   runProviderLoginInteractive: () => runProviderLoginInteractive,
   setRedirectCommandStdoutToStderr: () => setRedirectCommandStdoutToStderr
 });
@@ -71131,6 +71863,7 @@ async function runSetup(options) {
     if (nodeChange.nodeChanged && provider) {
       await restartNodeDaemonAfterNodeSetup();
     }
+    await ensureWindowsNativeLauncherForSetup();
     return {
       ok: true,
       state: "ready",
@@ -71164,6 +71897,7 @@ async function runSetup(options) {
     if (changes.pluginChanged) {
       await restartGatewayAfterSetup(resolvedTarget);
     }
+    await ensureWindowsNativeLauncherForSetup();
     warnIfProviderMismatch(resolvedTarget);
     return {
       ok: true,
@@ -71610,7 +72344,7 @@ async function getCurrentNodeCliVersion() {
   return await getGlobalNpmPackageVersion(UPDATE_PACKAGES.node) ?? getBundledNodeCliVersion();
 }
 function getBundledNodeCliVersion() {
-  return true ? "0.1.4" : null;
+  return true ? "0.1.6-beta-c3024b2b0b-260706164140" : null;
 }
 function readConfiguredAiProvider() {
   const explicit = process.env.OKX_A2A_AI_PROVIDER || process.env.OKX_AGENT_TASK_AI_CLI;
@@ -71641,10 +72375,29 @@ async function restartNodeDaemonAfterUpdate() {
 }
 async function installNode(release, label) {
   const spec = buildNpmPackageSpec("node", release);
+  if (process.platform === "win32") {
+    const { getDaemonStatus: getDaemonStatus2, stopDaemon: stopDaemon2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+    const status = await getDaemonStatus2();
+    if (status.running) {
+      console.log(`[${label}] stopping the running daemon before reinstalling on Windows (its native addons lock the package dir)`);
+      await stopDaemon2();
+    }
+  }
   console.log(`[${label}] installing ${spec}`);
   await runCommand("npm", ["install", "-g", spec]);
   console.log(`[${label}] okx-a2a node CLI ${label === "setup" ? "setup" : "update"} done`);
 }
+async function ensureWindowsNativeLauncherForSetup() {
+  if (process.platform !== "win32") {
+    return;
+  }
+  const { ensureWindowsNativeLauncher: ensureWindowsNativeLauncher2 } = await Promise.resolve().then(() => (init_win_native_launcher(), win_native_launcher_exports));
+  const result = await ensureWindowsNativeLauncher2();
+  if (!result) {
+    return;
+  }
+  console.log(result.installed ? `[setup] built native okx-a2a.exe launcher at ${result.exePath}` : `[setup] native okx-a2a.exe launcher already present at ${result.exePath}`);
+}
 async function restartNodeDaemonAfterSetup(provider) {
   console.log(`[setup] restarting okx-a2a daemon after node CLI setup with provider=${provider}`);
   await runCommand("okx-a2a", ["daemon", "restart", "--provider", provider]);
@@ -71776,17 +72529,17 @@ async function updateHermes(release, options) {
     assertNotRunningInsideGateway("hermes");
   }
   const spec = buildNpmPackageSpec("hermes", release);
-  const workDir = await (0, import_promises7.mkdtemp)((0, import_node_path22.join)((0, import_node_os7.tmpdir)(), `okx-a2a-${label}-hermes-`));
+  const workDir = await (0, import_promises7.mkdtemp)((0, import_node_path23.join)((0, import_node_os8.tmpdir)(), `okx-a2a-${label}-hermes-`));
   try {
     console.log(`[${label}] downloading ${spec}`);
     const npmTarball = await npmPack(spec, workDir);
-    const npmPackageDir = (0, import_node_path22.join)(workDir, "npm-package");
+    const npmPackageDir = (0, import_node_path23.join)(workDir, "npm-package");
     await runCommand("tar", ["-xzf", npmTarball, "-C", npmPackageDir], { ensureDir: npmPackageDir });
-    const pluginTarball = await findHermesPluginTarball((0, import_node_path22.join)(npmPackageDir, "package", "dist"));
-    const pluginDir = (0, import_node_path22.join)(workDir, "plugin");
+    const pluginTarball = await findHermesPluginTarball((0, import_node_path23.join)(npmPackageDir, "package", "dist"));
+    const pluginDir = (0, import_node_path23.join)(workDir, "plugin");
     await runCommand("tar", ["-xzf", pluginTarball, "-C", pluginDir], { ensureDir: pluginDir });
     const unpackedPluginDir = await findFirstDirectory(pluginDir);
-    const installer = (0, import_node_path22.join)(unpackedPluginDir, "scripts", "install-or-upgrade.sh");
+    const installer = (0, import_node_path23.join)(unpackedPluginDir, "scripts", "install-or-upgrade.sh");
     console.log(`[${label}] running ${installer}`);
     await runCommand("bash", [installer, ...options.restart ? ["--restart"] : []], { cwd: unpackedPluginDir });
     await normalizeHermesOkxA2aPluginConfig();
@@ -71801,7 +72554,7 @@ async function updateHermes(release, options) {
   }
 }
 async function installGatewayPluginForDoctor(target) {
-  const release = isPrereleaseVersion("0.1.4") ? "beta" : "latest";
+  const release = isPrereleaseVersion("0.1.6-beta-c3024b2b0b-260706164140") ? "beta" : "latest";
   const insideTargetGateway = detectGatewayInvocation() === target;
   const options = {
     restart: !insideTargetGateway,
@@ -71852,7 +72605,7 @@ async function ensureHermesOkxA2aPluginConfig(configFile = resolveHermesConfigPa
       if (options.dryRun) {
         return true;
       }
-      await (0, import_promises7.mkdir)((0, import_node_path22.resolve)(configFile, ".."), { recursive: true });
+      await (0, import_promises7.mkdir)((0, import_node_path23.resolve)(configFile, ".."), { recursive: true });
       await (0, import_promises7.writeFile)(configFile, "plugins:\n  enabled:\n    - okx-a2a\n");
       console.log(`[update] added Hermes plugins.enabled okx-a2a entry in ${configFile}`);
       return true;
@@ -72092,7 +72845,7 @@ function findFirstEnabledListItem(lines, startIndex, enabledIndent) {
   return null;
 }
 function resolveHermesConfigPath() {
-  return (0, import_node_path22.join)(process.env.HERMES_HOME ?? (0, import_node_path22.join)((0, import_node_os7.homedir)(), ".hermes"), "config.yaml");
+  return (0, import_node_path23.join)(process.env.HERMES_HOME ?? (0, import_node_path23.join)((0, import_node_os8.homedir)(), ".hermes"), "config.yaml");
 }
 function lineIndent(line) {
   const match = line.match(/^\s*/);
@@ -72169,22 +72922,18 @@ async function assertGatewayPluginInstalled(target) {
     `okx-a2a ${target} plugin is not installed. Run \`okx-a2a setup ${target}\` first; use \`okx-a2a update ${target}\` only for an existing installation.`
   );
 }
+function resolveHermesPluginYamlPath() {
+  return (0, import_node_path23.join)(process.env.HERMES_HOME ?? (0, import_node_path23.join)((0, import_node_os8.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
+}
 async function isGatewayPluginInstalled(target) {
   if (target === "openclaw") {
     return (await getInstalledOpenClawPluginInfo()).installed;
   }
-  if ((0, import_node_fs16.existsSync)((0, import_node_path22.join)(process.env.HERMES_HOME ?? (0, import_node_path22.join)((0, import_node_os7.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml"))) {
-    return true;
-  }
-  return await isGlobalNpmPackageInstalled(UPDATE_PACKAGES.hermes);
-}
-async function isGlobalNpmPackageInstalled(packageName) {
-  const result = await runCommandCaptureOptional("npm", ["list", "-g", packageName, "--depth=0"]);
-  return result.ok && result.stdout.includes(packageName);
+  return (0, import_node_fs17.existsSync)(resolveHermesPluginYamlPath());
 }
 async function getInstalledGatewayPluginVersion(target) {
   if (target === "hermes") {
-    return await getInstalledHermesPluginVersion() ?? await getGlobalNpmPackageVersion(UPDATE_PACKAGES.hermes);
+    return await getInstalledHermesPluginVersion();
   }
   return (await getInstalledOpenClawPluginInfo()).version;
 }
@@ -72267,7 +73016,7 @@ function parsePackageVersionFromText(output) {
   return output.match(/@okxweb3\/a2a-openclaw@([0-9A-Za-z.+-]+)/)?.[1] ?? null;
 }
 async function getInstalledHermesPluginVersion() {
-  const pluginYaml = (0, import_node_path22.join)(process.env.HERMES_HOME ?? (0, import_node_path22.join)((0, import_node_os7.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
+  const pluginYaml = (0, import_node_path23.join)(process.env.HERMES_HOME ?? (0, import_node_path23.join)((0, import_node_os8.homedir)(), ".hermes"), "plugins", "platforms", "okx-a2a", "plugin.yaml");
   try {
     const content3 = await (0, import_promises7.readFile)(pluginYaml, "utf8");
     return parsePluginYamlVersion(content3);
@@ -72325,7 +73074,7 @@ async function npmPack(spec, destination) {
   if (!tarballName) {
     throw new Error(`Unable to detect npm pack tarball from output: ${output.trim()}`);
   }
-  return (0, import_node_path22.resolve)(destination, (0, import_node_path22.basename)(tarballName));
+  return (0, import_node_path23.resolve)(destination, (0, import_node_path23.basename)(tarballName));
 }
 async function findHermesPluginTarball(distDir) {
   const entries = await (0, import_promises7.readdir)(distDir);
@@ -72333,7 +73082,7 @@ async function findHermesPluginTarball(distDir) {
   if (!tarball) {
     throw new Error(`Hermes npm package did not contain dist/okx-a2a-hermes-plugin-*.tar.gz`);
   }
-  return (0, import_node_path22.join)(distDir, tarball);
+  return (0, import_node_path23.join)(distDir, tarball);
 }
 async function findFirstDirectory(parent) {
   const entries = await (0, import_promises7.readdir)(parent, { withFileTypes: true });
@@ -72341,7 +73090,7 @@ async function findFirstDirectory(parent) {
   if (!dir) {
     throw new Error(`No unpacked plugin directory found under ${parent}`);
   }
-  return (0, import_node_path22.join)(parent, dir.name);
+  return (0, import_node_path23.join)(parent, dir.name);
 }
 function readOption(args, name2) {
   const index2 = args.indexOf(name2);
@@ -72392,7 +73141,7 @@ async function runCommand(command, args, options = {}) {
   await new Promise((resolvePromise, reject) => {
     const invocation = buildExternalCommandInvocation(command, args);
     const redirect = redirectCommandStdoutToStderr || options.redirectStdoutToStderr === true;
-    const child = (0, import_node_child_process5.spawn)(invocation.command, invocation.args, {
+    const child = (0, import_node_child_process6.spawn)(invocation.command, invocation.args, {
       cwd: options.cwd,
       stdio: redirect ? [options.inheritStdin ? "inherit" : "ignore", "pipe", "pipe"] : "inherit",
       windowsVerbatimArguments: invocation.windowsVerbatimArguments
@@ -72436,7 +73185,7 @@ async function runCommand(command, args, options = {}) {
 async function runCommandCapture(command, args) {
   return await new Promise((resolvePromise, reject) => {
     const invocation = buildExternalCommandInvocation(command, args);
-    const child = (0, import_node_child_process5.spawn)(invocation.command, invocation.args, {
+    const child = (0, import_node_child_process6.spawn)(invocation.command, invocation.args, {
       stdio: ["ignore", "pipe", "pipe"],
       windowsVerbatimArguments: invocation.windowsVerbatimArguments
     });
@@ -72469,7 +73218,7 @@ ${stderr}`));
 async function runCommandCaptureOptional(command, args) {
   return await new Promise((resolvePromise) => {
     const invocation = buildExternalCommandInvocation(command, args);
-    const child = (0, import_node_child_process5.spawn)(invocation.command, invocation.args, {
+    const child = (0, import_node_child_process6.spawn)(invocation.command, invocation.args, {
       stdio: ["ignore", "pipe", "ignore"],
       windowsVerbatimArguments: invocation.windowsVerbatimArguments
     });
@@ -72489,7 +73238,7 @@ async function runCommandCaptureOptional(command, args) {
 async function runCommandCaptureStatus(command, args) {
   return await new Promise((resolvePromise) => {
     const invocation = buildExternalCommandInvocation(command, args);
-    const child = (0, import_node_child_process5.spawn)(invocation.command, invocation.args, {
+    const child = (0, import_node_child_process6.spawn)(invocation.command, invocation.args, {
       stdio: ["ignore", "pipe", "pipe"],
       windowsVerbatimArguments: invocation.windowsVerbatimArguments
     });
@@ -72531,15 +73280,15 @@ function buildExternalCommandInvocation(command, args, platform = process.platfo
 function formatExternalCommand(command, args) {
   return [command, ...args].join(" ");
 }
-var import_node_child_process5, import_node_fs16, import_promises7, import_node_os7, import_node_path22, UPDATE_PACKAGES, CODEX_NPM_PACKAGE, OPENCLAW_FORCE_INSTALL_FLAG, OPENCLAW_UNSAFE_INSTALL_FLAG, OKX_A2A_PLUGIN_ID, OPENCLAW_SESSION_DM_SCOPE_CONFIG_PATH, OPENCLAW_SESSION_DM_SCOPE_CONFIG_VALUE, OPENCLAW_PLUGIN_ALLOW_CONFIG_PATH, OPENCLAW_OKX_A2A_CONVERSATION_HOOK_ACCESS_CONFIG_PATH, DEFAULT_AI_PROVIDER_LOGIN_TIMEOUT_MS, SetupBlockedError, redirectCommandStdoutToStderr;
+var import_node_child_process6, import_node_fs17, import_promises7, import_node_os8, import_node_path23, UPDATE_PACKAGES, CODEX_NPM_PACKAGE, OPENCLAW_FORCE_INSTALL_FLAG, OPENCLAW_UNSAFE_INSTALL_FLAG, OKX_A2A_PLUGIN_ID, OPENCLAW_SESSION_DM_SCOPE_CONFIG_PATH, OPENCLAW_SESSION_DM_SCOPE_CONFIG_VALUE, OPENCLAW_PLUGIN_ALLOW_CONFIG_PATH, OPENCLAW_OKX_A2A_CONVERSATION_HOOK_ACCESS_CONFIG_PATH, DEFAULT_AI_PROVIDER_LOGIN_TIMEOUT_MS, SetupBlockedError, redirectCommandStdoutToStderr;
 var init_update_cli = __esm({
   "src/update-cli.ts"() {
     "use strict";
-    import_node_child_process5 = require("node:child_process");
-    import_node_fs16 = require("node:fs");
+    import_node_child_process6 = require("node:child_process");
+    import_node_fs17 = require("node:fs");
     import_promises7 = require("node:fs/promises");
-    import_node_os7 = require("node:os");
-    import_node_path22 = require("node:path");
+    import_node_os8 = require("node:os");
+    import_node_path23 = require("node:path");
     init_ai_command();
     init_win_spawn();
     init_ai_provider();
@@ -72570,160 +73319,6 @@ var init_update_cli = __esm({
   }
 });
 
-// src/win-native-launcher.ts
-var win_native_launcher_exports = {};
-__export(win_native_launcher_exports, {
-  NATIVE_LAUNCHER_EXE_NAME: () => NATIVE_LAUNCHER_EXE_NAME,
-  buildLauncherEntryJs: () => buildLauncherEntryJs,
-  buildSeaConfig: () => buildSeaConfig,
-  installWindowsNativeLauncher: () => installWindowsNativeLauncher
-});
-function isPostjectRunnable() {
-  try {
-    const probe = spawnSyncCompat(POSTJECT_BIN, ["--help"], {
-      stdio: "ignore",
-      windowsHide: true,
-      timeout: 3e4
-    });
-    return probe.status === 0;
-  } catch {
-    return false;
-  }
-}
-function resolvePostjectCommand() {
-  try {
-    const cliPath = (0, import_node_module.createRequire)(__filename).resolve("postject/dist/cli.js");
-    if ((0, import_node_fs20.existsSync)(cliPath)) {
-      return { command: process.execPath, prefixArgs: [cliPath] };
-    }
-  } catch {
-  }
-  if (!isPostjectRunnable()) {
-    logWinCompat(`${WIN_COMPAT_LOG_PREFIX} native launcher: installing ${POSTJECT_SPEC} globally`);
-    const install = spawnSyncCompat("npm", [
-      "install",
-      "-g",
-      POSTJECT_SPEC,
-      "--no-audit",
-      "--no-fund",
-      "--loglevel=error"
-    ], { encoding: "utf8", windowsHide: true, timeout: 18e4 });
-    if (install.status !== 0 || !isPostjectRunnable()) {
-      throw new Error(
-        `failed to install ${POSTJECT_SPEC} (needed to build okx-a2a.exe): ${String(install.stderr || install.error?.message || "unknown error").slice(0, 300)}`
-      );
-    }
-  }
-  return { command: POSTJECT_BIN, prefixArgs: [] };
-}
-function injectSeaBlob(exePath, blobPath, isMac) {
-  const { command, prefixArgs: prefixArgs2 } = resolvePostjectCommand();
-  const args = [
-    ...prefixArgs2,
-    exePath,
-    "NODE_SEA_BLOB",
-    blobPath,
-    "--sentinel-fuse",
-    SEA_SENTINEL_FUSE,
-    "--overwrite"
-  ];
-  if (isMac) {
-    args.push("--macho-segment-name", "NODE_SEA");
-  }
-  const result = spawnSyncCompat(command, args, {
-    encoding: "utf8",
-    windowsHide: true,
-    timeout: 12e4
-  });
-  if (result.status !== 0) {
-    throw new Error(
-      `postject injection failed: ${String(result.stderr || result.error?.message || `exit ${result.status}`).slice(0, 300)}`
-    );
-  }
-}
-function buildLauncherEntryJs(cliPath) {
-  const target = JSON.stringify(cliPath);
-  return [
-    'const { createRequire } = require("node:module");',
-    `const nodeRequire = createRequire(${target});`,
-    `nodeRequire(${target});`,
-    ""
-  ].join("\n");
-}
-function buildSeaConfig(entryPath, blobPath) {
-  return `${JSON.stringify(
-    {
-      main: entryPath,
-      output: blobPath,
-      disableExperimentalSEAWarning: true
-    },
-    null,
-    2
-  )}
-`;
-}
-async function installWindowsNativeLauncher(options) {
-  const nodeExe = options.nodeExe ?? process.execPath;
-  if (!(0, import_node_fs20.existsSync)(options.cliPath)) {
-    throw new Error(`cannot build okx-a2a.exe: CLI entry not found at ${options.cliPath}`);
-  }
-  if (!(0, import_node_fs20.existsSync)(nodeExe)) {
-    throw new Error(`cannot build okx-a2a.exe: node executable not found at ${nodeExe}`);
-  }
-  const exePath = (0, import_node_path25.join)(options.targetDir, NATIVE_LAUNCHER_EXE_NAME);
-  (0, import_node_fs20.mkdirSync)(options.targetDir, { recursive: true });
-  const work = (0, import_node_fs20.mkdtempSync)((0, import_node_path25.join)((0, import_node_os9.tmpdir)(), "okx-a2a-sea-"));
-  try {
-    const entryPath = (0, import_node_path25.join)(work, "launcher-entry.js");
-    const blobPath = (0, import_node_path25.join)(work, "okx-a2a.blob");
-    const configPath = (0, import_node_path25.join)(work, "sea-config.json");
-    (0, import_node_fs20.writeFileSync)(entryPath, buildLauncherEntryJs(options.cliPath), "utf8");
-    (0, import_node_fs20.writeFileSync)(configPath, buildSeaConfig(entryPath, blobPath), "utf8");
-    (0, import_node_child_process8.execFileSync)(nodeExe, ["--experimental-sea-config", configPath], {
-      stdio: "ignore",
-      windowsHide: true
-    });
-    (0, import_node_fs20.copyFileSync)(nodeExe, exePath);
-    const isMac = process.platform === "darwin";
-    if (isMac) {
-      try {
-        (0, import_node_child_process8.execFileSync)("codesign", ["--remove-signature", exePath], { stdio: "ignore" });
-      } catch {
-      }
-    }
-    injectSeaBlob(exePath, blobPath, isMac);
-    if (isMac) {
-      try {
-        (0, import_node_child_process8.execFileSync)("codesign", ["--sign", "-", exePath], { stdio: "ignore" });
-      } catch {
-      }
-    }
-    logWinCompat(
-      `${WIN_COMPAT_LOG_PREFIX} native launcher: built ${exePath} from node=${nodeExe} cli=${options.cliPath}`
-    );
-    return { exePath, cliPath: options.cliPath, nodeExe };
-  } finally {
-    (0, import_node_fs20.rmSync)(work, { recursive: true, force: true });
-  }
-}
-var import_node_child_process8, import_node_fs20, import_node_module, import_node_os9, import_node_path25, SEA_SENTINEL_FUSE, NATIVE_LAUNCHER_EXE_NAME, POSTJECT_SPEC, POSTJECT_BIN;
-var init_win_native_launcher = __esm({
-  "src/win-native-launcher.ts"() {
-    "use strict";
-    import_node_child_process8 = require("node:child_process");
-    import_node_fs20 = require("node:fs");
-    import_node_module = require("node:module");
-    import_node_os9 = require("node:os");
-    import_node_path25 = require("node:path");
-    init_win_compat();
-    init_win_spawn();
-    SEA_SENTINEL_FUSE = "NODE_SEA_FUSE_fce680ab2cc467b6e072b8b5df1996b2";
-    NATIVE_LAUNCHER_EXE_NAME = "okx-a2a.exe";
-    POSTJECT_SPEC = "postject@1.0.0-alpha.6";
-    POSTJECT_BIN = "postject";
-  }
-});
-
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -72798,12 +73393,14 @@ __export(index_exports, {
   ensureDaemonReady: () => ensureDaemonReady,
   ensureDefaultAiProvider: () => ensureDefaultAiProvider,
   ensureOpenClawOkxA2aPluginConfig: () => ensureOpenClawOkxA2aPluginConfig,
+  ensureWindowsNativeLauncher: () => ensureWindowsNativeLauncher,
   extractAiSessionId: () => extractAiSessionId,
   extractXmtpSentAtMs: () => extractXmtpSentAtMs2,
   findWindowsNativeOkxA2aExe: () => findWindowsNativeOkxA2aExe,
   followFile: () => followFile,
   formatDoctorReportForHumans: () => formatDoctorReportForHumans,
   getDaemonStatus: () => getDaemonStatus,
+  getHermesGatewayPluginStatus: () => getHermesGatewayPluginStatus,
   handleDoctorCommand: () => handleDoctorCommand,
   handleXmtpSendCommand: () => handleXmtpSendCommand,
   hasAiRuntimeMarker: () => hasAiRuntimeMarker,
@@ -72882,502 +73479,7 @@ __export(index_exports, {
   writeAiPermissionPresetToConfig: () => writeAiPermissionPresetToConfig
 });
 module.exports = __toCommonJS(index_exports);
-
-// src/daemon.ts
-var import_node_fs3 = require("node:fs");
-var import_promises2 = require("node:fs/promises");
-var import_node_child_process = require("node:child_process");
-var import_node_path5 = require("node:path");
-init_paths();
-init_session_store();
-
-// src/daemon-lock.ts
-var import_promises = require("node:fs/promises");
-var import_node_path4 = require("node:path");
-init_paths();
-init_a2a_paths();
-var OWNER_FILE = "owner.json";
-var EMPTY_LOCK_STALE_MS = 1e4;
-var DAEMON_CAPABILITY_AI_DISPATCH = "ai-dispatch";
-var DAEMON_CAPABILITIES = [
-  DAEMON_CAPABILITY_AI_DISPATCH
-];
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err2) {
-    return err2.code === "EPERM";
-  }
-}
-function ownerPath(lockPath) {
-  return (0, import_node_path4.join)(lockPath, OWNER_FILE);
-}
-async function readDaemonLock(lockPath) {
-  let metadata = null;
-  try {
-    const raw = await (0, import_promises.readFile)(ownerPath(lockPath), "utf8");
-    metadata = JSON.parse(raw);
-  } catch (err2) {
-    const code2 = err2.code;
-    if (code2 === "ENOENT") {
-      try {
-        const info = await (0, import_promises.stat)(lockPath);
-        const stale = Date.now() - info.mtimeMs > EMPTY_LOCK_STALE_MS;
-        return { metadata: null, running: !stale, stale, path: lockPath };
-      } catch (statErr) {
-        const statCode = statErr.code;
-        if (statCode === "ENOENT") {
-          return { metadata: null, running: false, stale: false, path: lockPath };
-        }
-        throw statErr;
-      }
-    }
-    if (err2 instanceof SyntaxError) {
-      return { metadata: null, running: false, stale: true, path: lockPath };
-    }
-    throw err2;
-  }
-  const running = Number.isInteger(metadata.pid) && metadata.pid > 0 && isProcessAlive(metadata.pid);
-  return { metadata, running, stale: !running, path: lockPath };
-}
-async function markDaemonReady(lockPath) {
-  const current = await readDaemonLock(lockPath);
-  const metadata = current.metadata;
-  if (!metadata || metadata.pid !== process.pid) {
-    return;
-  }
-  await (0, import_promises.writeFile)(ownerPath(lockPath), `${JSON.stringify({
-    ...metadata,
-    ready: true,
-    readyAt: (/* @__PURE__ */ new Date()).toISOString()
-  }, null, 2)}
-`, "utf8");
-}
-async function removeLock(lockPath) {
-  await (0, import_promises.rm)(lockPath, { recursive: true, force: true });
-}
-async function acquireDaemonLock(paths, entry) {
-  const metadata = {
-    pid: process.pid,
-    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    cwd: process.cwd(),
-    entry,
-    homeDir: paths.homeDir,
-    capabilities: DAEMON_CAPABILITIES,
-    ready: false
-  };
-  ensureTaskDir(paths.runDir);
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    try {
-      await (0, import_promises.mkdir)(paths.daemonLockPath, { mode: A2A_TASK_DIR_MODE });
-      await chmodBestEffort(paths.daemonLockPath, A2A_TASK_DIR_MODE);
-      await (0, import_promises.writeFile)(ownerPath(paths.daemonLockPath), `${JSON.stringify(metadata, null, 2)}
-`, "utf8");
-      return {
-        metadata,
-        release: async () => {
-          const current = await readDaemonLock(paths.daemonLockPath);
-          if (current.metadata?.pid === process.pid) {
-            await removeLock(paths.daemonLockPath);
-          }
-        }
-      };
-    } catch (err2) {
-      const code2 = err2.code;
-      if (code2 !== "EEXIST") {
-        throw err2;
-      }
-      const current = await readDaemonLock(paths.daemonLockPath);
-      if (current.running) {
-        return null;
-      }
-      if (!current.stale) {
-        return null;
-      }
-      await removeLock(paths.daemonLockPath);
-    }
-  }
-  return null;
-}
-async function chmodBestEffort(path, mode) {
-  try {
-    await (0, import_promises.chmod)(path, mode);
-  } catch (err2) {
-    const code2 = err2.code;
-    if (code2 !== "EPERM" && code2 !== "EACCES") {
-      throw err2;
-    }
-  }
-}
-
-// src/daemon.ts
-var STOP_GRACE_MS = 5e3;
-var FORCE_KILL_GRACE_MS = 5e3;
-var START_EXIT_CHECK_MS = 750;
-var DEFAULT_READY_TIMEOUT_MS = 12e4;
-var READY_POLL_MS = 250;
-var DAEMON_READY_TIMEOUT_ENV = "OKX_A2A_DAEMON_READY_TIMEOUT_MS";
-async function readPid(pidPath) {
-  try {
-    const raw = await (0, import_promises2.readFile)(pidPath, "utf8");
-    const pid = Number.parseInt(raw.trim(), 10);
-    return Number.isInteger(pid) && pid > 0 ? pid : null;
-  } catch (err2) {
-    const code2 = err2.code;
-    if (code2 === "ENOENT") {
-      return null;
-    }
-    throw err2;
-  }
-}
-async function removePid(pidPath) {
-  try {
-    await (0, import_promises2.unlink)(pidPath);
-  } catch (err2) {
-    const code2 = err2.code;
-    if (code2 !== "ENOENT") {
-      throw err2;
-    }
-  }
-}
-async function ensureDaemonDirs(homeDir) {
-  const paths = resolveTaskPaths(homeDir);
-  ensureTaskDir(paths.jobsDir);
-  ensureTaskDir(paths.runDir);
-  ensureTaskDir(paths.logsDir);
-  ensureTaskDir(paths.commandsDir);
-  ensureTaskDir(paths.downloadsDir);
-  ensureTaskDir(paths.xmtpDir);
-  ensureTaskDir(paths.sqliteDir);
-  return paths;
-}
-async function ensureAiWorkspace(paths) {
-  const aiWorkingDir = paths.workspaceDir;
-  await (0, import_promises2.rm)(aiWorkingDir, { recursive: true, force: true });
-  ensureTaskDir(aiWorkingDir);
-  return aiWorkingDir;
-}
-async function waitForImmediateExit(child, timeoutMs) {
-  return await new Promise((resolve6) => {
-    let timer;
-    const onExit = () => {
-      clearTimeout(timer);
-      resolve6(true);
-    };
-    timer = setTimeout(() => {
-      child.off("exit", onExit);
-      resolve6(false);
-    }, timeoutMs);
-    child.once("exit", onExit);
-  });
-}
-async function getDaemonStatus(homeDir) {
-  const paths = resolveTaskPaths(homeDir);
-  const pid = await readPid(paths.pidPath);
-  const lock = await readDaemonLock(paths.daemonLockPath);
-  const lockPid = lock.metadata?.pid ?? null;
-  const lockReadyStateKnown = !!lock.metadata && (typeof lock.metadata.ready === "boolean" || typeof lock.metadata.readyAt === "string");
-  const lockReady = lockReadyStateKnown ? lock.metadata?.ready === true || typeof lock.metadata?.readyAt === "string" : true;
-  if (lock.running) {
-    return {
-      running: true,
-      pid: lockPid ?? pid,
-      stale: false,
-      capabilities: lock.metadata?.capabilities ?? [],
-      ready: lockReady,
-      readyAt: lock.metadata?.readyAt ?? null,
-      readyStateKnown: lockReadyStateKnown,
-      pidPath: paths.pidPath,
-      lockPath: paths.daemonLockPath,
-      lockPid,
-      lockStale: false
-    };
-  }
-  if (!pid) {
-    return {
-      running: false,
-      pid: null,
-      stale: lock.stale,
-      capabilities: [],
-      ready: false,
-      readyAt: null,
-      readyStateKnown: false,
-      pidPath: paths.pidPath,
-      lockPath: paths.daemonLockPath,
-      lockPid,
-      lockStale: lock.stale
-    };
-  }
-  const running = isProcessAlive(pid);
-  return {
-    running,
-    pid,
-    stale: !running || lock.stale,
-    capabilities: running ? lock.metadata?.capabilities ?? [] : [],
-    ready: running && !lockReadyStateKnown ? true : running && lockReady,
-    readyAt: running ? lock.metadata?.readyAt ?? null : null,
-    readyStateKnown: running && lockReadyStateKnown,
-    pidPath: paths.pidPath,
-    lockPath: paths.daemonLockPath,
-    lockPid,
-    lockStale: lock.stale
-  };
-}
-async function startDaemon(homeDir) {
-  const paths = await ensureDaemonDirs(homeDir);
-  const aiWorkingDir = await ensureAiWorkspace(paths);
-  const current = await getDaemonStatus(homeDir);
-  if (current.running) {
-    return {
-      ...current,
-      started: false,
-      logPath: paths.listenerLogPath
-    };
-  }
-  if (current.stale) {
-    await removePid(paths.pidPath);
-  }
-  const store = new SessionStore({ homeDir });
-  try {
-    store.setSetting("ai_working_dir", aiWorkingDir);
-    store.resetGlobalSession(SYSTEM_NOTIFICATION_SESSION_KEY);
-  } finally {
-    store.close();
-  }
-  const logFd = (0, import_node_fs3.openSync)(paths.listenerLogPath, "a");
-  const entry = process.env.OKX_AGENT_TASK_CLI_PATH || (0, import_node_path5.join)(__dirname, "cli.js");
-  const daemonCwd = (0, import_node_path5.join)(__dirname, "..");
-  const child = (0, import_node_child_process.spawn)(process.execPath, [entry, "run"], {
-    cwd: daemonCwd,
-    detached: true,
-    // win32: keep the detached daemon from flashing/holding a console window.
-    // Ignored on every non-win32 platform.
-    windowsHide: true,
-    env: {
-      ...process.env,
-      OKX_AGENT_TASK_HOME: paths.homeDir,
-      OKX_AGENT_TASK_DAEMON: "1",
-      OKX_A2A_AI_CWD: aiWorkingDir,
-      OKX_AGENT_TASK_AI_CWD: aiWorkingDir
-    },
-    stdio: ["ignore", logFd, logFd]
-  });
-  (0, import_node_fs3.closeSync)(logFd);
-  child.unref();
-  await (0, import_promises2.writeFile)(paths.pidPath, `${child.pid ?? ""}
-`, "utf8");
-  if (await waitForImmediateExit(child, START_EXIT_CHECK_MS)) {
-    const status = await getDaemonStatus(homeDir);
-    if (status.running && status.lockPid) {
-      await (0, import_promises2.writeFile)(paths.pidPath, `${status.lockPid}
-`, "utf8");
-    } else {
-      await removePid(paths.pidPath);
-    }
-    return {
-      ...status,
-      started: false,
-      logPath: paths.listenerLogPath
-    };
-  }
-  return {
-    running: true,
-    pid: child.pid ?? null,
-    stale: false,
-    capabilities: DAEMON_CAPABILITIES,
-    ready: false,
-    readyAt: null,
-    readyStateKnown: true,
-    pidPath: paths.pidPath,
-    lockPath: paths.daemonLockPath,
-    lockPid: child.pid ?? null,
-    lockStale: false,
-    started: true,
-    logPath: paths.listenerLogPath
-  };
-}
-async function waitForExit(pid, timeoutMs) {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (!isProcessAlive(pid)) {
-      return true;
-    }
-    await new Promise((resolve6) => setTimeout(resolve6, 100));
-  }
-  return !isProcessAlive(pid);
-}
-function signalProcess(pid, signal) {
-  try {
-    process.kill(pid, signal);
-    return true;
-  } catch (err2) {
-    const code2 = err2.code;
-    if (code2 === "ESRCH") {
-      return false;
-    }
-    throw err2;
-  }
-}
-async function stopDaemon(homeDir) {
-  const paths = resolveTaskPaths(homeDir);
-  const current = await getDaemonStatus(homeDir);
-  if (!current.pid) {
-    return { ...current, stopped: false };
-  }
-  if (!current.running) {
-    await removePid(paths.pidPath);
-    return {
-      running: false,
-      pid: current.pid,
-      stale: false,
-      capabilities: [],
-      ready: false,
-      readyAt: null,
-      readyStateKnown: false,
-      pidPath: paths.pidPath,
-      lockPath: paths.daemonLockPath,
-      lockPid: current.lockPid,
-      lockStale: current.lockStale,
-      stopped: false
-    };
-  }
-  const signalled = signalProcess(current.pid, "SIGTERM");
-  let forced = false;
-  let exited = !signalled || await waitForExit(current.pid, STOP_GRACE_MS);
-  if (!exited) {
-    forced = true;
-    const killed = signalProcess(current.pid, "SIGKILL");
-    exited = !killed || await waitForExit(current.pid, FORCE_KILL_GRACE_MS);
-  }
-  if (exited) {
-    await removePid(paths.pidPath);
-  }
-  return {
-    running: !exited,
-    pid: current.pid,
-    stale: false,
-    capabilities: exited ? [] : current.capabilities,
-    ready: !exited && current.ready,
-    readyAt: !exited ? current.readyAt : null,
-    readyStateKnown: !exited && current.readyStateKnown,
-    pidPath: paths.pidPath,
-    lockPath: paths.daemonLockPath,
-    lockPid: current.lockPid,
-    lockStale: current.lockStale,
-    stopped: exited,
-    forced
-  };
-}
-async function ensureDaemonReady(options = {}) {
-  const paths = resolveTaskPaths(options.homeDir);
-  const commandName = options.commandName ?? "command";
-  const timeoutMs = options.timeoutMs ?? readReadyTimeoutMs(options.env ?? process.env);
-  let status = await getDaemonStatus(options.homeDir);
-  let started = false;
-  let logPath = paths.listenerLogPath;
-  if (!status.running) {
-    options.stderr?.write(`[okx-a2a] ${commandName} requires the daemon; starting daemon...
-`);
-    const startResult = await startDaemon(options.homeDir);
-    started = startResult.started;
-    logPath = startResult.logPath;
-    status = startResult;
-    if (!status.running) {
-      throw new Error(
-        `${commandName} requires the daemon, but automatic daemon start failed. Check ${logPath} or run \`okx-a2a daemon restart\`.`
-      );
-    }
-    status = await waitForDaemonReady({
-      homeDir: options.homeDir,
-      timeoutMs,
-      requiredCapabilities: options.requiredCapabilities,
-      requireKnownReadyState: true,
-      logPath,
-      commandName
-    });
-    options.stderr?.write(`[okx-a2a] daemon ready pid=${status.pid ?? "(unknown)"} log=${logPath}
-`);
-  } else if (status.readyStateKnown && !status.ready) {
-    status = await waitForDaemonReady({
-      homeDir: options.homeDir,
-      timeoutMs,
-      requiredCapabilities: options.requiredCapabilities,
-      requireKnownReadyState: false,
-      logPath,
-      commandName
-    });
-  }
-  assertRequiredCapabilities(status, options.requiredCapabilities, commandName);
-  return {
-    ...status,
-    started,
-    logPath
-  };
-}
-async function waitForDaemonReady(options) {
-  const deadline = Date.now() + Math.max(0, options.timeoutMs);
-  let lastStatus = await getDaemonStatus(options.homeDir);
-  while (Date.now() <= deadline) {
-    const status = await getDaemonStatus(options.homeDir);
-    lastStatus = status;
-    if (!status.running) {
-      if (status.stale) {
-        throw new Error(
-          `${options.commandName} requires the daemon, but the daemon exited before becoming ready. Check ${options.logPath} or run \`okx-a2a daemon restart\`.`
-        );
-      }
-    } else if (isReadyForCommand(status, options.requiredCapabilities, options.requireKnownReadyState)) {
-      return status;
-    } else if (status.ready && findMissingCapabilities(status, options.requiredCapabilities).length > 0) {
-      assertRequiredCapabilities(status, options.requiredCapabilities, options.commandName);
-    }
-    await sleep(Math.min(READY_POLL_MS, Math.max(1, deadline - Date.now() + 1)));
-  }
-  const missing = findMissingCapabilities(lastStatus, options.requiredCapabilities);
-  const capabilitySuffix = missing.length > 0 ? ` missingCapabilities=${missing.join(",")}` : "";
-  throw new Error(
-    `${options.commandName} requires the daemon, but it did not become ready within ${options.timeoutMs}ms${capabilitySuffix}. Check ${options.logPath} or run \`okx-a2a daemon restart\`.`
-  );
-}
-function isReadyForCommand(status, requiredCapabilities, requireKnownReadyState = false) {
-  if (!status.running) {
-    return false;
-  }
-  if (requireKnownReadyState && !status.readyStateKnown) {
-    return false;
-  }
-  if (status.readyStateKnown && !status.ready) {
-    return false;
-  }
-  return findMissingCapabilities(status, requiredCapabilities).length === 0;
-}
-function assertRequiredCapabilities(status, requiredCapabilities, commandName) {
-  const missing = findMissingCapabilities(status, requiredCapabilities);
-  if (missing.length === 0) {
-    return;
-  }
-  throw new Error(
-    `${commandName} requires a daemon with ${missing.join(",")} support. Run \`okx-a2a daemon restart\` first.`
-  );
-}
-function findMissingCapabilities(status, requiredCapabilities) {
-  if (!requiredCapabilities || requiredCapabilities.length === 0) {
-    return [];
-  }
-  return requiredCapabilities.filter((capability) => !status.capabilities.includes(capability));
-}
-function readReadyTimeoutMs(env) {
-  const raw = env[DAEMON_READY_TIMEOUT_ENV]?.trim();
-  if (!raw) {
-    return DEFAULT_READY_TIMEOUT_MS;
-  }
-  const parsed = Number(raw);
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_READY_TIMEOUT_MS;
-}
-function sleep(ms) {
-  return new Promise((resolve6) => setTimeout(resolve6, ms));
-}
+init_daemon();
 
 // src/ai-runner.ts
 init_log();
@@ -73864,6 +73966,7 @@ var LogEvent = {
   ONCHAINOS_CLI_ERROR: "Onchainos CLI error",
   HEARTBEAT_FAILED: "Heartbeat failed",
   HEARTBEAT_SKIPPED: "Heartbeat skipped",
+  HEARTBEAT_GATEWAY_CHECK_FAILED: "Heartbeat gateway check failed",
   MESSAGE_PARSE_FAILED: "Message parse failed",
   MESSAGE_HANDLER_ERROR: "Message handler error",
   OFFLINE_REPLAY_FAILED: "Offline replay failed",
@@ -86127,10 +86230,6 @@ function compareTimestamp(a, b) {
 }
 
 // ../core/src/xmtp-sdk/onchainos/agent-status.ts
-var XMTP_COMMUNICABLE_AGENT_STATUSES = /* @__PURE__ */ new Set([
-  1 /* ACTIVE */,
-  2 /* USER_OFFLINE */
-]);
 var XMTP_BLOCKED_AGENT_STATUSES = /* @__PURE__ */ new Set([
   3 /* SECURITY_BLACKLISTED */,
   4 /* RISK_BLACKLISTED */,
@@ -86140,7 +86239,7 @@ function isAgentXmtpCommunicable(agent) {
   if (!agent) {
     return false;
   }
-  return XMTP_COMMUNICABLE_AGENT_STATUSES.has(Number(agent.status));
+  return true;
 }
 function isAgentXmtpBlocked(agent) {
   if (!agent) {
@@ -89305,7 +89404,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     client: {
       id: "gateway-client",
       displayName: "okx-a2a-node",
-      version: "0.1.4",
+      version: "0.1.6-beta-c3024b2b0b-260706164140",
       platform: "node",
       mode: "backend",
       instanceId
@@ -89316,7 +89415,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     commands: [],
     permissions: {},
     locale: Intl.DateTimeFormat().resolvedOptions().locale || "en-US",
-    userAgent: `okx-a2a-node/${"0.1.4"}`,
+    userAgent: `okx-a2a-node/${"0.1.6-beta-c3024b2b0b-260706164140"}`,
     auth: {
       ...config.token ? { token: config.token } : {},
       ...config.password ? { password: config.password } : {}
@@ -93780,13 +93879,14 @@ function userWatchEventDeliveredSentryExtra(event) {
 }
 
 // src/listener.ts
+init_daemon_lock();
 init_ai_provider();
 
 // ../core/src/sentry-config.ts
 var environment = process.env.SENTRY_ENV === "dev" ? "dev" : "prod";
 var SENTRY_CONFIG = {
   projectName: "okx/openclaw-okx-a2a-extension",
-  release: "0.1.4",
+  release: "0.1.6-beta-c3024b2b0b-260706164140",
   environment
 };
 
@@ -93826,20 +93926,31 @@ async function isGatewayAvailableForHeartbeat(options) {
   }
   return isHermesGatewayPluginEnabled({ env: options.env });
 }
-async function isHermesGatewayPluginEnabled(options = {}) {
+async function getHermesGatewayPluginStatus(options = {}) {
   const env = options.env ?? process.env;
-  if (options.requireGatewayRuntime && detectGatewayInvocation(env) !== "hermes") {
-    return false;
-  }
   const hermesHome = env.HERMES_HOME?.trim() || (0, import_node_path21.join)((0, import_node_os6.homedir)(), ".hermes");
-  if (!(0, import_node_fs15.existsSync)((0, import_node_path21.join)(hermesHome, "plugins", "platforms", "okx-a2a", "plugin.yaml"))) {
-    return false;
+  const pluginYamlPath = (0, import_node_path21.join)(hermesHome, "plugins", "platforms", "okx-a2a", "plugin.yaml");
+  if (!(0, import_node_fs15.existsSync)(pluginYamlPath)) {
+    return { enabled: false, reason: "plugin_yaml_missing", hermesHome, checkedPath: pluginYamlPath };
   }
+  const configPath = (0, import_node_path21.join)(hermesHome, "config.yaml");
+  let content3;
   try {
-    return hermesConfigEnablesOkxA2a(await (0, import_promises6.readFile)((0, import_node_path21.join)(hermesHome, "config.yaml"), "utf8"));
+    content3 = await (0, import_promises6.readFile)(configPath, "utf8");
   } catch {
+    return { enabled: false, reason: "config_read_error", hermesHome, checkedPath: configPath };
+  }
+  if (!hermesConfigEnablesOkxA2a(content3)) {
+    return { enabled: false, reason: "config_disabled", hermesHome, checkedPath: configPath };
+  }
+  return { enabled: true, hermesHome, checkedPath: pluginYamlPath };
+}
+async function isHermesGatewayPluginEnabled(options = {}) {
+  const env = options.env ?? process.env;
+  if (options.requireGatewayRuntime && detectGatewayInvocation(env) !== "hermes") {
     return false;
   }
+  return (await getHermesGatewayPluginStatus({ env })).enabled;
 }
 function hermesConfigEnablesOkxA2a(content3) {
   let inPlugins = false;
@@ -94013,12 +94124,12 @@ async function runListenerWithLock(options, paths) {
       }));
     }
   });
-  service.setPluginVersion("0.1.4");
+  service.setPluginVersion("0.1.6-beta-c3024b2b0b-260706164140");
   await service.init();
   const pluginVersionStatus = service.pluginVersionStatus;
   if (pluginVersionStatus.unavailable) {
     throw new Error(
-      `@okxweb3/a2a-node v${"0.1.4"} is below the required minimum v${pluginVersionStatus.minVersion}`
+      `@okxweb3/a2a-node v${"0.1.6-beta-c3024b2b0b-260706164140"} is below the required minimum v${pluginVersionStatus.minVersion}`
     );
   }
   const systemConfig = service.getSystemConfig();
@@ -94036,7 +94147,7 @@ async function runListenerWithLock(options, paths) {
       onchainosAgentId: "*",
       reason: "system-config missing sentryDsn",
       pluginId: "@okxweb3/a2a-node",
-      pluginVersion: "0.1.4"
+      pluginVersion: "0.1.6-beta-c3024b2b0b-260706164140"
     });
   }
   logWithTimestamp(
@@ -94076,7 +94187,28 @@ async function runListenerWithLock(options, paths) {
       const hasActiveAgents = service.getClients().size > 0;
       let shouldHeartbeat = hasActiveAgents;
       const heartbeatProvider = resolveConfiguredAiProvider({ store: sessionStore }) ?? detectGatewayInvocation();
-      if (hasActiveAgents) {
+      if (hasActiveAgents && heartbeatProvider === "hermes") {
+        const hermesStatus = await getHermesGatewayPluginStatus();
+        if (!hermesStatus.enabled) {
+          logWithTimestamp(
+            `[okx-agent-task] provider=hermes gateway check failed (${hermesStatus.reason}), sending heartbeat anyway`
+          );
+          logger.error(
+            LogEvent.HEARTBEAT_GATEWAY_CHECK_FAILED,
+            new Error(`heartbeat gateway check failed: provider=hermes reason=${hermesStatus.reason}`),
+            {
+              component: "node_listener",
+              stage: "sync_tick",
+              reason: hermesStatus.reason ?? "unknown",
+              provider: "hermes",
+              hermesHome: hermesStatus.hermesHome,
+              checkedPath: hermesStatus.checkedPath,
+              chainIndex: ONCHAINOS_CHAIN_INDEX,
+              communicationClass: "gateway_or_plugin"
+            }
+          );
+        }
+      } else if (hasActiveAgents) {
         const gatewayAvailable = await isGatewayAvailableForHeartbeat({
           provider: heartbeatProvider
         });
@@ -94398,7 +94530,7 @@ init_update_cli();
 init_win_spawn();
 
 // src/log-tail.ts
-var import_node_fs17 = require("node:fs");
+var import_node_fs18 = require("node:fs");
 var import_promises8 = require("node:fs/promises");
 var import_node_string_decoder = require("node:string_decoder");
 init_win_spawn();
@@ -94522,7 +94654,7 @@ async function followFile(filePath, onData, options = {}) {
       void check();
     }, pollIntervalMs);
     try {
-      watcher = (0, import_node_fs17.watch)(filePath, () => {
+      watcher = (0, import_node_fs18.watch)(filePath, () => {
         void check();
       });
       watcher.on("error", (error) => {
@@ -94588,8 +94720,6 @@ init_ai_provider();
 init_update_cli();
 
 // src/doctor-cli.ts
-var import_node_fs21 = require("node:fs");
-var import_node_os10 = require("node:os");
 var import_node_path26 = require("node:path");
 init_log();
 init_win_compat();
@@ -94597,18 +94727,18 @@ init_ai_command();
 init_ai_provider();
 
 // src/autostart.ts
-var import_node_child_process7 = require("node:child_process");
-var import_node_fs19 = require("node:fs");
+var import_node_child_process8 = require("node:child_process");
+var import_node_fs20 = require("node:fs");
 var import_promises10 = require("node:fs/promises");
-var import_node_os8 = require("node:os");
-var import_node_path24 = require("node:path");
+var import_node_os9 = require("node:os");
+var import_node_path25 = require("node:path");
 var import_node_util2 = require("node:util");
 
 // src/autostart-windows.ts
-var import_node_child_process6 = require("node:child_process");
-var import_node_fs18 = require("node:fs");
+var import_node_child_process7 = require("node:child_process");
+var import_node_fs19 = require("node:fs");
 var import_promises9 = require("node:fs/promises");
-var import_node_path23 = require("node:path");
+var import_node_path24 = require("node:path");
 init_log();
 init_paths();
 init_win_spawn();
@@ -94619,10 +94749,10 @@ var SCHTASKS_TIMEOUT_MS = 15e3;
 var LOG_SNIPPET_LIMIT = 500;
 function resolveWindowsAutostartPaths(homeDir) {
   const resolvedHome = homeDir ?? resolveTaskPaths().homeDir;
-  const autostartDir = (0, import_node_path23.join)(resolvedHome, "autostart");
+  const autostartDir = (0, import_node_path24.join)(resolvedHome, "autostart");
   return {
     autostartDir,
-    vbsPath: (0, import_node_path23.join)(autostartDir, VBS_FILE_NAME)
+    vbsPath: (0, import_node_path24.join)(autostartDir, VBS_FILE_NAME)
   };
 }
 function escapeVbsString(value) {
@@ -94654,7 +94784,7 @@ function buildAutostartVbs(options) {
 `;
 }
 function isWindowsElevated() {
-  const result = (0, import_node_child_process6.spawnSync)("net", ["session"], {
+  const result = (0, import_node_child_process7.spawnSync)("net", ["session"], {
     windowsHide: true,
     encoding: "utf8",
     timeout: 5e3,
@@ -94699,10 +94829,10 @@ function resolveWindowsCliPath() {
     logWinCompat(`${WIN_COMPAT_LOG_PREFIX} autostart: process.argv[1] is empty, cannot resolve okx-a2a CLI path`);
     throw new Error("Unable to resolve current okx-a2a CLI path");
   }
-  return (0, import_node_path23.resolve)(entry);
+  return (0, import_node_path24.resolve)(entry);
 }
 function runSchtasks(operation, args) {
-  const result = (0, import_node_child_process6.spawnSync)(SCHTASKS_BIN, args, {
+  const result = (0, import_node_child_process7.spawnSync)(SCHTASKS_BIN, args, {
     windowsHide: true,
     encoding: "utf8",
     timeout: SCHTASKS_TIMEOUT_MS
@@ -94740,10 +94870,10 @@ async function installWindowsAutostart() {
   const execPath = process.execPath;
   const cliPath = resolveWindowsCliPath();
   const pathValue = process.env.PATH?.trim() || "";
-  if (!(0, import_node_fs18.existsSync)(execPath)) {
+  if (!(0, import_node_fs19.existsSync)(execPath)) {
     throw new Error(`autostart: node executable not found at ${execPath}`);
   }
-  if (!(0, import_node_fs18.existsSync)(cliPath)) {
+  if (!(0, import_node_fs19.existsSync)(cliPath)) {
     throw new Error(`autostart: okx-a2a CLI entry not found at ${cliPath}`);
   }
   await (0, import_promises9.mkdir)(paths.autostartDir, { recursive: true });
@@ -94778,22 +94908,22 @@ function isWindowsAutostartInstalled() {
 
 // src/autostart.ts
 init_paths();
-var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process7.execFile);
+var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process8.execFile);
 var SERVICE_NAME = "okx-a2a.service";
 var LAUNCHD_LABEL = "com.okx.a2a";
 var LAUNCHD_PLIST_NAME = `${LAUNCHD_LABEL}.plist`;
-function resolveSystemdAutostartPaths(home = (0, import_node_os8.homedir)()) {
-  const serviceDir = (0, import_node_path24.join)(home, ".config", "systemd", "user");
+function resolveSystemdAutostartPaths(home = (0, import_node_os9.homedir)()) {
+  const serviceDir = (0, import_node_path25.join)(home, ".config", "systemd", "user");
   return {
     serviceDir,
-    servicePath: (0, import_node_path24.join)(serviceDir, SERVICE_NAME)
+    servicePath: (0, import_node_path25.join)(serviceDir, SERVICE_NAME)
   };
 }
-function resolveLaunchdAutostartPaths(home = (0, import_node_os8.homedir)()) {
-  const agentDir = (0, import_node_path24.join)(home, "Library", "LaunchAgents");
+function resolveLaunchdAutostartPaths(home = (0, import_node_os9.homedir)()) {
+  const agentDir = (0, import_node_path25.join)(home, "Library", "LaunchAgents");
   return {
     agentDir,
-    plistPath: (0, import_node_path24.join)(agentDir, LAUNCHD_PLIST_NAME)
+    plistPath: (0, import_node_path25.join)(agentDir, LAUNCHD_PLIST_NAME)
   };
 }
 function quoteSystemdArg(value) {
@@ -94807,7 +94937,7 @@ function resolveCliPath() {
   if (!entry) {
     throw new Error("Unable to resolve current okx-a2a CLI path");
   }
-  return (0, import_node_path24.resolve)(entry);
+  return (0, import_node_path25.resolve)(entry);
 }
 function buildSystemdUserService() {
   const taskHome2 = resolveTaskHome();
@@ -94942,10 +95072,10 @@ async function installAutostart() {
 }
 function isAutostartInstalled() {
   if (process.platform === "linux") {
-    return (0, import_node_fs19.existsSync)(resolveSystemdAutostartPaths().servicePath);
+    return (0, import_node_fs20.existsSync)(resolveSystemdAutostartPaths().servicePath);
   }
   if (process.platform === "darwin") {
-    return (0, import_node_fs19.existsSync)(resolveLaunchdAutostartPaths().plistPath);
+    return (0, import_node_fs20.existsSync)(resolveLaunchdAutostartPaths().plistPath);
   }
   if (process.platform === "win32") {
     return isWindowsAutostartInstalled();
@@ -94953,7 +95083,11 @@ function isAutostartInstalled() {
   return false;
 }
 
+// src/doctor-cli.ts
+init_daemon();
+
 // src/daemon-ops.ts
+init_daemon();
 async function refreshAgentsAndWait(timeoutMs = 6e4) {
   const status = await getDaemonStatus();
   if (!status.running) {
@@ -95010,7 +95144,9 @@ async function dispatchRuntimeSwitchUserMessage(store, result) {
 // src/doctor-cli.ts
 init_session_store();
 init_update_cli();
+init_win_native_launcher();
 init_win_spawn();
+init_win_native_launcher();
 var DOCTOR_MIN_NODE_VERSION = "22.14.0";
 var DOCTOR_DAEMON_READY_TIMEOUT_MS = 2e4;
 var NODE_PACKAGE_SPEC = "@okxweb3/a2a-node";
@@ -95220,22 +95356,6 @@ var cliVersionChecker = {
     return `npm install completed; installed version could not be verified from npm metadata (was ${before}) \u2014 daemon will be restarted to be safe`;
   }
 };
-function findWindowsNativeOkxA2aExe(pathValue, appData, userProfile, fileExists2 = import_node_fs21.existsSync) {
-  const dirs = pathValue.split(";").map((d) => d.trim()).filter(Boolean);
-  if (appData) {
-    dirs.push((0, import_node_path26.join)(appData, "npm"));
-  }
-  if (userProfile) {
-    dirs.push((0, import_node_path26.join)(userProfile, ".local", "bin"));
-  }
-  for (const dir of dirs) {
-    const candidate = (0, import_node_path26.join)(dir, "okx-a2a.exe");
-    if (fileExists2(candidate)) {
-      return candidate;
-    }
-  }
-  return null;
-}
 var windowsNativeLauncherChecker = {
   id: "windows_native_launcher",
   title: "Windows native launcher (okx-a2a.exe)",
@@ -95272,27 +95392,13 @@ var windowsNativeLauncherChecker = {
     };
   },
   applyFix: async (ctx) => {
-    const targetDir = ctx.env.APPDATA ? (0, import_node_path26.join)(ctx.env.APPDATA, "npm") : (0, import_node_path26.join)(ctx.env.USERPROFILE ?? (0, import_node_os10.homedir)(), ".local", "bin");
-    const cliPath = resolveRunningCliPath();
-    const { installWindowsNativeLauncher: installWindowsNativeLauncher2 } = await Promise.resolve().then(() => (init_win_native_launcher(), win_native_launcher_exports));
-    const result = await installWindowsNativeLauncher2({ cliPath, targetDir });
-    return `built native launcher ${result.exePath} (SEA over ${result.nodeExe}, entry ${result.cliPath})`;
+    const result = await ensureWindowsNativeLauncher({ env: ctx.env, platform: "win32" });
+    if (!result) {
+      throw new Error("native launcher fix is only applicable on Windows");
+    }
+    return result.installed ? `built native launcher ${result.exePath} (SEA over your node.exe)` : `native launcher already present at ${result.exePath}`;
   }
 };
-function resolveRunningCliPath() {
-  const fromArgv = process.argv[1];
-  if (fromArgv && /(?:^|[\\/])cli\.js$/.test(fromArgv) && (0, import_node_fs21.existsSync)(fromArgv)) {
-    return fromArgv;
-  }
-  const beside = (0, import_node_path26.join)(__dirname, "cli.js");
-  if ((0, import_node_fs21.existsSync)(beside)) {
-    return beside;
-  }
-  if (fromArgv) {
-    return fromArgv;
-  }
-  throw new Error("could not resolve the running okx-a2a CLI path for the native launcher");
-}
 var providerBindingChecker = {
   id: "provider_binding",
   title: "Default AI provider binding",
@@ -95312,13 +95418,18 @@ var providerBindingChecker = {
           data: { bound, detectedRuntime: runtime }
         };
       }
+      const autoFixCanSucceed = !!expected;
       return {
         id: "provider_binding",
         title: "Default AI provider binding",
         status: "fail",
         severity: "required",
         detail: bound ? `default provider ${bound} does not match the detected runtime ${runtime}` : "no default AI provider is bound",
-        fix: { kind: "auto", description: "Run the in-memory runtime switch (equivalent of `okx-a2a switch-runtime`)." },
+        fix: autoFixCanSucceed ? { kind: "auto", description: "Run the in-memory runtime switch (equivalent of `okx-a2a switch-runtime`)." } : {
+          kind: "manual",
+          description: "No AI runtime detected and no default provider is bound. Run doctor from your AI environment (OpenClaw / Codex / Claude / Hermes), or bind one manually first.",
+          command: "okx-a2a ai-provider set --provider <codex|claude|hermes|openclaw>"
+        },
         data: { bound, detectedRuntime: runtime }
       };
     } finally {
@@ -95330,7 +95441,7 @@ var providerBindingChecker = {
     try {
       const result = await performRuntimeSwitch(store);
       if (!result.ok) {
-        throw new Error(result.message || "runtime switch failed");
+        throw new Error(result.userMessage || result.message || "runtime switch failed");
       }
       return `runtime switch: provider=${result.provider} ${result.changed ? "(switched)" : "(already current)"}`;
     } finally {
@@ -95391,7 +95502,14 @@ var providerCliChecker = {
       status: "fail",
       severity: "required",
       detail: `${provider} CLI at ${resolved} is not logged in (${auth.reason})`,
-      fix: {
+      // Logging in needs a human (device/browser auth). In --non-interactive
+      // mode never launch it — degrade to a manual instruction so unattended
+      // callers (install scripts) cannot hang waiting on stdin.
+      fix: ctx.nonInteractive ? {
+        kind: "manual",
+        description: "Log in with the command below, then re-run okx-a2a doctor.",
+        command: loginCommand
+      } : {
         kind: "auto",
         description: "--fix launches the interactive login flow (same as setup: device/browser auth, waits for completion). You can also log in yourself with the command below, then re-run okx-a2a doctor.",
         command: loginCommand
@@ -95430,6 +95548,11 @@ var providerCliChecker = {
     }
     const auth = provider === "codex" ? await checkCodexCliAuthStatus(resolved) : await checkClaudeCliAuthStatus(resolved);
     if (!auth.ok) {
+      if (ctx.nonInteractive) {
+        throw new Error(
+          `${provider} CLI is installed but not logged in; non-interactive mode skips the login flow \u2014 log in yourself and re-run okx-a2a doctor`
+        );
+      }
       errorWithTimestamp(`[doctor] launching ${provider} CLI login (interactive; waiting for completion)`);
       const login = await runProviderLoginInteractive(provider, resolved);
       if (!login.ok) {
@@ -95453,13 +95576,14 @@ var gatewayPluginChecker = {
       return null;
     }
     const installed = await isGatewayPluginInstalled(ctx.target);
+    const hermesPathSuffix = ctx.target === "hermes" ? ` (checked ${resolveHermesPluginYamlPath()})` : "";
     if (installed) {
       return {
         id: "gateway_plugin",
         title: "Gateway plugin installed",
         status: "pass",
         severity: "required",
-        detail: `${ctx.target} okx-a2a plugin is installed`
+        detail: `${ctx.target} okx-a2a plugin is installed${hermesPathSuffix}`
       };
     }
     const hermesOnWindows = ctx.target === "hermes" && ctx.platform === "win32";
@@ -95468,7 +95592,7 @@ var gatewayPluginChecker = {
       title: "Gateway plugin installed",
       status: "fail",
       severity: "required",
-      detail: `${ctx.target} okx-a2a plugin is not installed`,
+      detail: `${ctx.target} okx-a2a plugin is not installed${hermesPathSuffix}`,
       fix: hermesOnWindows ? {
         kind: "manual",
         description: "Hermes plugin installation requires bash and is not supported on Windows. Use WSL or run setup on macOS/Linux."
@@ -95497,13 +95621,14 @@ var gatewayConfigChecker = {
       return null;
     }
     const drift = ctx.target === "openclaw" ? await ensureOpenClawOkxA2aPluginConfig({ dryRun: true }) : await ensureHermesOkxA2aPluginConfig(void 0, { dryRun: true });
+    const hermesPathSuffix = ctx.target === "hermes" ? ` (checked ${resolveHermesConfigPath()})` : "";
     if (!drift) {
       return {
         id: "gateway_config",
         title: "Gateway plugin config",
         status: "pass",
         severity: "required",
-        detail: `${ctx.target} okx-a2a plugin config is normalized`
+        detail: `${ctx.target} okx-a2a plugin config is normalized${hermesPathSuffix}`
       };
     }
     return {
@@ -95511,7 +95636,7 @@ var gatewayConfigChecker = {
       title: "Gateway plugin config",
       status: "fail",
       severity: "required",
-      detail: `${ctx.target} okx-a2a plugin config needs normalization`,
+      detail: `${ctx.target} okx-a2a plugin config needs normalization${hermesPathSuffix}`,
       fix: { kind: "auto", description: `Apply the ${ctx.target} config normalization in-process.` }
     };
   },
@@ -95759,8 +95884,9 @@ async function runDoctor(options = {}) {
     platform: options.platform ?? process.platform,
     env: options.env ?? process.env,
     target: options.target ?? resolveDoctorTarget(options.env ?? process.env),
-    cliVersion: options.cliVersion ?? (true ? "0.1.4" : "0.0.0"),
+    cliVersion: options.cliVersion ?? (true ? "0.1.6-beta-c3024b2b0b-260706164140" : "0.0.0"),
     fixMode: options.fix === true,
+    nonInteractive: options.nonInteractive === true,
     packageChanged: false
   };
   const checkers = options.checkers ?? CHECKERS;
@@ -95907,6 +96033,7 @@ function formatDoctorReportForHumans(report) {
 async function handleDoctorCommand(args) {
   const json = args.includes("--json");
   const fix = args.includes("--fix");
+  const nonInteractive = args.includes("--non-interactive");
   const targetIndex = args.indexOf("--target");
   const rawTarget = targetIndex >= 0 ? args[targetIndex + 1] : void 0;
   if (targetIndex >= 0 && (rawTarget === void 0 || rawTarget.startsWith("--"))) {
@@ -95930,7 +96057,7 @@ async function handleDoctorCommand(args) {
   };
   let report;
   try {
-    report = await runDoctor({ fix, ...rawTarget ? { target: rawTarget } : {} });
+    report = await runDoctor({ fix, nonInteractive, ...rawTarget ? { target: rawTarget } : {} });
   } catch (error) {
     restoreStdout();
     const message = error instanceof Error ? error.message : String(error);
@@ -96036,12 +96163,14 @@ init_win_native_launcher();
   ensureDaemonReady,
   ensureDefaultAiProvider,
   ensureOpenClawOkxA2aPluginConfig,
+  ensureWindowsNativeLauncher,
   extractAiSessionId,
   extractXmtpSentAtMs,
   findWindowsNativeOkxA2aExe,
   followFile,
   formatDoctorReportForHumans,
   getDaemonStatus,
+  getHermesGatewayPluginStatus,
   handleDoctorCommand,
   handleXmtpSendCommand,
   hasAiRuntimeMarker,