openclaw-clawtown-plugin 1.1.27 → 1.1.30

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "openclaw-clawtown-plugin",
   "name": "OpenClaw Clawtown Plugin",
   "description": "Connects an OpenClaw agent to OpenClaw Forum and reports forum actions",
-  "version": "1.1.27",
+  "version": "1.1.30",
   "main": "./index.ts",
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-clawtown-plugin",
-  "version": "1.1.27",
+  "version": "1.1.30",
   "description": "Forum reporter plugin for OpenClaw Forum (Clawtown)",
   "license": "MIT",
   "main": "index.ts",

package/reporter.ts

@@ -21,6 +21,8 @@ const TASK_TIMEOUT_RETRY_MS = 190_000;
 const ACTION_CONTEXT_TIMEOUT_SECONDS = 115;
 const ACTION_CONTEXT_TIMEOUT_MS = 125_000;
 const API_FETCH_TIMEOUT_MS = 20_000;
+const FORUM_FETCH_RETRY_COUNT = 2;
+const FORUM_FETCH_RETRY_DELAYS_MS = [1_500, 3_000];
 const AUTO_PROVISION_RETRY_COUNT = 3;
 const AUTO_PROVISION_RETRY_DELAYS_MS = [1_500, 3_000, 5_000];
 const PROFILE_SYNC_RETRY_COUNT = 3;
@@ -32,6 +34,7 @@ const RECONNECT_BASE_MS = 3_000;
 const RECONNECT_MAX_MS = 5 * 60_000;
 const CONNECTION_SELF_HEAL_INTERVAL_MS = 30_000;
 const CONNECTING_STALE_MS = 20_000;
+const FAILED_MINE_TASK_LOCAL_SUPPRESS_MS = 24 * 60 * 60_000;
 const FORUM_ISOLATED_HOME_DIRNAME = ".openclaw-forum";
 const DEFAULT_OPENCLAW_HOME_DIRNAME = ".openclaw";
 const PLUGIN_ID = "openclaw-clawtown-plugin";
@@ -162,6 +165,14 @@ interface AuthHealthCheck {
   reason: string;
 }
 
+interface AuthProviderSnapshot {
+  storePath: string;
+  modelsPath: string;
+  availableProviders: string[];
+  invalidProfileIds: string[];
+  storeStatus: "missing" | "invalid_json" | "invalid_store" | "ok";
+}
+
 interface SyncProfileResult {
   ok: boolean;
   status?: number;
@@ -234,6 +245,7 @@ class Reporter {
   private activeTaskDedupKey = "";
   private queuedTaskDedupKeys = new Set<string>();
   private pendingContextUpdates = new Map<string, PendingQuestionContextUpdate>();
+  private locallySuppressedMineTasks = new Map<string, number>();
   private sessionHintLogged = false;
   private instanceLockPath: string | null = null;
   private instanceLockHeld = false;
@@ -292,7 +304,14 @@ class Reporter {
       isolationMode: this.openClawIsolationMode,
       isolationActive: Boolean(this.forcedOpenClawHome),
     };
-    const authHealth = inspectAuthHealthForStateDir(resolveStateDirForConfiguredHome(this.forcedOpenClawHome));
+    const stateDir = resolveStateDirForConfiguredHome(this.forcedOpenClawHome);
+    let authHealth = inspectAuthHealthForStateDir(stateDir);
+    if (!authHealth.ok) {
+      const repair = repairForumModelConfigForAvailableAuth(stateDir, authHealth);
+      if (repair.changed) {
+        authHealth = inspectAuthHealthForStateDir(stateDir);
+      }
+    }
     this.authHealth = authHealth;
     if (!authHealth.ok) {
       console.error(`[forum-reporter-v2] ${formatAuthHealthFailure(authHealth)}`);
@@ -638,6 +657,10 @@ class Reporter {
     if (message.event === "task_push") {
       const qid = String((message.payload as any)?.questionId ?? "").trim();
       const tid = String((message.payload as any)?.taskId ?? "").trim();
+      if ((message.taskType === "mine_draft" || message.taskType === "mine_followup") && tid && this.isMineTaskLocallySuppressed(tid)) {
+        console.log(`[forum-reporter-v2] stale mine task_push dropped by local suppressor: ${String(message.taskType)} taskId=${tid}`);
+        return;
+      }
       const dedupKey = buildTaskDedupKey(message);
       this.lastTaskPushAt = Date.now();
       if (dedupKey && (this.activeTaskDedupKey === dedupKey || this.queuedTaskDedupKeys.has(dedupKey))) {
@@ -837,13 +860,19 @@ class Reporter {
     if (!serverFeedback) return;
     console.warn(`[forum-reporter-v2] task feedback: ${serverFeedback.replace(/\s+/g, " ").trim()}`);
     console.warn(`[forum-reporter-v2] submit rejected for taskType=${taskType}, retry once with server feedback`);
-    const retryInstructions = buildRetryInstructions(baseInstructions, serverFeedback);
+    const retryInstructions = buildSubmitRetryInstructions(taskType, baseInstructions, serverFeedback, normalized.payload);
     let retryOutput = "";
     try {
+      const submitRetryTimeoutSeconds = taskType === "mine_draft" || taskType === "mine_followup"
+        ? TASK_TIMEOUT_RETRY_SECONDS
+        : TASK_FIRST_TURN_TIMEOUT_SECONDS;
+      const submitRetryTimeoutMs = taskType === "mine_draft" || taskType === "mine_followup"
+        ? TASK_TIMEOUT_RETRY_MS
+        : TASK_FIRST_TURN_TIMEOUT_MS;
       retryOutput = await runTaskTurn(
         retryInstructions,
-        TASK_FIRST_TURN_TIMEOUT_SECONDS,
-        TASK_FIRST_TURN_TIMEOUT_MS,
+        submitRetryTimeoutSeconds,
+        submitRetryTimeoutMs,
         `${tid || qid || taskType}-submit-retry1`,
       );
     } catch (error: any) {
@@ -904,6 +933,12 @@ class Reporter {
     if (!submitRes.ok) {
       const reasonCode = String(input.payload?.reasonCode ?? "");
       const bodyError = String(body.error ?? "").trim();
+      if (input.kind === "mine_task" && bodyError === "task_blocked_for_failed_robot") {
+        const taskId = String(input.payload?.taskId ?? "").trim();
+        if (taskId) {
+          this.rememberSuppressedMineTask(taskId, FAILED_MINE_TASK_LOCAL_SUPPRESS_MS);
+        }
+      }
       const logLine = `[forum-reporter-v2] action-response failed: ${submitRes.status} ${rawText}${reasonCode ? ` (reasonCode=${reasonCode})` : ""}`;
       if (isExpectedSubmitConflict(bodyError)) {
         console.log(logLine);
@@ -972,7 +1007,7 @@ class Reporter {
           openClawIdentity: identity ?? undefined,
           reporterRuntime: this.reporterRuntime,
         }),
-      });
+      }, { retryOnNetworkError: true });
       if (!res.ok) {
         const text = await res.text().catch(() => "");
         return {
@@ -1039,7 +1074,7 @@ class Reporter {
         const res = await this.forumFetch("/api/regenerate-pair-code", {
           method: "POST",
           headers: { "x-api-key": this.apiKey },
-        });
+        }, { retryOnNetworkError: true });
         if (!res.ok) {
           const text = await res.text().catch(() => "");
           const error = new Error(`regenerate pair code failed: ${res.status} ${truncate(text || "request failed", 240)}`);
@@ -1078,7 +1113,7 @@ class Reporter {
       method: "GET",
       headers: { "x-api-key": this.apiKey },
       cache: "no-store",
-    });
+    }, { retryOnNetworkError: true });
     if (res.status === 204) return;
     if (!res.ok) {
       const text = await res.text().catch(() => "");
@@ -1311,9 +1346,52 @@ class Reporter {
     this.instanceLockHeld = false;
   }
 
-  private async forumFetch(inputPath: string, init?: RequestInit) {
+  private async forumFetch(
+    inputPath: string,
+    init?: RequestInit,
+    options?: {
+      retryOnNetworkError?: boolean;
+      maxAttempts?: number;
+      retryDelaysMs?: number[];
+    },
+  ) {
     const target = new URL(inputPath, this.serverUrl).toString();
-    return fetchWithTimeout(target, init, API_FETCH_TIMEOUT_MS);
+    const shouldRetry = Boolean(options?.retryOnNetworkError);
+    const maxAttempts = shouldRetry ? Math.max(1, options?.maxAttempts ?? (1 + FORUM_FETCH_RETRY_COUNT)) : 1;
+    let lastError: unknown = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+      try {
+        return await fetchWithTimeout(target, init, API_FETCH_TIMEOUT_MS);
+      } catch (error) {
+        lastError = error;
+        if (!shouldRetry || attempt >= maxAttempts || !shouldRetryAutoProvisionError(error)) {
+          throw error;
+        }
+      }
+      const delays = options?.retryDelaysMs ?? FORUM_FETCH_RETRY_DELAYS_MS;
+      const delayMs = delays[Math.min(attempt - 1, delays.length - 1)] ?? 1_500;
+      console.warn(
+        `[forum-reporter-v2] forumFetch retry ${attempt}/${maxAttempts} failed for ${inputPath}: ${describeAutoProvisionError(lastError)}; retrying in ${Math.round(delayMs / 1000)}s`,
+      );
+      await sleep(delayMs);
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError ?? "unknown"));
+  }
+
+  private isMineTaskLocallySuppressed(taskId: string) {
+    const until = this.locallySuppressedMineTasks.get(taskId);
+    if (!until) return false;
+    if (until <= Date.now()) {
+      this.locallySuppressedMineTasks.delete(taskId);
+      return false;
+    }
+    return true;
+  }
+
+  private rememberSuppressedMineTask(taskId: string, durationMs: number) {
+    if (!taskId) return;
+    const until = Date.now() + Math.max(60_000, durationMs);
+    this.locallySuppressedMineTasks.set(taskId, until);
   }
 }
 
@@ -1753,6 +1831,53 @@ function buildRetryInstructions(baseInstructions: string, feedback: string) {
   ].join("\n");
 }
 
+function buildSubmitRetryInstructions(
+  taskType: PushTaskType,
+  baseInstructions: string,
+  feedback: string,
+  currentPayload?: Record<string, any>,
+) {
+  if ((taskType !== "mine_draft" && taskType !== "mine_followup") || !currentPayload) {
+    return buildRetryInstructions(baseInstructions, feedback);
+  }
+  const taskId = String(currentPayload.taskId ?? "").trim();
+  const title = cleanSerializationArtifacts(coerceToString(currentPayload.title));
+  const coreFindings = cleanSerializationArtifacts(coerceToString(currentPayload.coreFindings));
+  const cases = cleanSerializationArtifacts(coerceToString(currentPayload.cases));
+  const opinion = cleanSerializationArtifacts(coerceToString(currentPayload.opinion));
+  const sources = Array.isArray(currentPayload.sources)
+    ? currentPayload.sources.map((item: any) => cleanSerializationArtifacts(coerceToString(item))).filter(Boolean)
+    : [];
+  if (!taskId || !title || !coreFindings || !cases || !opinion) {
+    return buildRetryInstructions(baseInstructions, feedback);
+  }
+  return [
+    V2_AGENT_RULES,
+    "",
+    "你现在在修补一份已经生成过、但被服务器规则打回的矿题稿件。",
+    "只修正失败点，不要从零开始发散重写。",
+    `taskId: ${taskId}`,
+    `矿题：${title}`,
+    "",
+    "服务器反馈（必须逐条修正）：",
+    String(feedback || "").trim(),
+    "",
+    "你刚才提交的稿件：",
+    `title=${truncate(title, 160)}`,
+    `coreFindings=${truncate(coreFindings, 2_400)}`,
+    `cases=${truncate(cases, 1_600)}`,
+    `opinion=${truncate(opinion, 1_200)}`,
+    `sources=${sources.slice(0, 8).join(" | ") || "[]"}`,
+    "",
+    "修补要求：",
+    "1. 保留已有有效内容，只修改被打回的部分。",
+    "2. 如果反馈提到来源或 URL，sources 数组里至少要有 1 条明确可访问的 http(s):// URL。",
+    "3. 只输出一个 JSON 对象，字段只能是 title、coreFindings、cases、opinion、sources。",
+    "4. 不要输出解释、不要输出 markdown、不要输出额外文本。",
+    "{\"title\":\"...\",\"coreFindings\":\"...\",\"cases\":\"...\",\"opinion\":\"...\",\"sources\":[\"https://...\"]}",
+  ].join("\n");
+}
+
 function buildFallbackTaskInstructions(taskType: PushTaskType, payload: Record<string, any>) {
   if (taskType === "answer_question") {
     const minLength = Math.max(MIN_ANSWER_LENGTH, Number(payload.minLength ?? MIN_ANSWER_LENGTH) || MIN_ANSWER_LENGTH);
@@ -2515,21 +2640,36 @@ function resolveStateDirForConfiguredHome(openclawHome: string) {
 function inspectAuthHealthForStateDir(stateDir: string): AuthHealthCheck {
   const configInfo = readOpenClawConfigInfo(stateDir);
   const requiredProviders = resolveConfiguredProviders(configInfo.config);
+  const providerSnapshot = readAuthProviderSnapshot(stateDir, configInfo.config);
+  const availableProviders = new Set<string>(providerSnapshot.availableProviders);
+  const missingProviders = requiredProviders.filter((provider) => !availableProviders.has(provider));
+  const reason = missingProviders.length
+    ? providerSnapshot.storeStatus === "ok" ? "missing_provider" : providerSnapshot.storeStatus
+    : "ok";
+  return {
+    ok: missingProviders.length === 0,
+    storePath: providerSnapshot.storePath,
+    modelsPath: providerSnapshot.modelsPath,
+    requiredProviders,
+    availableProviders: Array.from(availableProviders),
+    invalidProfileIds: providerSnapshot.invalidProfileIds,
+    missingProviders,
+    reason,
+  };
+}
+
+function readAuthProviderSnapshot(stateDir: string, config: Record<string, any> | null): AuthProviderSnapshot {
   const storePath = path.join(stateDir, "agents", "main", "agent", "auth-profiles.json");
   const modelsPath = path.join(stateDir, "agents", "main", "agent", "models.json");
-  const availableProviders = new Set<string>(readInlineCredentialProviders(stateDir, configInfo.config));
+  const availableProviders = new Set<string>(readInlineCredentialProviders(stateDir, config));
   const invalidProfileIds: string[] = [];
   if (!fs.existsSync(storePath)) {
-    const missingProviders = requiredProviders.filter((provider) => !availableProviders.has(provider));
     return {
-      ok: missingProviders.length === 0,
       storePath,
       modelsPath,
-      requiredProviders,
       availableProviders: Array.from(availableProviders),
       invalidProfileIds,
-      missingProviders,
-      reason: missingProviders.length ? "missing_store" : "ok",
+      storeStatus: "missing",
     };
   }
   let parsed: Record<string, any> | null = null;
@@ -2537,14 +2677,11 @@ function inspectAuthHealthForStateDir(stateDir: string): AuthHealthCheck {
     parsed = JSON.parse(fs.readFileSync(storePath, "utf-8"));
   } catch {
     return {
-      ok: false,
       storePath,
       modelsPath,
-      requiredProviders,
       availableProviders: Array.from(availableProviders),
       invalidProfileIds,
-      missingProviders: requiredProviders.filter((provider) => !availableProviders.has(provider)),
-      reason: "invalid_json",
+      storeStatus: "invalid_json",
     };
   }
   const profiles = parsed?.profiles && typeof parsed.profiles === "object"
@@ -2552,14 +2689,11 @@ function inspectAuthHealthForStateDir(stateDir: string): AuthHealthCheck {
     : null;
   if (!profiles) {
     return {
-      ok: false,
       storePath,
       modelsPath,
-      requiredProviders,
       availableProviders: Array.from(availableProviders),
       invalidProfileIds,
-      missingProviders: requiredProviders.filter((provider) => !availableProviders.has(provider)),
-      reason: "invalid_store",
+      storeStatus: "invalid_store",
     };
   }
   for (const [profileId, profile] of Object.entries(profiles)) {
@@ -2570,16 +2704,12 @@ function inspectAuthHealthForStateDir(stateDir: string): AuthHealthCheck {
     }
     availableProviders.add(normalized.provider);
   }
-  const missingProviders = requiredProviders.filter((provider) => !availableProviders.has(provider));
   return {
-    ok: missingProviders.length === 0,
     storePath,
     modelsPath,
-    requiredProviders,
     availableProviders: Array.from(availableProviders),
     invalidProfileIds,
-    missingProviders,
-    reason: missingProviders.length ? "missing_provider" : "ok",
+    storeStatus: "ok",
   };
 }
 
@@ -2734,6 +2864,184 @@ function formatAuthHealthFailure(health: AuthHealthCheck) {
   return parts.join(" | ");
 }
 
+function repairForumModelConfigForAvailableAuth(stateDir: string, authHealth?: AuthHealthCheck | null) {
+  const configInfo = readOpenClawConfigInfo(stateDir);
+  if (!configInfo.path || !configInfo.config) {
+    return { changed: false, previousPrimary: "", nextPrimary: "", reason: "missing_config" };
+  }
+  const config = cloneJson(configInfo.config);
+  const previousPrimary = resolvePrimaryModelRef(config);
+  const previousProvider = extractProviderFromModelRef(previousPrimary);
+  const snapshot = readAuthProviderSnapshot(stateDir, config);
+  const availableProviders = new Set(snapshot.availableProviders);
+  if (!availableProviders.size) {
+    return { changed: false, previousPrimary, nextPrimary: "", reason: "no_available_provider" };
+  }
+  if (previousProvider && availableProviders.has(previousProvider) && (!authHealth || authHealth.ok)) {
+    return { changed: false, previousPrimary, nextPrimary: previousPrimary, reason: "current_provider_ok" };
+  }
+  const candidateRefs = collectUsableModelRefsForProviders(stateDir, config, availableProviders);
+  const nextPrimary = candidateRefs[0] ?? "";
+  if (!nextPrimary || nextPrimary === previousPrimary) {
+    return { changed: false, previousPrimary, nextPrimary, reason: nextPrimary ? "already_best" : "no_candidate_model" };
+  }
+  let changed = setPreferredPrimaryModelRef(config, nextPrimary);
+  changed = ensurePreferredModelEntry(config, nextPrimary) || changed;
+  changed = filterFallbackModelRefs(config, availableProviders) || changed;
+  if (!changed) {
+    return { changed: false, previousPrimary, nextPrimary, reason: "no_config_change" };
+  }
+  writeOpenClawConfig(configInfo.path, config);
+  console.warn(`[forum-reporter-v2] forum model auto-healed: ${previousPrimary || "none"} -> ${nextPrimary} (available providers: ${Array.from(availableProviders).join(", ")})`);
+  return { changed: true, previousPrimary, nextPrimary, reason: "healed" };
+}
+
+function resolvePrimaryModelRef(config: Record<string, any> | null) {
+  const candidates = [
+    config?.agents?.defaults?.model?.primary,
+    config?.agent?.model?.primary,
+    config?.model?.primary,
+  ];
+  for (const value of candidates) {
+    const raw = String(value ?? "").trim();
+    if (raw.includes("/")) return raw;
+  }
+  return "";
+}
+
+function extractProviderFromModelRef(modelRef: string) {
+  const raw = String(modelRef ?? "").trim();
+  if (!raw || !raw.includes("/")) return "";
+  return raw.slice(0, raw.indexOf("/")).trim().toLowerCase();
+}
+
+function collectUsableModelRefsForProviders(
+  stateDir: string,
+  config: Record<string, any> | null,
+  availableProviders: Set<string>,
+) {
+  const orderedRefs: string[] = [];
+  const seen = new Set<string>();
+  const push = (value: unknown) => {
+    const raw = String(value ?? "").trim();
+    if (!raw || !raw.includes("/")) return;
+    const provider = extractProviderFromModelRef(raw);
+    if (!provider || !availableProviders.has(provider) || seen.has(raw)) return;
+    seen.add(raw);
+    orderedRefs.push(raw);
+  };
+  const visitModelNode = (value: unknown) => {
+    if (typeof value === "string") {
+      push(value);
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) visitModelNode(item);
+      return;
+    }
+    if (!value || typeof value !== "object") return;
+    for (const [key, nested] of Object.entries(value)) {
+      if (key === "providers" || key === "mode") continue;
+      if (typeof nested === "string") {
+        push(nested);
+        if (nested.includes("/")) continue;
+      }
+      visitModelNode(nested);
+    }
+  };
+  visitModelNode(config?.agents?.defaults?.model);
+  visitModelNode(config?.agent?.model);
+  visitModelNode(config?.model);
+  visitModelNode(config?.agents?.defaults?.models);
+  visitModelNode(config?.agent?.models);
+  visitModelNode(config?.models);
+  appendProviderModelsToList(orderedRefs, seen, config?.agents?.defaults?.models?.providers, availableProviders);
+  appendProviderModelsToList(orderedRefs, seen, config?.agent?.models?.providers, availableProviders);
+  appendProviderModelsToList(orderedRefs, seen, config?.models?.providers, availableProviders);
+  try {
+    const modelsPath = path.join(stateDir, "agents", "main", "agent", "models.json");
+    if (fs.existsSync(modelsPath)) {
+      const parsed = JSON.parse(fs.readFileSync(modelsPath, "utf-8"));
+      appendProviderModelsToList(orderedRefs, seen, parsed?.providers, availableProviders);
+    }
+  } catch {}
+  return orderedRefs;
+}
+
+function appendProviderModelsToList(
+  orderedRefs: string[],
+  seen: Set<string>,
+  providerMap: Record<string, any> | null | undefined,
+  availableProviders: Set<string>,
+) {
+  if (!providerMap || typeof providerMap !== "object") return;
+  for (const [providerName, providerConfig] of Object.entries(providerMap)) {
+    const normalizedProvider = String(providerName ?? "").trim().toLowerCase();
+    if (!normalizedProvider || !availableProviders.has(normalizedProvider)) continue;
+    const models = Array.isArray((providerConfig as any)?.models) ? (providerConfig as any).models : [];
+    for (const model of models) {
+      const modelId = String((model as any)?.id ?? "").trim();
+      if (!modelId) continue;
+      const modelRef = `${normalizedProvider}/${modelId}`;
+      if (seen.has(modelRef)) continue;
+      seen.add(modelRef);
+      orderedRefs.push(modelRef);
+    }
+  }
+}
+
+function setPreferredPrimaryModelRef(config: Record<string, any>, modelRef: string) {
+  let changed = false;
+  const defaultsModel = (((config.agents ??= {}).defaults ??= {}).model ??= {});
+  if (defaultsModel.primary !== modelRef) {
+    defaultsModel.primary = modelRef;
+    changed = true;
+  }
+  if (!Array.isArray(defaultsModel.fallbacks)) {
+    defaultsModel.fallbacks = [];
+    changed = true;
+  }
+  const legacyRoots = [
+    config.agent?.model,
+    config.model,
+  ];
+  for (const root of legacyRoots) {
+    if (!root || typeof root !== "object") continue;
+    if (root.primary !== modelRef) {
+      root.primary = modelRef;
+      changed = true;
+    }
+  }
+  return changed;
+}
+
+function ensurePreferredModelEntry(config: Record<string, any>, modelRef: string) {
+  const models = (((config.agents ??= {}).defaults ??= {}).models ??= {});
+  if (models[modelRef] && typeof models[modelRef] === "object") {
+    return false;
+  }
+  models[modelRef] = {};
+  return true;
+}
+
+function filterFallbackModelRefs(config: Record<string, any>, availableProviders: Set<string>) {
+  let changed = false;
+  const lists = [
+    (((config.agents ??= {}).defaults ??= {}).model ??= {}).fallbacks,
+    config.agent?.model?.fallbacks,
+    config.model?.fallbacks,
+  ];
+  for (const current of lists) {
+    if (!Array.isArray(current)) continue;
+    const filtered = current.filter((value) => availableProviders.has(extractProviderFromModelRef(String(value ?? ""))));
+    if (filtered.length !== current.length) {
+      current.splice(0, current.length, ...filtered);
+      changed = true;
+    }
+  }
+  return changed;
+}
+
 function syncReporterConfigToForum(
   sourceLocalConfig: ReturnType<typeof readLocalReporterConfig>,
   forumStateDir: string,
@@ -2789,7 +3097,7 @@ function syncOpenClawConfigs(
     changed = writeOpenClawConfig(defaultInfo.path, normalizedDefault) || changed;
   }
 
-  const forumBaseConfig = forumInfo.config ?? defaultInfo.config ?? {};
+  const forumBaseConfig = mergeOpenClawConfig(defaultInfo.config ?? {}, forumInfo.config ?? {});
   const normalizedForum = normalizeForumHomeConfig(forumBaseConfig, forumStateDir, runtimeInfo, defaultInfo.config, forumInfo.config);
   changed = writeOpenClawConfig(targetForumConfigPath, normalizedForum) || changed;
   return changed;
@@ -2934,6 +3242,44 @@ function writeOpenClawConfig(filePath: string, nextConfig: Record<string, any>)
   return true;
 }
 
+function mergeOpenClawConfig(
+  baseConfig: Record<string, any> | null | undefined,
+  overlayConfig: Record<string, any> | null | undefined,
+) {
+  const base = cloneJson(baseConfig ?? {});
+  const overlay = cloneJson(overlayConfig ?? {});
+  return deepMergePlainObjects(base, overlay);
+}
+
+function deepMergePlainObjects(base: any, overlay: any): any {
+  if (Array.isArray(overlay)) return cloneJson(overlay);
+  if (!overlay || typeof overlay !== "object") {
+    return overlay === undefined ? cloneJson(base) : overlay;
+  }
+  const result = isPlainObject(base) ? cloneJson(base) : {};
+  for (const [key, overlayValue] of Object.entries(overlay)) {
+    const baseValue = result[key];
+    if (Array.isArray(overlayValue)) {
+      result[key] = cloneJson(overlayValue);
+      continue;
+    }
+    if (isPlainObject(overlayValue) && isPlainObject(baseValue)) {
+      result[key] = deepMergePlainObjects(baseValue, overlayValue);
+      continue;
+    }
+    if (isPlainObject(overlayValue)) {
+      result[key] = deepMergePlainObjects({}, overlayValue);
+      continue;
+    }
+    result[key] = overlayValue;
+  }
+  return result;
+}
+
+function isPlainObject(value: unknown) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
 function cloneJson<T>(input: T): T {
   try {
     return JSON.parse(JSON.stringify(input)) as T;