@okxweb3/a2a-node 0.2.10-beta-1a0d85b27f-260828092722 → 0.2.10

package/dist/index.js

@@ -32437,7 +32437,7 @@ var init_sentry_config = __esm({
     environment = process.env.SENTRY_ENV === "dev" ? "dev" : "prod";
     SENTRY_CONFIG = {
       projectName: "okx/openclaw-okx-a2a-extension",
-      release: "0.2.10-beta-1a0d85b27f-260828092722",
+      release: "0.2.10",
       environment,
       runtimeContainer: normalizeRuntimeContainer(process.env.OKX_A2A_RUNTIME_CONTAINER)
     };
@@ -33378,7 +33378,7 @@ async function getCurrentNodeCliVersion() {
   return await getGlobalNpmPackageVersion(UPDATE_PACKAGES.node) ?? getBundledNodeCliVersion();
 }
 function getBundledNodeCliVersion() {
-  return true ? "0.2.10-beta-1a0d85b27f-260828092722" : null;
+  return true ? "0.2.10" : null;
 }
 function readConfiguredAiProvider() {
   const explicit = process.env.OKX_A2A_AI_PROVIDER || process.env.OKX_AGENT_TASK_AI_CLI;
@@ -33588,7 +33588,7 @@ async function updateHermes(release, options) {
   }
 }
 async function installGatewayPluginForDoctor(target) {
-  const release = isPrereleaseVersion("0.2.10-beta-1a0d85b27f-260828092722") ? "beta" : "latest";
+  const release = isPrereleaseVersion("0.2.10") ? "beta" : "latest";
   const insideTargetGateway = detectGatewayInvocation() === target;
   const options = {
     restart: !insideTargetGateway,
@@ -44420,6 +44420,7 @@ __export(index_exports, {
   getA2ACapabilities: () => getA2ACapabilities,
   getDaemonStatus: () => getDaemonStatus,
   getHermesGatewayPluginStatus: () => getHermesGatewayPluginStatus,
+  getResolvedOnchainosBinForTests: () => getResolvedOnchainosBinForTests,
   getRuntimeMetadata: () => getRuntimeMetadata,
   getSessionBusyTracker: () => getSessionBusyTracker,
   handleCapabilitiesCommand: () => handleCapabilitiesCommand,
@@ -44435,6 +44436,7 @@ __export(index_exports, {
   installWindowsNativeLauncher: () => installWindowsNativeLauncher,
   installedAutostartHasCurrentConfiguration: () => installedAutostartHasCurrentConfiguration,
   installedAutostartHasCurrentRestartPolicy: () => installedAutostartHasCurrentRestartPolicy,
+  invalidateResolvedOnchainosBinForTests: () => invalidateResolvedOnchainosBinForTests,
   isAutostartManagerUnavailableError: () => isAutostartManagerUnavailableError,
   isDefaultTaskHome: () => isDefaultTaskHome,
   isGatewayAvailableForHeartbeat: () => isGatewayAvailableForHeartbeat,
@@ -44515,6 +44517,7 @@ __export(index_exports, {
   resolveNpmCmdShimScript: () => resolveNpmCmdShimScript,
   resolveOfflineReplayCapabilityMarker: () => resolveOfflineReplayCapabilityMarker,
   resolveOfflineReplayIntervalSec: () => resolveOfflineReplayIntervalSec,
+  resolveOnchainosBinForTests: () => resolveOnchainosBinForTests,
   resolveOpenClawGatewayConfig: () => resolveOpenClawGatewayConfig,
   resolveOpenClawGatewayRoute: () => resolveOpenClawGatewayRoute,
   resolveOpenClawGatewayRoutes: () => resolveOpenClawGatewayRoutes,
@@ -46015,15 +46018,15 @@ var AiRunner = class {
       output: fullOutputForClassification,
       timedOut
     });
+    const runCompletedSuccessfully = provider === "codex" && !timedOut && exitCode === 0 && closeResult.signal === null && aiSessionId !== null && toolFailures.turnCompleted();
     const syntheticToolFailure = synthesizeCodexProsePermissionFailure({
       provider,
       existingFailures: toolFailures.failures,
       errorType: fullOutputErrorType,
-      output: fullOutputForClassification,
+      output: runCompletedSuccessfully ? stdoutFull : fullOutputForClassification,
       exitCode
     });
     const detectedToolFailures = syntheticToolFailure ? [...toolFailures.failures, syntheticToolFailure] : toolFailures.failures;
-    const runCompletedSuccessfully = provider === "codex" && !timedOut && exitCode === 0 && closeResult.signal === null && aiSessionId !== null && toolFailures.turnCompleted();
     const reportableToolFailures = selectReportableAiToolFailures({
       provider,
       failures: detectedToolFailures,
@@ -59157,14 +59160,40 @@ init_runtime_metadata();
 init_win_compat();
 var execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process6.execFile);
 var resolvedBin = null;
+var resolvedForEnvBin = null;
+var resolverRevision = 0;
 var versionProbeInFlight = null;
+var posixDiscoveryFlights = /* @__PURE__ */ new Map();
 var REDACTED_VALUE_FLAGS = /* @__PURE__ */ new Set(["--message"]);
+var COMMAND_UNAVAILABLE_CODES = /* @__PURE__ */ new Set(["EACCES", "ENOENT", "ENOTDIR"]);
 var ONCHAINOS_VERSION_PROBE_TIMEOUT_MS = 5e3;
 var ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS = 5e3;
 function resetResolvedOnchainosBinForTests() {
   resolvedBin = null;
+  resolvedForEnvBin = null;
+  resolverRevision += 1;
+  posixDiscoveryFlights.clear();
   versionProbeInFlight = null;
 }
+function getResolvedOnchainosBinForTests() {
+  return {
+    bin: resolvedBin,
+    envBin: resolvedForEnvBin,
+    revision: resolverRevision,
+    discoveryFlightCount: posixDiscoveryFlights.size,
+    discoveryJoinCount: [...posixDiscoveryFlights.values()].reduce(
+      (total, flight) => total + flight.joinCount,
+      0
+    )
+  };
+}
+async function resolveOnchainosBinForTests(timeoutMs = ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS, excludedBin) {
+  const excludedAttempt = excludedBin ? { bin: excludedBin, revision: resolverRevision } : void 0;
+  return (await resolveBinSelection(timeoutMs, excludedAttempt)).bin;
+}
+function invalidateResolvedOnchainosBinForTests(bin, revision) {
+  return invalidateResolvedBin(bin, "test requested invalidation", revision);
+}
 async function refreshOnchainosVersionMetadata(options = {}) {
   const now = options.now ?? Date.now;
   const current = getRuntimeMetadata();
@@ -59173,13 +59202,11 @@ async function refreshOnchainosVersionMetadata(options = {}) {
   if (versionProbeInFlight) {
     return versionProbeInFlight;
   }
-  versionProbeInFlight = (async () => {
+  const probe = (async () => {
     const observedAtMs = now();
     try {
-      const bin = await resolve6(
-        options.resolveTimeoutMs ?? ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS
-      );
-      const output = options.runVersionCommand ? await options.runVersionCommand(bin) : await runVersionCommand(bin);
+      const resolveTimeoutMs = options.resolveTimeoutMs ?? ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS;
+      const output = options.runVersionCommand ? await options.runVersionCommand(await resolve6(resolveTimeoutMs)) : await runVersionCommand(resolveTimeoutMs);
       const version3 = parseOnchainosVersionOutput(output);
       if (version3 === UNKNOWN_RUNTIME_METADATA) {
         throw new Error("OnchainOS version output did not contain a semantic version");
@@ -59230,68 +59257,311 @@ async function refreshOnchainosVersionMetadata(options = {}) {
         probeStatus: "failed",
         changed: false
       };
-    } finally {
-      versionProbeInFlight = null;
     }
   })();
-  return versionProbeInFlight;
+  versionProbeInFlight = probe;
+  const clearProbe = () => {
+    if (versionProbeInFlight === probe) {
+      versionProbeInFlight = null;
+    }
+  };
+  void probe.then(clearProbe, clearProbe);
+  return probe;
+}
+async function runVersionCommand(resolveTimeoutMs) {
+  let excludedAttempt;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const selection = await resolveBinSelection(
+      resolveTimeoutMs,
+      excludedAttempt
+    );
+    const { bin } = selection;
+    const invocation = toWindowsInvocation(bin, ["--version"]);
+    try {
+      const result = await execFileAsync2(invocation.command, invocation.args, {
+        windowsHide: true,
+        windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+        timeout: ONCHAINOS_VERSION_PROBE_TIMEOUT_MS
+      });
+      rememberSuccessfulBareBin(bin);
+      return [result.stdout, result.stderr].filter(Boolean).join("\n");
+    } catch (err) {
+      if (attempt === 0 && isCommandUnavailableError(err)) {
+        invalidateResolvedBin(
+          bin,
+          "version probe could not launch the cached binary",
+          selection.revision
+        );
+        if (shouldRetryUnavailableBin(bin)) {
+          excludedAttempt = selection;
+          continue;
+        }
+      }
+      throw err;
+    }
+  }
+  throw new Error("OnchainOS version command retry exhausted");
 }
-async function runVersionCommand(bin) {
-  const invocation = toWindowsInvocation(bin, ["--version"]);
-  const result = await execFileAsync2(invocation.command, invocation.args, {
-    windowsHide: true,
-    windowsVerbatimArguments: invocation.windowsVerbatimArguments,
-    timeout: ONCHAINOS_VERSION_PROBE_TIMEOUT_MS
+function configuredEnvBin() {
+  return process.env.ONCHAINOS_BIN?.trim() || null;
+}
+function isPathLikeCommand(command) {
+  return command.includes("/") || command.includes("\\");
+}
+function isResolvedBinUsable(bin) {
+  if (!isPathLikeCommand(bin)) {
+    return true;
+  }
+  return process.platform === "win32" ? (0, import_node_fs16.existsSync)(bin) : isExecutable2(bin);
+}
+function resolvePosixBareCommand(command, pathValue) {
+  for (const dir of pathValue.split(":")) {
+    const candidate = (0, import_node_path22.join)(dir || ".", command);
+    if (isExecutable2(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveConfiguredBin(bin) {
+  if (isPathLikeCommand(bin)) {
+    return isResolvedBinUsable(bin) ? bin : null;
+  }
+  if (process.platform === "win32") {
+    return resolveWin32BareCommandCandidate(
+      bin,
+      process.env.PATH ?? process.env.Path ?? "",
+      process.env.PATHEXT ?? process.env.PathExt ?? ".COM;.EXE;.BAT;.CMD",
+      process.env.USERPROFILE
+    );
+  }
+  return resolvePosixBareCommand(bin, process.env.PATH ?? "");
+}
+function cacheResolvedBin(bin, envBin) {
+  resolvedBin = bin;
+  resolvedForEnvBin = envBin;
+  resolverRevision += 1;
+  return { bin, revision: resolverRevision };
+}
+function rememberSuccessfulBareBin(bin) {
+  if (process.platform !== "win32" && resolvedBin === null && !isPathLikeCommand(bin)) {
+    cacheResolvedBin(bin, configuredEnvBin());
+  }
+}
+function invalidateResolvedBin(bin, reason, expectedRevision) {
+  if (resolvedBin !== bin || expectedRevision !== void 0 && resolverRevision !== expectedRevision) {
+    return false;
+  }
+  logWithTimestamp(
+    `[onchainos] invalidating cached binary ${bin}: ${reason}; rediscovering`
+  );
+  resolvedBin = null;
+  resolvedForEnvBin = null;
+  resolverRevision += 1;
+  return true;
+}
+function isCommandUnavailableError(err) {
+  const code = err?.code;
+  return typeof code === "string" && COMMAND_UNAVAILABLE_CODES.has(code);
+}
+function shouldRetryUnavailableBin(bin) {
+  if (!isPathLikeCommand(bin)) {
+    return false;
+  }
+  return true;
+}
+function currentPosixDiscoveryContextKey() {
+  return JSON.stringify({
+    onchainosBin: configuredEnvBin(),
+    shell: process.env.SHELL || "/bin/bash",
+    path: process.env.PATH ?? "",
+    home: process.env.HOME ?? "",
+    zDotDir: process.env.ZDOTDIR ?? "",
+    bashEnv: process.env.BASH_ENV ?? "",
+    env: process.env.ENV ?? "",
+    cwd: process.cwd()
   });
-  return [result.stdout, result.stderr].filter(Boolean).join("\n");
 }
-async function resolve6(timeoutMs) {
+function createPosixDiscoverySnapshot(envBin, excludedBin, timeoutMs) {
+  const revision = resolverRevision;
+  const contextKey = currentPosixDiscoveryContextKey();
+  const excluded = excludedBin ?? null;
+  return {
+    revision,
+    contextKey,
+    // Exclusions represent binaries that failed to launch, so they are safe
+    // to union across callers sharing this resolver generation. Keeping them
+    // out of the key lets a late request join an ongoing recovery discovery.
+    flightKey: JSON.stringify([revision, contextKey, timeoutMs]),
+    envBin,
+    excludedBin: excluded,
+    shell: process.env.SHELL || "/bin/bash",
+    childEnv: { ...process.env }
+  };
+}
+function isPosixDiscoverySnapshotCurrent(snapshot) {
+  return resolverRevision === snapshot.revision && currentPosixDiscoveryContextKey() === snapshot.contextKey;
+}
+function getOrCreatePosixDiscovery(snapshot, remainingTimeoutMs) {
+  const existing = posixDiscoveryFlights.get(snapshot.flightKey);
+  if (existing) {
+    if (snapshot.excludedBin) {
+      existing.excludedBins.add(snapshot.excludedBin);
+    }
+    existing.joinCount += 1;
+    logWithTimestamp("[onchainos] joining in-flight binary discovery");
+    return existing;
+  }
+  const excludedBins = /* @__PURE__ */ new Set();
+  if (snapshot.excludedBin) {
+    excludedBins.add(snapshot.excludedBin);
+  }
+  const expiresAtMs = Date.now() + remainingTimeoutMs;
+  const discovery = (async () => {
+    try {
+      const { stdout } = await execFileAsync2(
+        snapshot.shell,
+        ["-lc", "command -v onchainos"],
+        {
+          env: snapshot.childEnv,
+          windowsHide: true,
+          timeout: remainingTimeoutMs
+        }
+      );
+      const bin = extractExecutablePath(stdout);
+      return bin ? { status: "found", bin } : { status: "not_found" };
+    } catch (err) {
+      if (isPosixDiscoveryTimeoutError(err, expiresAtMs)) {
+        logWithTimestamp(
+          "[onchainos] shell resolve timed out; callers with time remaining may retry"
+        );
+        return { status: "timed_out" };
+      }
+      logWithTimestamp(
+        "[onchainos] shell resolve failed, will fallback to bare 'onchainos':",
+        err
+      );
+      return { status: "not_found" };
+    }
+  })();
+  const clearFlight = () => {
+    if (posixDiscoveryFlights.get(snapshot.flightKey) === flight) {
+      posixDiscoveryFlights.delete(snapshot.flightKey);
+    }
+  };
+  const flight = {
+    excludedBins,
+    expiresAtMs,
+    joinCount: 0,
+    promise: discovery.then(
+      (result) => {
+        clearFlight();
+        return result;
+      },
+      (err) => {
+        clearFlight();
+        throw err;
+      }
+    )
+  };
+  posixDiscoveryFlights.set(snapshot.flightKey, flight);
+  return flight;
+}
+function isPosixDiscoveryTimeoutError(err, expiresAtMs) {
+  const timeoutError = err;
+  return timeoutError?.killed === true || timeoutError?.code === "ETIMEDOUT" || Date.now() >= expiresAtMs;
+}
+async function resolveBinSelection(timeoutMs = ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS, excludedAttempt, deadlineMs = Date.now() + timeoutMs) {
+  const excludedBin = excludedAttempt && !(resolvedBin === excludedAttempt.bin && resolverRevision !== excludedAttempt.revision) ? excludedAttempt.bin : void 0;
+  const envBin = configuredEnvBin();
+  const explicitCandidate = envBin && envBin !== excludedBin ? resolveConfiguredBin(envBin) : null;
   if (resolvedBin) {
-    return resolvedBin;
+    if (resolvedBin === excludedBin) {
+      invalidateResolvedBin(
+        resolvedBin,
+        "previous launch attempt could not start",
+        excludedAttempt?.revision
+      );
+    }
+  }
+  if (resolvedBin) {
+    const explicitBinRecovered = explicitCandidate !== null && explicitCandidate !== resolvedBin;
+    if (resolvedForEnvBin === envBin && isResolvedBinUsable(resolvedBin) && !explicitBinRecovered) {
+      return { bin: resolvedBin, revision: resolverRevision };
+    }
+    invalidateResolvedBin(
+      resolvedBin,
+      explicitBinRecovered ? "ONCHAINOS_BIN is available again" : resolvedForEnvBin !== envBin ? "ONCHAINOS_BIN changed" : "cached path is no longer executable"
+    );
   }
-  const envBin = process.env.ONCHAINOS_BIN;
   if (envBin) {
-    logWithTimestamp(`[onchainos] using ONCHAINOS_BIN=${envBin}`);
-    resolvedBin = envBin;
-    return resolvedBin;
+    if (explicitCandidate && explicitCandidate !== excludedBin) {
+      logWithTimestamp(
+        explicitCandidate === envBin ? `[onchainos] using ONCHAINOS_BIN=${envBin}` : `[onchainos] resolved ONCHAINOS_BIN=${envBin} to ${explicitCandidate}`
+      );
+      return cacheResolvedBin(explicitCandidate, envBin);
+    }
+    logWithTimestamp(
+      envBin === excludedBin ? `[onchainos] skipping ONCHAINOS_BIN=${envBin} after launch failure; falling back to discovery` : `[onchainos] ONCHAINOS_BIN is not executable at ${envBin}; falling back to discovery`
+    );
   }
   if (process.platform === "win32") {
-    const winBin = resolveWin32();
+    const winBin = resolveWin32(excludedBin);
     if (winBin) {
-      resolvedBin = winBin;
-      return resolvedBin;
+      return cacheResolvedBin(winBin, envBin);
     }
   } else {
-    try {
-      const shell = process.env.SHELL || "/bin/bash";
-      const { stdout } = await execFileAsync2(shell, ["-lc", "command -v onchainos"], {
-        windowsHide: true,
-        timeout: timeoutMs
-      });
-      const bin = extractExecutablePath(stdout);
-      if (bin) {
+    const remainingTimeoutMs = deadlineMs - Date.now();
+    if (remainingTimeoutMs > 0) {
+      const snapshot = createPosixDiscoverySnapshot(
+        envBin,
+        excludedBin,
+        timeoutMs
+      );
+      const flight = getOrCreatePosixDiscovery(snapshot, remainingTimeoutMs);
+      const discoveryResult = await flight.promise;
+      if (!isPosixDiscoverySnapshotCurrent(snapshot)) {
+        if (currentPosixDiscoveryContextKey() !== snapshot.contextKey) {
+          logWithTimestamp(
+            "[onchainos] discarding stale binary discovery result; resolver context changed"
+          );
+        }
+        return resolveBinSelection(timeoutMs, excludedAttempt, deadlineMs);
+      }
+      if (discoveryResult.status === "timed_out" && deadlineMs - Date.now() > 0) {
+        return resolveBinSelection(timeoutMs, excludedAttempt, deadlineMs);
+      }
+      const recoveredExplicitBin = snapshot.envBin ? resolveConfiguredBin(snapshot.envBin) : null;
+      if (recoveredExplicitBin && !flight.excludedBins.has(recoveredExplicitBin) && resolvedBin === null) {
+        logWithTimestamp(
+          recoveredExplicitBin === snapshot.envBin ? `[onchainos] using recovered ONCHAINOS_BIN=${snapshot.envBin}` : `[onchainos] resolved recovered ONCHAINOS_BIN=${snapshot.envBin} to ${recoveredExplicitBin}`
+        );
+        return cacheResolvedBin(recoveredExplicitBin, snapshot.envBin);
+      }
+      const bin = discoveryResult.status === "found" ? discoveryResult.bin : null;
+      if (bin && !flight.excludedBins.has(bin) && isResolvedBinUsable(bin) && resolvedBin === null) {
         logWithTimestamp(`[onchainos] resolved binary via shell: ${bin}`);
-        resolvedBin = bin;
-        return resolvedBin;
+        return cacheResolvedBin(bin, snapshot.envBin);
       }
-    } catch (err) {
+    } else {
       logWithTimestamp(
-        "[onchainos] shell resolve failed, will fallback to bare 'onchainos':",
-        err
+        "[onchainos] binary discovery deadline exhausted; using bare fallback"
       );
     }
   }
   logWithTimestamp(
     "[onchainos] could not resolve binary path, falling back to bare 'onchainos'"
   );
-  resolvedBin = "onchainos";
-  return resolvedBin;
+  return { bin: "onchainos", revision: resolverRevision };
 }
-function resolveWin32() {
+async function resolve6(timeoutMs = ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS) {
+  return (await resolveBinSelection(timeoutMs)).bin;
+}
+function resolveWin32(excludedBin) {
   const candidates = buildWin32OnchainosCandidates(
     process.env.PATH ?? process.env.Path ?? "",
     process.env.USERPROFILE
-  );
+  ).filter((candidate) => !isSameWin32Candidate(candidate, excludedBin));
   const picked = pickOnchainosWin32Candidate(candidates);
   if (picked) {
     logWinCompat(
@@ -59304,7 +59574,14 @@ function resolveWin32() {
   );
   return null;
 }
-function buildWin32OnchainosCandidates(pathValue, userProfile) {
+function isSameWin32Candidate(candidate, excludedBin) {
+  if (!excludedBin) {
+    return false;
+  }
+  const normalize = (value) => value.replace(/\//g, "\\").replace(/\\+$/g, "").toLowerCase();
+  return normalize(candidate) === normalize(excludedBin);
+}
+function buildWin32CandidatePaths(names, pathValue, userProfile) {
   const dirs = [];
   const seen = /* @__PURE__ */ new Set();
   const addDir = (dir) => {
@@ -59324,7 +59601,6 @@ function buildWin32OnchainosCandidates(pathValue, userProfile) {
   if (userProfile?.trim()) {
     addDir((0, import_node_path22.join)(userProfile, ".local", "bin"));
   }
-  const names = ["onchainos.exe", "onchainos.cmd", "onchainos.bat", "onchainos"];
   const candidates = [];
   for (const dir of dirs) {
     for (const name of names) {
@@ -59333,6 +59609,29 @@ function buildWin32OnchainosCandidates(pathValue, userProfile) {
   }
   return candidates;
 }
+function buildWin32OnchainosCandidates(pathValue, userProfile) {
+  return buildWin32CandidatePaths(
+    ["onchainos.exe", "onchainos.cmd", "onchainos.bat", "onchainos"],
+    pathValue,
+    userProfile
+  );
+}
+function resolveWin32BareCommandCandidate(command, pathValue, pathExtValue, userProfile) {
+  const names = (0, import_node_path22.extname)(command) ? [command] : [
+    ...new Set(
+      pathExtValue.split(";").map((extension) => extension.trim().toLowerCase()).filter(Boolean).map(
+        (extension) => `${command}${extension.startsWith(".") ? extension : `.${extension}`}`
+      )
+    ),
+    command
+  ];
+  for (const candidate of buildWin32CandidatePaths(names, pathValue, userProfile)) {
+    if (win32FileExists(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
 var WINDOWS_APPS_ALIAS_MARKER = "\\microsoft\\windowsapps\\";
 function win32CandidatePriority(candidate) {
   const extension = (0, import_node_path22.extname)(candidate).toLowerCase();
@@ -59438,59 +59737,79 @@ function commandForLog(bin, args) {
   return `${bin} ${redactArgsForLog(args).join(" ")}`;
 }
 async function exec(args, options = {}) {
-  const bin = await resolve6();
-  const cmd = commandForLog(bin, args);
-  logWithTimestamp(`[onchainos] exec: ${cmd}`);
-  const invocation = toWindowsInvocation(bin, args);
-  if (invocation.routedThroughWindowsShell) {
-    logWinCompat(
-      `${WIN_COMPAT_LOG_PREFIX} [onchainos] exec routed through ${invocation.command} /d /s /c: ${cmd}`
+  let excludedAttempt;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const selection = await resolveBinSelection(
+      ONCHAINOS_BIN_RESOLVE_TIMEOUT_MS,
+      excludedAttempt
     );
-  }
-  const t0 = Date.now();
-  try {
-    const result = await execFileAsync2(invocation.command, invocation.args, {
-      windowsHide: true,
-      windowsVerbatimArguments: invocation.windowsVerbatimArguments,
-      timeout: options.timeoutMs
-    });
-    logWithTimestamp(
-      `[onchainos] exec done: ${cmd} (${Date.now() - t0}ms, stdout=${result.stdout.length}B, stderr=${result.stderr.length}B)`
-    );
-    return result;
-  } catch (err) {
+    const { bin } = selection;
+    const cmd = commandForLog(bin, args);
+    logWithTimestamp(`[onchainos] exec: ${cmd}`);
+    const invocation = toWindowsInvocation(bin, args);
     if (invocation.routedThroughWindowsShell) {
       logWinCompat(
-        `${WIN_COMPAT_LOG_PREFIX} [onchainos] routed exec failed via ${invocation.command}: ${cmd} errorCode=${err?.code ?? ""} signal=${err?.signal ?? ""}`
+        `${WIN_COMPAT_LOG_PREFIX} [onchainos] exec routed through ${invocation.command} /d /s /c: ${cmd}`
       );
     }
-    logWithTimestamp(
-      `[onchainos] exec error: ${cmd} (${Date.now() - t0}ms) code=${err.code} signal=${err.signal} killed=${err.killed} message=${err.message}`
-    );
-    logger.error(
-      LogEvent.ONCHAINOS_CLI_ERROR,
-      err instanceof Error ? err : new Error("onchainos command failed"),
-      {
-        component: "onchainos_cli",
-        source: "onchainos",
-        stage: "exec",
-        communicationClass: "onchainos_cli_or_api_issue",
-        operation: redactArgsForLog(args).slice(0, 3).join(" "),
-        reason: "exec_failed",
-        argCount: String(args.length),
-        exitCode: String(err?.code ?? ""),
-        signal: String(err?.signal ?? ""),
-        killed: String(err?.killed ?? ""),
-        stderrBytes: String(Buffer.byteLength(String(err?.stderr ?? ""), "utf8")),
-        stdoutBytes: String(Buffer.byteLength(String(err?.stdout ?? ""), "utf8")),
-        cliErrorName: err instanceof Error ? err.name : "",
-        cliErrorMessageLength: String(String(err?.message ?? "").length),
-        durationMs: String(Date.now() - t0),
-        timeoutMs: String(options.timeoutMs ?? "")
+    const t0 = Date.now();
+    try {
+      const result = await execFileAsync2(invocation.command, invocation.args, {
+        windowsHide: true,
+        windowsVerbatimArguments: invocation.windowsVerbatimArguments,
+        timeout: options.timeoutMs
+      });
+      rememberSuccessfulBareBin(bin);
+      logWithTimestamp(
+        `[onchainos] exec done: ${cmd} (${Date.now() - t0}ms, stdout=${result.stdout.length}B, stderr=${result.stderr.length}B)`
+      );
+      return result;
+    } catch (err) {
+      if (invocation.routedThroughWindowsShell) {
+        logWinCompat(
+          `${WIN_COMPAT_LOG_PREFIX} [onchainos] routed exec failed via ${invocation.command}: ${cmd} errorCode=${err?.code ?? ""} signal=${err?.signal ?? ""}`
+        );
       }
-    );
-    throw err;
+      logWithTimestamp(
+        `[onchainos] exec error: ${cmd} (${Date.now() - t0}ms) code=${err.code} signal=${err.signal} killed=${err.killed} message=${err.message}`
+      );
+      if (attempt === 0 && isCommandUnavailableError(err)) {
+        invalidateResolvedBin(
+          bin,
+          "command could not launch the cached binary",
+          selection.revision
+        );
+        if (shouldRetryUnavailableBin(bin)) {
+          excludedAttempt = selection;
+          continue;
+        }
+      }
+      logger.error(
+        LogEvent.ONCHAINOS_CLI_ERROR,
+        err instanceof Error ? err : new Error("onchainos command failed"),
+        {
+          component: "onchainos_cli",
+          source: "onchainos",
+          stage: "exec",
+          communicationClass: "onchainos_cli_or_api_issue",
+          operation: redactArgsForLog(args).slice(0, 3).join(" "),
+          reason: "exec_failed",
+          argCount: String(args.length),
+          exitCode: String(err?.code ?? ""),
+          signal: String(err?.signal ?? ""),
+          killed: String(err?.killed ?? ""),
+          stderrBytes: String(Buffer.byteLength(String(err?.stderr ?? ""), "utf8")),
+          stdoutBytes: String(Buffer.byteLength(String(err?.stdout ?? ""), "utf8")),
+          cliErrorName: err instanceof Error ? err.name : "",
+          cliErrorMessageLength: String(String(err?.message ?? "").length),
+          durationMs: String(Date.now() - t0),
+          timeoutMs: String(options.timeoutMs ?? "")
+        }
+      );
+      throw err;
+    }
   }
+  throw new Error("OnchainOS command retry exhausted");
 }
 
 // ../core/src/xmtp-sdk/onchainos/index.ts
@@ -61027,7 +61346,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     client: {
       id: "gateway-client",
       displayName: "okx-a2a-node",
-      version: "0.2.10-beta-1a0d85b27f-260828092722",
+      version: "0.2.10",
       platform: "node",
       mode: "backend",
       instanceId
@@ -61038,7 +61357,7 @@ function buildConnectParams(config, instanceId, protocolVersion) {
     commands: [],
     permissions: {},
     locale: Intl.DateTimeFormat().resolvedOptions().locale || "en-US",
-    userAgent: `okx-a2a-node/${"0.2.10-beta-1a0d85b27f-260828092722"}`,
+    userAgent: `okx-a2a-node/${"0.2.10"}`,
     auth: {
       ...config.token ? { token: config.token } : {},
       ...config.password ? { password: config.password } : {}
@@ -62563,6 +62882,7 @@ function stableHash2(value) {
 // src/xmtp-send.ts
 var TASK_MIN_VERSION = 1;
 var sqliteGroupSessionPromises = /* @__PURE__ */ new Map();
+var conversationSyncPromises = /* @__PURE__ */ new WeakMap();
 var XMTP_SEND_CHECKPOINT = "outbound/xmtp_send";
 function buildXmtpMessageSentExtra(params) {
   const xmtpMessageId = typeof params.xmtpMessageId === "string" && params.xmtpMessageId.length > 0 ? params.xmtpMessageId : "";
@@ -62727,6 +63047,22 @@ function selectAnyJobTarget(messages) {
   }
   return null;
 }
+async function syncConversationsOnLocalMiss(agent) {
+  const conversations = agent.client.conversations;
+  const existing = conversationSyncPromises.get(conversations);
+  if (existing) {
+    return existing;
+  }
+  const pending = conversations.sync();
+  conversationSyncPromises.set(conversations, pending);
+  try {
+    await pending;
+  } finally {
+    if (conversationSyncPromises.get(conversations) === pending) {
+      conversationSyncPromises.delete(conversations);
+    }
+  }
+}
 async function findConversation(agent, target) {
   await agent.client.conversations.syncAll([
     import_node_bindings2.ConsentState.Allowed,
@@ -62748,11 +63084,11 @@ async function findConversation(agent, target) {
   return null;
 }
 async function findGroupConversation(agent, groupId) {
-  await agent.client.conversations.syncAll([
-    import_node_bindings2.ConsentState.Allowed,
-    import_node_bindings2.ConsentState.Unknown
-  ]);
-  const conversation = await agent.client.conversations.getConversationById(groupId);
+  let conversation = await agent.client.conversations.getConversationById(groupId);
+  if (!(conversation instanceof Group)) {
+    await syncConversationsOnLocalMiss(agent);
+    conversation = await agent.client.conversations.getConversationById(groupId);
+  }
   return conversation instanceof Group ? conversation : null;
 }
 function buildDmReplyRaw(command, target, localAgentId) {
@@ -63022,6 +63358,9 @@ async function handleSqliteGroupSendCommand(params) {
       let created2 = false;
       if (xmtpGroupId) {
         conversation2 = await findGroupConversation(agent, xmtpGroupId);
+        if (!conversation2) {
+          throw new Error(`conversation not found for stored xmtpGroupId=${xmtpGroupId} after conversation sync`);
+        }
       }
       if (!conversation2) {
         conversation2 = await createGroupForAddress({
@@ -64127,7 +64466,7 @@ function isRecord5(value) {
 }
 
 // src/command-processor.ts
-var DEFAULT_COMMAND_EXECUTION_TIMEOUT_MS = 5e4;
+var DEFAULT_COMMAND_EXECUTION_TIMEOUT_MS = 12e4;
 var DEFAULT_COMMAND_STALE_TIMEOUT_MS = 12e4;
 var DEFAULT_AI_COMMAND_STALE_TIMEOUT_MS = 30 * 6e4;
 var DEFAULT_XMTP_SEND_CONCURRENCY = 50;
@@ -67385,12 +67724,12 @@ async function runListenerWithLock(options, paths) {
       });
     }
   });
-  service.setPluginVersion("0.2.10-beta-1a0d85b27f-260828092722");
+  service.setPluginVersion("0.2.10");
   await service.init();
   const pluginVersionStatus = service.pluginVersionStatus;
   if (pluginVersionStatus.unavailable) {
     throw new Error(
-      `@okxweb3/a2a-node v${"0.2.10-beta-1a0d85b27f-260828092722"} is below the required minimum v${pluginVersionStatus.minVersion}`
+      `@okxweb3/a2a-node v${"0.2.10"} is below the required minimum v${pluginVersionStatus.minVersion}`
     );
   }
   const systemConfig = service.getSystemConfig();
@@ -67418,7 +67757,7 @@ async function runListenerWithLock(options, paths) {
       onchainosAgentId: "*",
       reason: "system-config missing sentryDsn",
       pluginId: "@okxweb3/a2a-node",
-      pluginVersion: "0.2.10-beta-1a0d85b27f-260828092722"
+      pluginVersion: "0.2.10"
     });
   }
   logWithTimestamp(
@@ -70186,7 +70525,7 @@ async function exportDiagnosticLogs(options) {
     node: process.version,
     platform: process.platform,
     arch: process.arch,
-    packageVersion: true ? "0.2.10-beta-1a0d85b27f-260828092722" : "unknown",
+    packageVersion: true ? "0.2.10" : "unknown",
     sensitiveContentIncluded: options.includeSensitiveContent,
     listenerAndLlmContentIncluded: true,
     credentialsAlwaysRedacted: true,
@@ -72068,7 +72407,7 @@ 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.2.10-beta-1a0d85b27f-260828092722" : "0.0.0"),
+    cliVersion: options.cliVersion ?? (true ? "0.2.10" : "0.0.0"),
     fixMode: options.fix === true,
     nonInteractive: options.nonInteractive === true,
     packageChanged: false,
@@ -72425,6 +72764,7 @@ init_autostart_windows();
   getA2ACapabilities,
   getDaemonStatus,
   getHermesGatewayPluginStatus,
+  getResolvedOnchainosBinForTests,
   getRuntimeMetadata,
   getSessionBusyTracker,
   handleCapabilitiesCommand,
@@ -72440,6 +72780,7 @@ init_autostart_windows();
   installWindowsNativeLauncher,
   installedAutostartHasCurrentConfiguration,
   installedAutostartHasCurrentRestartPolicy,
+  invalidateResolvedOnchainosBinForTests,
   isAutostartManagerUnavailableError,
   isDefaultTaskHome,
   isGatewayAvailableForHeartbeat,
@@ -72520,6 +72861,7 @@ init_autostart_windows();
   resolveNpmCmdShimScript,
   resolveOfflineReplayCapabilityMarker,
   resolveOfflineReplayIntervalSec,
+  resolveOnchainosBinForTests,
   resolveOpenClawGatewayConfig,
   resolveOpenClawGatewayRoute,
   resolveOpenClawGatewayRoutes,