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

test/helpers/config/bundled-channel-config-runtime.ts

@@ -0,0 +1,106 @@
+// Bundled channel config runtime helper loads public bundled channel config surfaces.
+import * as bundledChannelModule from "../../../src/channels/plugins/bundled.js";
+import type {
+  ChannelConfigRuntimeSchema,
+  ChannelConfigSchema,
+} from "../../../src/channels/plugins/types.plugin.js";
+import { listBundledPluginMetadata } from "../../../src/plugins/bundled-plugin-metadata.js";
+
+// Shared bundled channel config runtime maps for config contract tests.
+
+type BundledChannelRuntimeMap = ReadonlyMap<string, ChannelConfigRuntimeSchema>;
+type BundledChannelConfigSchemaMap = ReadonlyMap<string, ChannelConfigSchema>;
+type BundledChannelPluginShape = {
+  id: string;
+  configSchema?: ChannelConfigSchema;
+};
+type BundledChannelMaps = {
+  runtimeMap: Map<string, ChannelConfigRuntimeSchema>;
+  configSchemaMap: Map<string, ChannelConfigSchema>;
+};
+
+let cachedBundledChannelMaps: BundledChannelMaps | undefined;
+
+/** Build runtime/config maps from public bundled channel plugin metadata. */
+function buildBundledChannelMaps(
+  plugins: readonly BundledChannelPluginShape[],
+): BundledChannelMaps {
+  const runtimeMap = new Map<string, ChannelConfigRuntimeSchema>();
+  const configSchemaMap = new Map<string, ChannelConfigSchema>();
+
+  for (const plugin of plugins) {
+    const channelSchema = plugin.configSchema;
+    if (!channelSchema) {
+      continue;
+    }
+    configSchemaMap.set(plugin.id, channelSchema);
+    if (channelSchema.runtime) {
+      runtimeMap.set(plugin.id, channelSchema.runtime);
+    }
+  }
+
+  for (const entry of listBundledPluginMetadata({ includeChannelConfigs: true })) {
+    const channelConfigs = entry.manifest.channelConfigs;
+    if (!channelConfigs) {
+      continue;
+    }
+    for (const [channelId, channelConfig] of Object.entries(channelConfigs)) {
+      const channelSchema = channelConfig?.schema as Record<string, unknown> | undefined;
+      if (!channelSchema) {
+        continue;
+      }
+      if (!configSchemaMap.has(channelId)) {
+        configSchemaMap.set(channelId, {
+          schema: channelSchema,
+          ...(channelConfig.runtime ? { runtime: channelConfig.runtime } : {}),
+          ...(channelConfig.uiHints ? { uiHints: channelConfig.uiHints } : {}),
+        });
+      }
+      if (channelConfig.runtime && !runtimeMap.has(channelId)) {
+        runtimeMap.set(channelId, channelConfig.runtime);
+      }
+    }
+  }
+
+  return { runtimeMap, configSchemaMap };
+}
+
+/** Read bundled channel plugin surfaces when available in this test process. */
+function readBundledChannelPlugins(): readonly BundledChannelPluginShape[] | undefined {
+  try {
+    if (typeof bundledChannelModule.listBundledChannelPlugins !== "function") {
+      return undefined;
+    }
+    const plugins = bundledChannelModule.listBundledChannelPlugins();
+    return Array.isArray(plugins) ? (plugins as readonly BundledChannelPluginShape[]) : undefined;
+  } catch (error) {
+    if (error instanceof ReferenceError) {
+      return undefined;
+    }
+    throw error;
+  }
+}
+
+/** Return cached maps when live bundled plugin surfaces were available. */
+function getBundledChannelMaps(): BundledChannelMaps {
+  const plugins = readBundledChannelPlugins();
+  if (plugins && cachedBundledChannelMaps) {
+    return cachedBundledChannelMaps;
+  }
+
+  const maps = buildBundledChannelMaps(plugins ?? []);
+  if (plugins) {
+    cachedBundledChannelMaps = maps;
+  }
+  return maps;
+}
+
+/** Return runtime config schemas keyed by bundled channel id. */
+export function getBundledChannelRuntimeMap(): BundledChannelRuntimeMap {
+  return getBundledChannelMaps().runtimeMap;
+}
+
+/** Return channel config schemas keyed by bundled channel id. */
+export function getBundledChannelConfigSchemaMap(): BundledChannelConfigSchemaMap {
+  return getBundledChannelMaps().configSchemaMap;
+}

test/helpers/config/config-honor-audit.ts

@@ -0,0 +1,150 @@
+// Config honor audit helper checks config fields against expected consumers.
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { computeBaseConfigSchemaResponse } from "../../../src/config/schema-base.js";
+
+// Config honor audit helpers that compare schema keys with proof inventories.
+
+/** Inventory row describing where one config key is declared, merged, consumed, and tested. */
+export type ConfigHonorInventoryRow = {
+  key: string;
+  schemaPaths: string[];
+  typePaths: string[];
+  mergePaths: string[];
+  consumerPaths: string[];
+  reloadPaths: string[];
+  testPaths: string[];
+  notes?: string[];
+};
+
+type ConfigHonorProofKey =
+  | "schemaPaths"
+  | "typePaths"
+  | "mergePaths"
+  | "consumerPaths"
+  | "reloadPaths"
+  | "testPaths";
+
+/** Result of auditing one config honor inventory. */
+export type ConfigHonorAuditResult = {
+  schemaKeys: string[];
+  missingKeys: string[];
+  extraKeys: string[];
+  missingSchemaPaths: string[];
+  missingFiles: string[];
+  missingProofs: Array<{
+    key: string;
+    missing: ConfigHonorProofKey[];
+  }>;
+};
+
+const REPO_ROOT = fileURLToPath(new URL("../../../", import.meta.url));
+const BASE_CONFIG_SCHEMA = computeBaseConfigSchemaResponse({
+  generatedAt: "2026-05-05T00:00:00.000Z",
+});
+
+/** Return true when a dotted schema path exists in the generated base config schema. */
+function hasSchemaPath(schemaPath: string): boolean {
+  const segments = schemaPath.split(".");
+  let current: unknown = BASE_CONFIG_SCHEMA.schema;
+  for (const segment of segments) {
+    if (!current || typeof current !== "object") {
+      return false;
+    }
+    if (segment === "*") {
+      const items = (current as { items?: unknown }).items;
+      if (!items || typeof items !== "object") {
+        return false;
+      }
+      current = items;
+      continue;
+    }
+    const properties = (current as { properties?: Record<string, unknown> }).properties;
+    if (!properties || !Object.hasOwn(properties, segment)) {
+      return false;
+    }
+    current = properties[segment];
+  }
+  return true;
+}
+
+/** List leaf schema keys for the requested config prefixes. */
+export function listSchemaLeafKeysForPrefixes(prefixes: string[]): string[] {
+  const keys = new Set<string>();
+  for (const prefix of prefixes) {
+    const segments = prefix.split(".");
+    let current: unknown = BASE_CONFIG_SCHEMA.schema;
+    for (const segment of segments) {
+      if (!current || typeof current !== "object") {
+        current = null;
+        break;
+      }
+      if (segment === "*") {
+        current = (current as { items?: unknown }).items ?? null;
+        continue;
+      }
+      current = (current as { properties?: Record<string, unknown> }).properties?.[segment] ?? null;
+    }
+    const properties = (current as { properties?: Record<string, unknown> } | null)?.properties;
+    if (!properties) {
+      continue;
+    }
+    for (const key of Object.keys(properties)) {
+      keys.add(key);
+    }
+  }
+  return [...keys].toSorted();
+}
+
+/** Audit an inventory against schema keys, proof paths, and file existence. */
+export function auditConfigHonorInventory(params: {
+  prefixes: string[];
+  rows: ConfigHonorInventoryRow[];
+  expectedKeys?: string[];
+  repoRoot?: string;
+}): ConfigHonorAuditResult {
+  const repoRoot = params.repoRoot ?? REPO_ROOT;
+  const schemaKeys = listSchemaLeafKeysForPrefixes(params.prefixes);
+  const expectedKeys = new Set(params.expectedKeys ?? schemaKeys);
+  const rowKeys = new Set(params.rows.map((row) => row.key));
+  const missingKeys = [...expectedKeys].filter((key) => !rowKeys.has(key)).toSorted();
+  const extraKeys = params.rows
+    .map((row) => row.key)
+    .filter((key) => !expectedKeys.has(key))
+    .toSorted();
+
+  const missingSchemaPaths = params.rows.flatMap((row) =>
+    row.schemaPaths.filter((schemaPath) => !hasSchemaPath(schemaPath)),
+  );
+
+  const missingFiles = params.rows.flatMap((row) => {
+    const files = [...row.typePaths, ...row.mergePaths, ...row.consumerPaths, ...row.testPaths];
+    return files
+      .filter((relativePath) => !fs.existsSync(path.join(repoRoot, relativePath)))
+      .map((relativePath) => `${row.key}:${relativePath}`);
+  });
+
+  const missingProofs = params.rows
+    .map((row) => {
+      const missing: ConfigHonorProofKey[] = [
+        row.schemaPaths.length === 0 ? "schemaPaths" : null,
+        row.typePaths.length === 0 ? "typePaths" : null,
+        row.mergePaths.length === 0 ? "mergePaths" : null,
+        row.consumerPaths.length === 0 ? "consumerPaths" : null,
+        row.reloadPaths.length === 0 ? "reloadPaths" : null,
+        row.testPaths.length === 0 ? "testPaths" : null,
+      ].filter((value): value is ConfigHonorProofKey => value !== null);
+      return missing.length > 0 ? { key: row.key, missing } : null;
+    })
+    .filter((row): row is NonNullable<typeof row> => row !== null);
+
+  return {
+    schemaKeys,
+    missingKeys,
+    extraKeys,
+    missingSchemaPaths,
+    missingFiles,
+    missingProofs,
+  };
+}

test/helpers/config/heartbeat-config-honor.inventory.ts

@@ -0,0 +1,177 @@
+// Heartbeat config honor inventory lists heartbeat config ownership rows.
+import type { ConfigHonorInventoryRow } from "./config-honor-audit.js";
+
+// Inventory of heartbeat config keys and the proof paths that should honor them.
+
+/** Config prefixes audited for heartbeat key coverage. */
+export const HEARTBEAT_CONFIG_PREFIXES = [
+  "agents.defaults.heartbeat",
+  "agents.list.*.heartbeat",
+] as const;
+
+/** Heartbeat config honor inventory consumed by config audit tests. */
+export const HEARTBEAT_CONFIG_HONOR_INVENTORY: ConfigHonorInventoryRow[] = [
+  {
+    key: "every",
+    schemaPaths: ["agents.defaults.heartbeat.every", "agents.list.*.heartbeat.every"],
+    typePaths: ["src/config/types.agent-defaults.ts", "src/config/zod-schema.agent-runtime.ts"],
+    mergePaths: ["src/infra/heartbeat-runner.ts", "src/agents/acp-spawn.ts"],
+    consumerPaths: ["src/infra/heartbeat-runner.ts", "src/agents/acp-spawn.ts"],
+    reloadPaths: ["src/gateway/config-reload-plan.ts"],
+    testPaths: [
+      "src/infra/heartbeat-runner.returns-default-unset.test.ts",
+      "src/gateway/config-reload.test.ts",
+    ],
+  },
+  {
+    key: "model",
+    schemaPaths: ["agents.defaults.heartbeat.model", "agents.list.*.heartbeat.model"],
+    typePaths: ["src/config/types.agent-defaults.ts", "src/config/zod-schema.agent-runtime.ts"],
+    mergePaths: ["src/infra/heartbeat-runner.ts"],
+    consumerPaths: ["src/infra/heartbeat-runner.ts"],
+    reloadPaths: ["src/gateway/config-reload-plan.ts"],
+    testPaths: [
+      "src/infra/heartbeat-runner.model-override.test.ts",
+      "src/gateway/config-reload.test.ts",
+    ],
+  },
+  {
+    key: "prompt",
+    schemaPaths: ["agents.defaults.heartbeat.prompt", "agents.list.*.heartbeat.prompt"],
+    typePaths: ["src/config/types.agent-defaults.ts", "src/config/zod-schema.agent-runtime.ts"],
+    mergePaths: ["src/infra/heartbeat-runner.ts"],
+    consumerPaths: ["src/infra/heartbeat-runner.ts"],
+    reloadPaths: ["src/gateway/config-reload-plan.ts"],
+    testPaths: ["src/infra/heartbeat-runner.returns-default-unset.test.ts"],
+  },
+  {
+    key: "includeSystemPromptSection",
+    schemaPaths: [
+      "agents.defaults.heartbeat.includeSystemPromptSection",
+      "agents.list.*.heartbeat.includeSystemPromptSection",
+    ],
+    typePaths: ["src/config/types.agent-defaults.ts", "src/config/zod-schema.agent-runtime.ts"],
+    mergePaths: ["src/agents/heartbeat-system-prompt.ts"],
+    consumerPaths: [
+      "src/agents/heartbeat-system-prompt.ts",
+      "src/agents/embedded-agent-runner/run/attempt.prompt-helpers.ts",
+    ],
+    reloadPaths: ["src/gateway/config-reload-plan.ts"],
+    testPaths: ["src/agents/heartbeat-system-prompt.test.ts"],
+  },
+  {
+    key: "ackMaxChars",
+    schemaPaths: ["agents.defaults.heartbeat.ackMaxChars", "agents.list.*.heartbeat.ackMaxChars"],
+    typePaths: ["src/config/types.agent-defaults.ts", "src/config/zod-schema.agent-runtime.ts"],
+    mergePaths: ["src/infra/heartbeat-runner.ts"],
+    consumerPaths: ["src/infra/heartbeat-runner.ts"],
+    reloadPaths: ["src/gateway/config-reload-plan.ts"],
+    testPaths: ["src/infra/heartbeat-runner.respects-ackmaxchars-heartbeat-acks.test.ts"],
+  },
+  {
+    key: "suppressToolErrorWarnings",
+    schemaPaths: [
+      "agents.defaults.heartbeat.suppressToolErrorWarnings",
+      "agents.list.*.heartbeat.suppressToolErrorWarnings",
+    ],
+    typePaths: ["src/config/types.agent-defaults.ts", "src/config/zod-schema.agent-runtime.ts"],
+    mergePaths: ["src/infra/heartbeat-runner.ts"],
+    consumerPaths: ["src/infra/heartbeat-runner.ts"],
+    reloadPaths: ["src/gateway/config-reload-plan.ts"],
+    testPaths: ["src/infra/heartbeat-runner.model-override.test.ts"],
+  },
+  {
+    key: "timeoutSeconds",
+    schemaPaths: [
+      "agents.defaults.heartbeat.timeoutSeconds",
+      "agents.list.*.heartbeat.timeoutSeconds",
+    ],
+    typePaths: ["src/config/types.agent-defaults.ts", "src/config/zod-schema.agent-runtime.ts"],
+    mergePaths: ["src/infra/heartbeat-runner.ts"],
+    consumerPaths: ["src/infra/heartbeat-runner.ts", "src/auto-reply/reply/get-reply.ts"],
+    reloadPaths: ["src/gateway/config-reload-plan.ts"],
+    testPaths: [
+      "src/config/zod-schema.agent-defaults.test.ts",
+      "src/infra/heartbeat-runner.model-override.test.ts",
+    ],
+  },
+  {
+    key: "lightContext",
+    schemaPaths: ["agents.defaults.heartbeat.lightContext", "agents.list.*.heartbeat.lightContext"],
+    typePaths: ["src/config/types.agent-defaults.ts", "src/config/zod-schema.agent-runtime.ts"],
+    mergePaths: ["src/infra/heartbeat-runner.ts"],
+    consumerPaths: ["src/infra/heartbeat-runner.ts", "src/agents/bootstrap-files.ts"],
+    reloadPaths: ["src/gateway/config-reload-plan.ts"],
+    testPaths: [
+      "src/infra/heartbeat-runner.model-override.test.ts",
+      "src/agents/bootstrap-files.test.ts",
+      "src/gateway/config-reload.test.ts",
+    ],
+  },
+  {
+    key: "isolatedSession",
+    schemaPaths: [
+      "agents.defaults.heartbeat.isolatedSession",
+      "agents.list.*.heartbeat.isolatedSession",
+    ],
+    typePaths: ["src/config/types.agent-defaults.ts", "src/config/zod-schema.agent-runtime.ts"],
+    mergePaths: ["src/infra/heartbeat-runner.ts"],
+    consumerPaths: ["src/infra/heartbeat-runner.ts"],
+    reloadPaths: ["src/gateway/config-reload-plan.ts"],
+    testPaths: ["src/infra/heartbeat-runner.model-override.test.ts"],
+  },
+  {
+    key: "target",
+    schemaPaths: ["agents.defaults.heartbeat.target", "agents.list.*.heartbeat.target"],
+    typePaths: ["src/config/types.agent-defaults.ts", "src/config/zod-schema.agent-runtime.ts"],
+    mergePaths: ["src/infra/heartbeat-runner.ts", "src/infra/outbound/targets.ts"],
+    consumerPaths: ["src/infra/outbound/targets.ts", "src/infra/heartbeat-runner.ts"],
+    reloadPaths: ["src/gateway/config-reload-plan.ts"],
+    testPaths: [
+      "src/infra/heartbeat-runner.returns-default-unset.test.ts",
+      "src/cron/service.main-job-passes-heartbeat-target-last.test.ts",
+    ],
+  },
+  {
+    key: "to",
+    schemaPaths: ["agents.defaults.heartbeat.to", "agents.list.*.heartbeat.to"],
+    typePaths: ["src/config/types.agent-defaults.ts", "src/config/zod-schema.agent-runtime.ts"],
+    mergePaths: ["src/infra/heartbeat-runner.ts", "src/infra/outbound/targets.ts"],
+    consumerPaths: ["src/infra/outbound/targets.ts"],
+    reloadPaths: ["src/gateway/config-reload-plan.ts"],
+    testPaths: ["src/infra/heartbeat-runner.returns-default-unset.test.ts"],
+  },
+  {
+    key: "accountId",
+    schemaPaths: ["agents.defaults.heartbeat.accountId", "agents.list.*.heartbeat.accountId"],
+    typePaths: ["src/config/types.agent-defaults.ts", "src/config/zod-schema.agent-runtime.ts"],
+    mergePaths: ["src/infra/heartbeat-runner.ts", "src/infra/outbound/targets.ts"],
+    consumerPaths: ["src/infra/outbound/targets.ts", "src/infra/heartbeat-runner.ts"],
+    reloadPaths: ["src/gateway/config-reload-plan.ts"],
+    testPaths: [
+      "src/infra/heartbeat-runner.returns-default-unset.test.ts",
+      "src/infra/heartbeat-runner.respects-ackmaxchars-heartbeat-acks.test.ts",
+    ],
+  },
+  {
+    key: "directPolicy",
+    schemaPaths: ["agents.defaults.heartbeat.directPolicy", "agents.list.*.heartbeat.directPolicy"],
+    typePaths: ["src/config/types.agent-defaults.ts", "src/config/zod-schema.agent-runtime.ts"],
+    mergePaths: ["src/infra/heartbeat-runner.ts", "src/infra/outbound/targets.ts"],
+    consumerPaths: ["src/infra/outbound/targets.ts"],
+    reloadPaths: ["src/gateway/config-reload-plan.ts"],
+    testPaths: ["src/infra/heartbeat-runner.returns-default-unset.test.ts"],
+  },
+  {
+    key: "includeReasoning",
+    schemaPaths: [
+      "agents.defaults.heartbeat.includeReasoning",
+      "agents.list.*.heartbeat.includeReasoning",
+    ],
+    typePaths: ["src/config/types.agent-defaults.ts", "src/config/zod-schema.agent-runtime.ts"],
+    mergePaths: ["src/infra/heartbeat-runner.ts"],
+    consumerPaths: ["src/infra/heartbeat-runner.ts"],
+    reloadPaths: ["src/gateway/config-reload-plan.ts"],
+    testPaths: ["src/infra/heartbeat-runner.returns-default-unset.test.ts"],
+  },
+];

test/helpers/config/redact-snapshot-test-hints.ts

@@ -0,0 +1,18 @@
+// Redaction snapshot hints list config UI hints used by redaction tests.
+import type { ConfigUiHints } from "../../../src/config/schema.js";
+
+// Keep this fixture minimal so redaction tests exercise the hint-matching
+// behavior they care about without paying to build the full config schema graph.
+export const redactSnapshotTestHints: ConfigUiHints = {
+  "agents.defaults.memorySearch.remote.apiKey": { sensitive: true },
+  "agents.list[].memorySearch.remote.apiKey": { sensitive: true },
+  "broadcast.apiToken[]": { sensitive: true },
+  "env.GROQ_API_KEY": { sensitive: true },
+  "gateway.auth.password": { sensitive: true },
+  "models.providers.*.apiKey": { sensitive: true },
+  "models.providers.*.baseUrl": { sensitive: true },
+  "models.providers.*.request.headers.*": { sensitive: true },
+  "models.providers.*.request.auth.token": { sensitive: true },
+  "models.providers.*.request.proxy.url": { sensitive: true },
+  "skills.entries.*.env.GEMINI_API_KEY": { sensitive: true },
+};