Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

scripts/e2e/lib/plugin-update/corrupt-update-scenario.sh

@@ -0,0 +1,110 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+source scripts/lib/openclaw-e2e-instance.sh
+source scripts/e2e/lib/plugins/fixtures.sh
+
+openclaw_e2e_eval_test_state_from_b64 "${OPENCLAW_TEST_STATE_SCRIPT_B64:?missing OPENCLAW_TEST_STATE_SCRIPT_B64}"
+
+export npm_config_loglevel=error
+export npm_config_fund=false
+export npm_config_audit=false
+export npm_config_prefix=/tmp/npm-prefix
+export NPM_CONFIG_PREFIX=/tmp/npm-prefix
+export PATH="/tmp/npm-prefix/bin:$PATH"
+export CI=true
+export OPENCLAW_DISABLE_BUNDLED_PLUGINS=1
+export OPENCLAW_NO_ONBOARD=1
+export OPENCLAW_NO_PROMPT=1
+
+baseline="${OPENCLAW_UPDATE_CORRUPT_PLUGIN_BASELINE:-openclaw@latest}"
+update_timeout_seconds="$(openclaw_e2e_read_positive_int_env OPENCLAW_UPDATE_CORRUPT_PLUGIN_TIMEOUT_SECONDS 900)"
+echo "Installing baseline OpenClaw package: $baseline"
+if ! openclaw_e2e_maybe_timeout "${OPENCLAW_E2E_NPM_INSTALL_TIMEOUT:-600s}" npm install -g --prefix /tmp/npm-prefix --omit=optional "$baseline" >/tmp/openclaw-update-corrupt-baseline-install.log 2>&1; then
+  openclaw_e2e_print_log /tmp/openclaw-update-corrupt-baseline-install.log >&2
+  exit 1
+fi
+
+package_root="$(openclaw_e2e_package_root /tmp/npm-prefix)"
+entry="$(openclaw_e2e_package_entrypoint "$package_root")"
+export OPENCLAW_ENTRY="$entry"
+
+npm_pack_dir="$(mktemp -d "/tmp/openclaw-corrupt-plugin-pack.XXXXXX")"
+npm_registry_dir="$(mktemp -d "/tmp/openclaw-corrupt-plugin-registry.XXXXXX")"
+pack_fixture_plugin "$npm_pack_dir" /tmp/demo-corrupt-plugin.tgz demo-corrupt-plugin 0.0.1 demo.corrupt "Demo Corrupt Plugin"
+start_npm_fixture_registry "@openclaw/demo-corrupt-plugin" "0.0.1" /tmp/demo-corrupt-plugin.tgz "$npm_registry_dir"
+
+echo "Installing managed external plugin..."
+node "$entry" plugins install "npm:@openclaw/demo-corrupt-plugin@0.0.1" >/tmp/openclaw-corrupt-plugin-install.log 2>&1
+node "$entry" plugins inspect demo-corrupt-plugin --runtime --json >/tmp/openclaw-corrupt-plugin-before.json
+unset NPM_CONFIG_REGISTRY npm_config_registry
+
+plugin_dir="$(
+  node -e '
+    const fs = require("node:fs");
+    const payload = JSON.parse(fs.readFileSync(process.argv[1], "utf8"));
+    const installPath = payload.install?.installPath ?? payload.plugin?.rootDir;
+    if (!installPath) {
+      throw new Error("missing plugin install path in inspect output");
+    }
+    process.stdout.write(installPath);
+  ' /tmp/openclaw-corrupt-plugin-before.json
+)"
+rm -f "$plugin_dir/package.json"
+if [ -f "$plugin_dir/package.json" ]; then
+  echo "Expected corrupt plugin package.json to be removed before update." >&2
+  exit 1
+fi
+
+echo "Updating OpenClaw with corrupt plugin present..."
+set +e
+openclaw_e2e_maybe_timeout "${update_timeout_seconds}s" \
+  node "$entry" update \
+  --channel beta \
+  --tag "${OPENCLAW_CURRENT_PACKAGE_TGZ:?missing OPENCLAW_CURRENT_PACKAGE_TGZ}" \
+  --yes \
+  --no-restart \
+  --json \
+  >/tmp/openclaw-update-corrupt-plugin.json \
+  2>/tmp/openclaw-update-corrupt-plugin.err
+update_status=$?
+set -e
+if [ "$update_status" -ne 0 ]; then
+  if ! node scripts/e2e/lib/plugin-update/probe.mjs assert-legacy-post-update-plugin-failure /tmp/openclaw-update-corrupt-plugin.json; then
+    echo "openclaw update failed or timed out after ${update_timeout_seconds}s with corrupt plugin present" >&2
+    openclaw_e2e_print_log /tmp/openclaw-update-corrupt-plugin.err >&2
+    openclaw_e2e_print_log /tmp/openclaw-update-corrupt-plugin.json >&2
+    exit "$update_status"
+  fi
+  echo "Legacy updater reported post-update plugin failure after installing the new core; verifying updated entrypoint..."
+  set +e
+  OPENCLAW_UPDATE_POST_CORE=1 \
+    OPENCLAW_UPDATE_POST_CORE_CHANNEL=beta \
+    OPENCLAW_UPDATE_POST_CORE_RESULT_PATH=/tmp/openclaw-update-corrupt-plugin-post-core.json \
+    openclaw_e2e_maybe_timeout "${update_timeout_seconds}s" \
+    node "$entry" update \
+    --yes \
+    --no-restart \
+    --json \
+    >/tmp/openclaw-update-corrupt-plugin-post-core.stdout \
+    2>/tmp/openclaw-update-corrupt-plugin-post-core.err
+  post_core_status=$?
+  set -e
+  if [ "$post_core_status" -ne 0 ]; then
+    echo "updated OpenClaw entry failed or timed out after ${update_timeout_seconds}s during post-core plugin verification" >&2
+    openclaw_e2e_print_log /tmp/openclaw-update-corrupt-plugin-post-core.err >&2
+    openclaw_e2e_print_log /tmp/openclaw-update-corrupt-plugin-post-core.stdout >&2
+    openclaw_e2e_print_log /tmp/openclaw-update-corrupt-plugin-post-core.json >&2
+    exit "$post_core_status"
+  fi
+  node scripts/e2e/lib/plugin-update/probe.mjs assert-corrupt-plugin-result /tmp/openclaw-update-corrupt-plugin-post-core.json demo-corrupt-plugin
+  exit 0
+fi
+
+if ! node scripts/e2e/lib/plugin-update/probe.mjs assert-corrupt-update /tmp/openclaw-update-corrupt-plugin.json demo-corrupt-plugin; then
+  echo "corrupt update JSON payload:" >&2
+  openclaw_e2e_print_log /tmp/openclaw-update-corrupt-plugin.json >&2
+  echo "corrupt update stderr:" >&2
+  openclaw_e2e_print_log /tmp/openclaw-update-corrupt-plugin.err >&2
+  exit 1
+fi

scripts/e2e/lib/plugin-update/probe.mjs

@@ -0,0 +1,307 @@
+// Probe script for plugin update E2E scenarios.
+import fs from "node:fs";
+import http from "node:http";
+import os from "node:os";
+import path from "node:path";
+import { legacyPackageAcceptanceCompat } from "../package-compat.mjs";
+import {
+  readPluginInstallRecords,
+  writePluginInstallIndexForE2E,
+} from "../plugin-index-sqlite.mjs";
+
+const home = os.homedir();
+const OUTPUT_TAIL_BYTES = 64 * 1024;
+const OUTPUT_TAIL_LINES = 120;
+const OUTPUT_SCAN_WINDOW_BYTES = 8 * 1024;
+
+const readJson = (file) => {
+  try {
+    return JSON.parse(fs.readFileSync(file, "utf8"));
+  } catch {
+    return {};
+  }
+};
+
+const pluginRecordSnapshot = () => {
+  const config = readJson(openclawPath("openclaw.json"));
+  const records = readPluginInstallRecords({ fallbackRecords: config.plugins?.installs ?? {} });
+  const record = records["lossless-claw"] ?? records["@example/lossless-claw"];
+  if (!record) {
+    throw new Error("missing plugin install record");
+  }
+  const { source, spec, resolvedName, resolvedVersion, resolvedSpec, integrity, shasum } = record;
+  return { source, spec, resolvedName, resolvedVersion, resolvedSpec, integrity, shasum };
+};
+
+function openclawPath(...parts) {
+  return path.join(home, ".openclaw", ...parts);
+}
+
+function writeJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function seedInstallState() {
+  writeJson(openclawPath("extensions", "lossless-claw", "package.json"), {
+    name: "@example/lossless-claw",
+    version: "0.9.0",
+  });
+  writeJson(process.env.OPENCLAW_CONFIG_PATH, { plugins: {} });
+  writePluginInstallIndexForE2E({
+    version: 1,
+    warning: "DO NOT EDIT. This file is generated by OpenClaw plugin registry commands.",
+    hostContractVersion: "docker-e2e",
+    compatRegistryVersion: "docker-e2e",
+    migrationVersion: 1,
+    policyHash: "docker-e2e",
+    generatedAtMs: 1777118400000,
+    installRecords: {
+      "lossless-claw": {
+        source: "npm",
+        spec: "@example/lossless-claw@0.9.0",
+        installPath: "~/.openclaw/extensions/lossless-claw",
+        resolvedName: "@example/lossless-claw",
+        resolvedVersion: "0.9.0",
+        resolvedSpec: "@example/lossless-claw@0.9.0",
+        integrity: "sha512-same",
+        shasum: "same",
+      },
+    },
+    plugins: [],
+    diagnostics: [],
+  });
+}
+
+async function waitRegistry() {
+  for (let attempt = 0; attempt < 50; attempt += 1) {
+    if (await registryHealthy()) {
+      return;
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, 100);
+    });
+  }
+  throw new Error("Local npm metadata registry failed to start");
+}
+
+function registryHealthy() {
+  return new Promise((resolve) => {
+    const registry = process.env.NPM_CONFIG_REGISTRY ?? "http://127.0.0.1:4873";
+    const req = http.get(`${registry.replace(/\/$/u, "")}/@example%2flossless-claw`, (res) => {
+      resolve(res.statusCode === 200);
+      res.resume();
+    });
+    req.on("error", () => resolve(false));
+    req.setTimeout(200, () => {
+      req.destroy();
+      resolve(false);
+    });
+  });
+}
+
+function assertSnapshot(beforePath) {
+  const before = readJson(beforePath);
+  const after = pluginRecordSnapshot();
+  if (JSON.stringify(before) !== JSON.stringify(after)) {
+    throw new Error(
+      `plugin install record changed unexpectedly: ${JSON.stringify({ before, after })}`,
+    );
+  }
+}
+
+function appendBufferTail(tail, chunk, maxBytes) {
+  if (chunk.length >= maxBytes) {
+    return chunk.subarray(chunk.length - maxBytes);
+  }
+  if (tail.length + chunk.length <= maxBytes) {
+    return Buffer.concat([tail, chunk]);
+  }
+  return Buffer.concat([tail, chunk]).subarray(tail.length + chunk.length - maxBytes);
+}
+
+async function readOutputEvidence(logPath) {
+  let outputTail = Buffer.alloc(0);
+  let scanWindow = "";
+  let sawDownload = false;
+  let sawUpToDate = false;
+  for await (const chunk of fs.createReadStream(logPath)) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    const text = buffer.toString("utf8");
+    const searchable = `${scanWindow}${text}`;
+    outputTail = appendBufferTail(outputTail, buffer, OUTPUT_TAIL_BYTES);
+    sawDownload ||= searchable.includes("Downloading @example/lossless-claw");
+    sawUpToDate ||= searchable.includes("lossless-claw is up to date (0.9.0).");
+    scanWindow = searchable.slice(-OUTPUT_SCAN_WINDOW_BYTES);
+  }
+  return {
+    outputTail: outputTail
+      .toString("utf8")
+      .split(/\r?\n/u)
+      .slice(-OUTPUT_TAIL_LINES)
+      .join("\n")
+      .trimEnd(),
+    sawDownload,
+    sawUpToDate,
+  };
+}
+
+async function assertOutput(logPath) {
+  const evidence = await readOutputEvidence(logPath);
+  const failure = evidence.sawDownload
+    ? "Unexpected npm download/reinstall path"
+    : !evidence.sawUpToDate
+      ? "Expected up-to-date output missing"
+      : "";
+  if (failure) {
+    throw new Error(`${failure}\nOutput tail:\n${evidence.outputTail}`);
+  }
+}
+
+function assertCorruptUpdate(updateJsonPath, pluginId) {
+  const payload = readJson(updateJsonPath);
+  if (payload.status !== "ok") {
+    throw new Error(`expected core update status ok, got ${JSON.stringify(payload.status)}`);
+  }
+  const plugins = payload.postUpdate?.plugins;
+  if (!plugins) {
+    throw new Error(`missing postUpdate.plugins in update output: ${JSON.stringify(payload)}`);
+  }
+  assertCorruptPluginTolerated(plugins, pluginId);
+}
+
+function assertCorruptPluginResult(pluginJsonPath, pluginId) {
+  const plugins = readJson(pluginJsonPath);
+  assertCorruptPluginTolerated(plugins, pluginId);
+}
+
+function assertCorruptPluginTolerated(plugins, pluginId) {
+  const evidence = collectPluginEvidence(plugins, pluginId);
+  if (plugins.status === "ok") {
+    assertCorruptPluginCleanOrRepaired(evidence);
+    return;
+  }
+  if (plugins.status !== "warning") {
+    throw new Error(
+      `expected post-update plugin status warning, got ${JSON.stringify(plugins.status)}`,
+    );
+  }
+  assertCorruptPluginDetails(plugins, pluginId);
+}
+
+function isCorruptPluginDisabledAfterUpdate(evidence, pluginId) {
+  const outcome = evidence.outcome;
+  const message = typeof outcome?.message === "string" ? outcome.message : "";
+  return (
+    outcome?.status === "skipped" &&
+    message.includes(`Disabled "${pluginId}" after plugin update failure`) &&
+    message.includes("OpenClaw will continue without it")
+  );
+}
+
+function assertCorruptPluginCleanOrRepaired(evidence) {
+  if (evidence.outcome) {
+    throw new Error(
+      `expected clean or repaired corrupt plugin state, got ${JSON.stringify(evidence)}`,
+    );
+  }
+  if (evidence.warning || evidence.integrityDrift || evidence.syncMessages.length > 0) {
+    throw new Error(
+      `expected warning post-update status for corrupt plugin evidence, got ok: ${JSON.stringify(
+        evidence,
+      )}`,
+    );
+  }
+}
+
+function assertCorruptPluginDetails(plugins, pluginId) {
+  const evidence = collectPluginEvidence(plugins, pluginId);
+  const outcome = evidence.outcome;
+  const disabledAfterFailure = isCorruptPluginDisabledAfterUpdate(evidence, pluginId);
+  if (!outcome || (outcome.status !== "error" && !disabledAfterFailure)) {
+    throw new Error(
+      `expected error or disabled-after-failure outcome for ${pluginId}, got ${JSON.stringify({
+        outcomes: plugins.npm?.outcomes ?? [],
+        warnings: plugins.warnings ?? [],
+        sync: plugins.sync,
+        integrityDrifts: plugins.integrityDrifts ?? [],
+      })}`,
+    );
+  }
+  const warning = evidence.warning;
+  if (!warning) {
+    throw new Error(
+      `expected warning for ${pluginId}, got ${JSON.stringify(plugins.warnings ?? [])}`,
+    );
+  }
+  const text = [outcome.message, warning.reason, warning.message, ...(warning.guidance ?? [])]
+    .filter(Boolean)
+    .join(" ");
+  const expectedFragments = disabledAfterFailure
+    ? [
+        `Disabled "${pluginId}" after plugin update failure`,
+        "OpenClaw will continue without it",
+        "Run openclaw update repair to retry post-update plugin repair.",
+        `Run openclaw plugins inspect ${pluginId} --runtime --json for details.`,
+      ]
+    : [
+        "package.json is missing",
+        "Run openclaw update repair to retry post-update plugin repair.",
+        `Run openclaw plugins inspect ${pluginId} --runtime --json for details.`,
+      ];
+  for (const expected of expectedFragments) {
+    if (!text.includes(expected)) {
+      throw new Error(`expected update output to include ${expected}: ${text}`);
+    }
+  }
+}
+
+function collectPluginEvidence(plugins, pluginId) {
+  const outcomes = plugins.npm?.outcomes ?? [];
+  const warnings = plugins.warnings ?? [];
+  const integrityDrifts = plugins.integrityDrifts ?? [];
+  const syncMessages = [...(plugins.sync?.warnings ?? []), ...(plugins.sync?.errors ?? [])].filter(
+    (message) => String(message).includes(pluginId),
+  );
+  return {
+    outcome: outcomes.find((entry) => entry?.pluginId === pluginId),
+    warning: warnings.find((entry) => entry?.pluginId === pluginId),
+    integrityDrift: integrityDrifts.find((entry) => entry?.pluginId === pluginId),
+    syncMessages,
+  };
+}
+
+function assertLegacyPostUpdatePluginFailure(updateJsonPath) {
+  const payload = readJson(updateJsonPath);
+  if (payload.status !== "error" || payload.reason !== "post-update-plugins") {
+    throw new Error(
+      `expected legacy post-update plugin failure, got ${JSON.stringify({
+        status: payload.status,
+        reason: payload.reason,
+      })}`,
+    );
+  }
+  if (!payload.after?.version) {
+    throw new Error(`expected core update to install a new version: ${JSON.stringify(payload)}`);
+  }
+}
+
+const [command, arg, arg2] = process.argv.slice(2);
+const commands = {
+  "legacy-compat": () => console.log(legacyPackageAcceptanceCompat(arg || "") ? "1" : "0"),
+  seed: seedInstallState,
+  "wait-registry": waitRegistry,
+  snapshot: () => process.stdout.write(JSON.stringify(pluginRecordSnapshot(), null, 2)),
+  "assert-snapshot": () => assertSnapshot(arg),
+  "assert-output": () => assertOutput(arg),
+  "assert-corrupt-update": () => assertCorruptUpdate(arg, arg2),
+  "assert-corrupt-plugin-result": () => assertCorruptPluginResult(arg, arg2),
+  "assert-legacy-post-update-plugin-failure": () => assertLegacyPostUpdatePluginFailure(arg),
+};
+const run = commands[command];
+await (
+  run ??
+  (() => {
+    throw new Error(`Unknown plugin update probe command: ${command || "(missing)"}`);
+  })
+)();

scripts/e2e/lib/plugin-update/registry-server.mjs

@@ -0,0 +1,52 @@
+// Fixture npm registry server for plugin update E2E scenarios.
+import fs from "node:fs";
+import http from "node:http";
+import { readTcpPortEnv } from "../env-limits.mjs";
+
+const portFile = process.argv[2];
+if (!portFile) {
+  console.error("usage: registry-server.mjs <port-file>");
+  process.exit(2);
+}
+
+function buildMetadata(req) {
+  const host = req.headers.host ?? "127.0.0.1";
+  return {
+    name: "@example/lossless-claw",
+    "dist-tags": { latest: "0.9.0" },
+    versions: {
+      "0.9.0": {
+        name: "@example/lossless-claw",
+        version: "0.9.0",
+        dist: {
+          integrity: "sha512-same",
+          shasum: "same",
+          tarball: `http://${host}/@example/lossless-claw/-/lossless-claw-0.9.0.tgz`,
+        },
+      },
+    },
+  };
+}
+
+const server = http.createServer((req, res) => {
+  if (req.url === "/@example%2flossless-claw" || req.url === "/@example%2Flossless-claw") {
+    res.writeHead(200, { "content-type": "application/json" });
+    res.end(JSON.stringify(buildMetadata(req)));
+    return;
+  }
+  res.writeHead(404, { "content-type": "text/plain" });
+  res.end(`not found: ${req.url}`);
+});
+
+const requestedPort =
+  process.env.OPENCLAW_PLUGIN_UPDATE_REGISTRY_PORT === undefined
+    ? 0
+    : readTcpPortEnv("OPENCLAW_PLUGIN_UPDATE_REGISTRY_PORT");
+
+server.listen(requestedPort, "127.0.0.1", () => {
+  const address = server.address();
+  if (!address || typeof address === "string") {
+    throw new Error("plugin update registry did not expose a TCP port");
+  }
+  fs.writeFileSync(portFile, `${address.port}\n`);
+});

scripts/e2e/lib/plugin-update/unchanged-scenario.sh

@@ -0,0 +1,76 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+source scripts/lib/openclaw-e2e-instance.sh
+
+openclaw_e2e_eval_test_state_from_b64 "${OPENCLAW_TEST_STATE_SCRIPT_B64:?missing OPENCLAW_TEST_STATE_SCRIPT_B64}"
+openclaw_e2e_install_package /tmp/openclaw-install.log "mounted OpenClaw package" /tmp/npm-prefix
+
+package_root="$(openclaw_e2e_package_root /tmp/npm-prefix)"
+entry="$(openclaw_e2e_package_entrypoint "$package_root")"
+probe="scripts/e2e/lib/plugin-update/probe.mjs"
+package_version="$(node -p "require('$package_root/package.json').version")"
+OPENCLAW_PACKAGE_ACCEPTANCE_LEGACY_COMPAT="$(node "$probe" legacy-compat "$package_version")"
+export OPENCLAW_PACKAGE_ACCEPTANCE_LEGACY_COMPAT
+export PATH="/tmp/npm-prefix/bin:$PATH"
+
+node "$probe" seed
+
+registry_port_file=/tmp/openclaw-e2e-registry.port
+rm -f "$registry_port_file"
+node scripts/e2e/lib/plugin-update/registry-server.mjs "$registry_port_file" >/tmp/openclaw-e2e-registry.log 2>&1 &
+registry_pid=$!
+trap 'openclaw_e2e_stop_process "${registry_pid:-}"' EXIT
+for _ in $(seq 1 50); do
+  if [ -s "$registry_port_file" ]; then
+    break
+  fi
+  sleep 0.1
+done
+if [ ! -s "$registry_port_file" ]; then
+  echo "Local npm metadata registry did not expose a port"
+  openclaw_e2e_print_log /tmp/openclaw-e2e-registry.log
+  exit 1
+fi
+export NPM_CONFIG_REGISTRY="http://127.0.0.1:$(cat "$registry_port_file")"
+export npm_config_registry="$NPM_CONFIG_REGISTRY"
+
+if ! node "$probe" wait-registry; then
+  echo "Local npm metadata registry failed to start"
+  openclaw_e2e_print_log /tmp/openclaw-e2e-registry.log
+  exit 1
+fi
+
+before_config_hash=""
+if [ "$OPENCLAW_PACKAGE_ACCEPTANCE_LEGACY_COMPAT" != "1" ]; then
+  before_config_hash="$(sha256sum "$OPENCLAW_CONFIG_PATH" | awk '{print $1}')"
+fi
+plugin_update_timeout_seconds="$(openclaw_e2e_read_positive_int_env OPENCLAW_PLUGIN_UPDATE_TIMEOUT_SECONDS 180)"
+
+node "$probe" snapshot > /tmp/plugin-update-before.json
+
+set +e
+openclaw_e2e_maybe_timeout "${plugin_update_timeout_seconds}s" node "$entry" plugins update @example/lossless-claw > /tmp/plugin-update-output.log 2>&1
+plugin_update_status=$?
+set -e
+if [ "$plugin_update_status" -ne 0 ]; then
+  echo "Plugin update command failed or timed out after ${plugin_update_timeout_seconds}s (status ${plugin_update_status})"
+  echo "--- plugin update output ---"
+  openclaw_e2e_print_log /tmp/plugin-update-output.log
+  echo "--- local registry output ---"
+  openclaw_e2e_print_log /tmp/openclaw-e2e-registry.log
+  exit "$plugin_update_status"
+fi
+
+if [ -n "$before_config_hash" ]; then
+  after_config_hash="$(sha256sum "$OPENCLAW_CONFIG_PATH" | awk '{print $1}')"
+  if [ "$before_config_hash" != "$after_config_hash" ]; then
+    echo "Config changed unexpectedly for modern package $package_version"
+    openclaw_e2e_print_log /tmp/plugin-update-output.log
+    exit 1
+  fi
+fi
+
+node "$probe" assert-snapshot /tmp/plugin-update-before.json
+node "$probe" assert-output /tmp/plugin-update-output.log
+openclaw_e2e_print_log /tmp/plugin-update-output.log