ylib-syim 0.0.14 → 0.0.16

package/bridges/main.ts

@@ -41,6 +41,58 @@ const runtimeErrorLogFallbackLines = Math.max(
       String(RUNTIME_ERROR_LOG_FALLBACK_LINES_DEFAULT),
   ) || RUNTIME_ERROR_LOG_FALLBACK_LINES_DEFAULT,
 );
+const RUNTIME_LOG_DOWNLOAD_MAX_BYTES_DEFAULT = 2 * 1024 * 1024;
+const runtimeLogDownloadMaxBytes = Math.max(
+  64 * 1024,
+  Number(
+    process.env.RUNTIME_LOG_DOWNLOAD_MAX_BYTES ||
+      String(RUNTIME_LOG_DOWNLOAD_MAX_BYTES_DEFAULT),
+  ) || RUNTIME_LOG_DOWNLOAD_MAX_BYTES_DEFAULT,
+);
+const runtimeStatusProbeIntervalMs = Math.max(
+  0,
+  Number(process.env.RUNTIME_STATUS_PROBE_INTERVAL_MS || "15000") || 15000,
+);
+const runtimeStatusProbeTtlMs = Math.max(
+  0,
+  Number(
+    process.env.RUNTIME_STATUS_PROBE_TTL_MS ||
+      String(Math.max(1000, runtimeStatusProbeIntervalMs || 15000)),
+  ) || Math.max(1000, runtimeStatusProbeIntervalMs || 15000),
+);
+const runtimeStatusProbeTimeoutMs = Math.max(
+  500,
+  Number(process.env.RUNTIME_STATUS_PROBE_TIMEOUT_MS || "3000") || 3000,
+);
+const runtimeStatusProbeTimeoutMsWeixin = Math.max(
+  runtimeStatusProbeTimeoutMs,
+  Number(process.env.RUNTIME_STATUS_PROBE_TIMEOUT_MS_WEIXIN || "4000") || 4000,
+);
+const runtimeStatusProbeConcurrency = {
+  dingtalk: Math.max(
+    1,
+    Number(process.env.RUNTIME_STATUS_PROBE_CONCURRENCY_DINGTALK || "4") || 4,
+  ),
+  feishu: Math.max(
+    1,
+    Number(process.env.RUNTIME_STATUS_PROBE_CONCURRENCY_FEISHU || "4") || 4,
+  ),
+  weixin: Math.max(
+    1,
+    Number(process.env.RUNTIME_STATUS_PROBE_CONCURRENCY_WEIXIN || "2") || 2,
+  ),
+};
+const runtimeEventHeartbeatMs = Math.max(
+  1000,
+  Number(process.env.RUNTIME_EVENT_HEARTBEAT_MS || "20000") || 20000,
+);
+const runtimeEventHeartbeatStaleMs = Math.max(
+  runtimeEventHeartbeatMs,
+  Number(
+    process.env.RUNTIME_EVENT_HEARTBEAT_STALE_MS ||
+      String(runtimeEventHeartbeatMs * 3),
+  ) || runtimeEventHeartbeatMs * 3,
+);
 
 type RuntimeBotStatus = {
   platform: "dingtalk" | "feishu" | "weixin";
@@ -60,7 +112,16 @@ type RuntimeBotStatus = {
   last_probe_at?: string | null;
 };
 
+type RuntimeHeartbeatEntry = {
+  platform: "dingtalk" | "feishu" | "weixin";
+  bot_account_id: string;
+  last_heartbeat_at: string;
+  last_event?: string | null;
+};
+
 const runtimeStatusRegistry = new Map<string, RuntimeBotStatus>();
+const runtimeHeartbeatRegistry = new Map<string, RuntimeHeartbeatEntry>();
+let runtimeHeartbeatLastReceivedAt: string | null = null;
 let loadedConfigForRuntime: Record<string, unknown> | null = {
   channels: {},
   bindings: [],
@@ -78,6 +139,14 @@ let larkBridgeStarting = false;
 let weixinBridgeStarted = false;
 let weixinBridgeStarting = false;
 let pluginTempHomeDir: string | null = null;
+let probeInFlight: Promise<void> | null = null;
+let lastProbeStartedAt: string | null = null;
+let lastProbeFinishedAt: string | null = null;
+let lastProbeDurationMs = 0;
+let runtimeStatusCacheHitTotal = 0;
+let runtimeStatusSingleflightReusedTotal = 0;
+let runtimeStatusProbeTimeoutTotal = 0;
+const botControlInFlight = new Set<string>();
 
 type RuntimeGatewayChannel = "dingtalk" | "feishu" | "weixin";
 
@@ -87,6 +156,21 @@ type RuntimeGatewayInvokeResult = {
   result?: unknown;
 };
 
+type RuntimePlatform = "dingtalk" | "feishu" | "weixin";
+
+type RuntimeBridgeControl = {
+  restart?: () => Promise<void>;
+  stop?: () => Promise<void>;
+  startAccount?: (accountId: string) => Promise<void>;
+  stopAccount?: (accountId: string) => Promise<void>;
+  restartAccount?: (accountId: string) => Promise<void>;
+};
+
+type ProbeRefreshOptions = {
+  force?: boolean;
+  reason?: string;
+};
+
 function pluginHomeConfigPayload(
   cfg: Record<string, unknown>,
 ): Record<string, unknown> {
@@ -99,7 +183,6 @@ function pluginHomeConfigPayload(
       : [],
   };
 }
-
 /** 远端配置拉取成功时：临时 HOME + ~/.syim/syim.json 与 ~/.openclaw/openclaw.json（内容一致）。 */
 function applyRemoteRuntimeConfigToPluginHome(): void {
   if (
@@ -137,6 +220,8 @@ function applyRemoteRuntimeConfigToPluginHome(): void {
       );
     }
     fs.writeFileSync(openclawPath, payload, "utf-8");
+    // 让 openclaw host 与插件均优先读取 .syim/syim.json。
+    process.env.OPENCLAW_CONFIG_PATH = syimPath;
     process.env.HOME = pluginTempHomeDir;
     if (process.platform === "win32")
       process.env.USERPROFILE = pluginTempHomeDir;
@@ -176,6 +261,69 @@ function upsertRuntimeStatus(entry: RuntimeBotStatus): void {
   });
 }
 
+function upsertRuntimeHeartbeat(entry: RuntimeHeartbeatEntry): void {
+  const key = keyOf(entry.platform, entry.bot_account_id);
+  const previous = runtimeHeartbeatRegistry.get(key);
+  runtimeHeartbeatRegistry.set(key, {
+    ...previous,
+    ...entry,
+  });
+  runtimeHeartbeatLastReceivedAt = nowIso();
+}
+
+function isHeartbeatOnlyEvent(eventName: string | null | undefined): boolean {
+  const normalized = String(eventName || "")
+    .trim()
+    .toLowerCase();
+  return normalized === "runtime_heartbeat" || normalized === "heartbeat";
+}
+
+function buildRuntimeHeartbeatSnapshot(nowMs = Date.now()): {
+  heartbeat_ms: number;
+  stale_after_ms: number;
+  last_received_at: string | null;
+  entries: Array<{
+    platform: "dingtalk" | "feishu" | "weixin";
+    bot_account_id: string;
+    last_heartbeat_at: string | null;
+    age_ms: number | null;
+    stale: boolean;
+    last_event: string | null;
+  }>;
+} {
+  const entries = Array.from(runtimeHeartbeatRegistry.values())
+    .map((item) => {
+      const rawHeartbeatAt = String(item.last_heartbeat_at || "").trim();
+      const heartbeatAt = rawHeartbeatAt || null;
+      const parsedMs = heartbeatAt ? Date.parse(heartbeatAt) : Number.NaN;
+      const ageMs = Number.isNaN(parsedMs)
+        ? null
+        : Math.max(0, nowMs - parsedMs);
+      const stale = ageMs == null ? true : ageMs > runtimeEventHeartbeatStaleMs;
+      return {
+        platform: item.platform,
+        bot_account_id: item.bot_account_id,
+        last_heartbeat_at: heartbeatAt,
+        age_ms: ageMs,
+        stale,
+        last_event: item.last_event || null,
+      };
+    })
+    .sort((a, b) => {
+      if (a.platform !== b.platform) {
+        return a.platform.localeCompare(b.platform);
+      }
+      return a.bot_account_id.localeCompare(b.bot_account_id);
+    });
+
+  return {
+    heartbeat_ms: runtimeEventHeartbeatMs,
+    stale_after_ms: runtimeEventHeartbeatStaleMs,
+    last_received_at: runtimeHeartbeatLastReceivedAt,
+    entries,
+  };
+}
+
 function isGenericRuntimeErrorMessage(
   message: string | null | undefined,
 ): boolean {
@@ -324,16 +472,20 @@ function readRecentBridgeErrorFromLog(
 /** Bridge file lines from setupBridgeLogger: `[ISO] [log|info|warn|error|debug] message` */
 const BRIDGE_FILE_ERROR_LINE = /^\[[^\]]+\] \[error\] /;
 
+function getBridgeLoggerFilePath(): string {
+  const loggerState = (globalThis as Record<string, unknown>)
+    .__imAgentHubBridgeLogger as
+    | { enabled?: boolean; logFilePath?: string }
+    | undefined;
+  return String(loggerState?.logFilePath || "").trim();
+}
+
 function readRuntimeLogLines(limit: number): {
   log_file_path: string | null;
   lines: string[];
   log_level_filter: "error";
 } {
-  const loggerState = (globalThis as Record<string, unknown>)
-    .__imAgentHubBridgeLogger as
-    | { enabled?: boolean; logFilePath?: string }
-    | undefined;
-  const logFilePath = String(loggerState?.logFilePath || "").trim();
+  const logFilePath = getBridgeLoggerFilePath();
   const clampedLimit = Math.max(1, Math.min(1000, Number(limit) || 100));
   if (!logFilePath || !fs.existsSync(logFilePath)) {
     return {
@@ -363,6 +515,99 @@ function readRuntimeLogLines(limit: number): {
   }
 }
 
+function buildRuntimeLogDownloadFileName(logFilePath: string | null): string {
+  const candidate = String(logFilePath || "").trim();
+  if (candidate) {
+    const baseName = path.basename(candidate).trim();
+    if (baseName) return baseName;
+  }
+  return `im-agent-hub-runtime-${new Date().toISOString().replace(/[:.]/g, "-")}.log`;
+}
+
+function parseRuntimeLogDownloadMaxBytes(maxBytesRaw?: unknown): number {
+  return Math.max(
+    64 * 1024,
+    Math.min(
+      20 * 1024 * 1024,
+      Number(maxBytesRaw) || runtimeLogDownloadMaxBytes,
+    ),
+  );
+}
+
+function streamRuntimeLogDownload(
+  res: http.ServerResponse,
+  options?: { maxBytesRaw?: unknown },
+): void {
+  const maxBytes = parseRuntimeLogDownloadMaxBytes(options?.maxBytesRaw);
+  const logFilePath = getBridgeLoggerFilePath();
+  const fileName = buildRuntimeLogDownloadFileName(logFilePath || null);
+
+  const baseHeaders: Record<string, string> = {
+    "Content-Type": "text/plain; charset=utf-8",
+    "Content-Disposition": `attachment; filename="${fileName}"`,
+    "X-IM-Runtime-Log-File-Name": fileName,
+    "X-IM-Runtime-Log-Max-Bytes": String(maxBytes),
+    "X-IM-Runtime-Instance-Id": runtimeInstanceId,
+  };
+
+  if (!logFilePath || !fs.existsSync(logFilePath)) {
+    res.writeHead(200, {
+      ...baseHeaders,
+      "Content-Length": "0",
+      "X-IM-Runtime-Log-Truncated": "0",
+      "X-IM-Runtime-Log-Bytes": "0",
+    });
+    res.end();
+    return;
+  }
+
+  try {
+    const stat = fs.statSync(logFilePath);
+    const totalBytes = Math.max(0, Number(stat.size) || 0);
+    const start = Math.max(0, totalBytes - maxBytes);
+    const contentBytes = Math.max(0, totalBytes - start);
+    const truncated = start > 0;
+
+    if (totalBytes <= 0) {
+      res.writeHead(200, {
+        ...baseHeaders,
+        "Content-Length": "0",
+        "X-IM-Runtime-Log-Truncated": "0",
+        "X-IM-Runtime-Log-Bytes": "0",
+      });
+      res.end();
+      return;
+    }
+
+    res.writeHead(200, {
+      ...baseHeaders,
+      "Content-Length": String(contentBytes),
+      "X-IM-Runtime-Log-Truncated": truncated ? "1" : "0",
+      "X-IM-Runtime-Log-Bytes": String(contentBytes),
+    });
+
+    const stream = fs.createReadStream(logFilePath, { start });
+    stream.on("error", (err) => {
+      if (!res.headersSent) {
+        res.writeHead(500, {
+          "Content-Type": "text/plain; charset=utf-8",
+          "X-IM-Runtime-Read-Error": (err as Error).message.slice(0, 200),
+        });
+      }
+      if (!res.writableEnded) {
+        res.end(`read log failed: ${(err as Error).message}`);
+      }
+    });
+    stream.pipe(res);
+  } catch (err) {
+    res.writeHead(500, {
+      "Content-Type": "text/plain; charset=utf-8",
+      "X-IM-Runtime-Read-Error": (err as Error).message.slice(0, 200),
+    });
+    res.end(`read log failed: ${(err as Error).message}`);
+  }
+}
+
 function clearPlatformStatuses(
   platform: "dingtalk" | "feishu" | "weixin",
 ): void {
@@ -494,10 +739,10 @@ function markPlatformStarted(platform: "dingtalk" | "feishu" | "weixin"): void {
     if (!key.startsWith(`${platform}:`)) continue;
     runtimeStatusRegistry.set(key, {
       ...value,
-      link_status: "connected",
+      link_status: "connecting",
       last_heartbeat_at: nowIso(),
       last_error: null,
-      last_event: "platform_started",
+      last_event: "platform_process_started",
       status_source: "manual",
     });
   }
@@ -532,7 +777,8 @@ async function ensureBridgesStartedByConfig(): Promise<void> {
     (startupOnlyMode === "all" || startupOnlyMode === "lark") &&
     isChannelEnabled("feishu") &&
     readChannelAccountCount("feishu") > 0;
-  const canStartWeixin = startupOnlyMode === "all" || startupOnlyMode === "weixin";
+  const canStartWeixin =
+    startupOnlyMode === "all" || startupOnlyMode === "weixin";
 
   const tasks: Array<Promise<void>> = [];
 
@@ -619,9 +865,7 @@ async function ensureBridgesStartedByConfig(): Promise<void> {
           }),
       );
     } else if (startupOnlyMode === "all" || startupOnlyMode === "weixin") {
-      console.log(
-        "[bridges/main] skip weixin bridge start: enabled=false",
-      );
+      console.log("[bridges/main] skip weixin bridge start: enabled=false");
     }
   } else {
     console.log(
@@ -650,7 +894,9 @@ async function ensureWeixinBridgeReadyForGatewayInvoke(): Promise<void> {
   }
 
   weixinBridgeStarting = true;
-  console.log("[bridges/main] lazy starting weixin bridge for gateway invoke...");
+  console.log(
+    "[bridges/main] lazy starting weixin bridge for gateway invoke...",
+  );
   try {
     await import("./weixin-stdio-bridge.ts");
     weixinBridgeStarted = true;
@@ -712,6 +958,48 @@ function normalizeGatewayChannel(input: unknown): RuntimeGatewayChannel | null {
   return null;
 }
 
+function normalizeRuntimePlatform(input: unknown): RuntimePlatform | null {
+  const raw = String(input || "")
+    .trim()
+    .toLowerCase();
+  if (raw === "dingtalk" || raw === "dingtalk-connector") return "dingtalk";
+  if (raw === "feishu" || raw === "lark" || raw === "openclaw-lark") {
+    return "feishu";
+  }
+  if (raw === "weixin" || raw === "openclaw-weixin") {
+    return "weixin";
+  }
+  return null;
+}
+
+function platformToChannelKey(
+  platform: RuntimePlatform,
+): "dingtalk-connector" | "feishu" | "openclaw-weixin" {
+  if (platform === "dingtalk") return "dingtalk-connector";
+  if (platform === "feishu") return "feishu";
+  return "openclaw-weixin";
+}
+
+function resolveRuntimeBridgeControl(
+  platform: RuntimePlatform,
+): RuntimeBridgeControl | undefined {
+  const key =
+    platform === "dingtalk"
+      ? "__IM_DINGTALK_BRIDGE_CONTROL__"
+      : platform === "feishu"
+        ? "__IM_LARK_BRIDGE_CONTROL__"
+        : "__IM_WEIXIN_BRIDGE_CONTROL__";
+  const control = (globalThis as Record<string, unknown>)[key] as
+    | RuntimeBridgeControl
+    | undefined;
+  return control;
+}
+
+function generateOperationId(prefix: string): string {
+  const rand = Math.random().toString(36).slice(2, 10);
+  return `${prefix}-${Date.now()}-${rand}`;
+}
+
 async function invokeGatewayMethodByChannel(args: {
   channel: RuntimeGatewayChannel;
   method: string;
@@ -774,7 +1062,66 @@ async function invokeGatewayMethodByChannel(args: {
   }
 }
 
-async function probeAndRefreshStatuses(): Promise<void> {
+function parseBoolFlag(input: unknown): boolean {
+  const normalized = String(input || "")
+    .trim()
+    .toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes";
+}
+
+function isProbeFresh(nowMs = Date.now()): boolean {
+  if (!lastProbeFinishedAt) return false;
+  const lastMs = Date.parse(lastProbeFinishedAt);
+  if (Number.isNaN(lastMs)) return false;
+  return nowMs - lastMs <= runtimeStatusProbeTtlMs;
+}
+
+async function withProbeTimeout<T>(
+  work: Promise<T>,
+  timeoutMs: number,
+  timeoutMessage: string,
+): Promise<T> {
+  if (timeoutMs <= 0) return await work;
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  try {
+    return await Promise.race([
+      work,
+      new Promise<T>((_, reject) => {
+        timer = setTimeout(() => {
+          runtimeStatusProbeTimeoutTotal += 1;
+          reject(new Error(timeoutMessage));
+        }, timeoutMs);
+      }),
+    ]);
+  } finally {
+    if (timer) {
+      clearTimeout(timer);
+    }
+  }
+}
+
+async function runWithConcurrency<T>(
+  items: T[],
+  concurrency: number,
+  worker: (item: T) => Promise<void>,
+): Promise<void> {
+  if (!items.length) return;
+  const limit = Math.max(1, Math.min(concurrency, items.length));
+  let cursor = 0;
+
+  const runners = Array.from({ length: limit }, async () => {
+    while (true) {
+      const current = cursor;
+      cursor += 1;
+      if (current >= items.length) return;
+      await worker(items[current] as T);
+    }
+  });
+
+  await Promise.all(runners);
+}
+
+async function runFullProbeAndRefreshStatuses(): Promise<void> {
   if (!loadedConfigForRuntime) return;
   const cfg = loadedConfigForRuntime;
 
@@ -817,120 +1164,152 @@ async function probeAndRefreshStatuses(): Promise<void> {
       if (listAccountIds) {
         const ids = configuredIds;
         if (resolveAccount && probeAccount) {
-          for (const accountId of ids) {
-            const previous = runtimeStatusRegistry.get(
-              keyOf("dingtalk", accountId),
-            );
-            try {
-              const account = resolveAccount(cfg, accountId);
-              const probeResult = await probeAccount({ account });
-              const ok = probeResult?.ok !== false;
-              const probeError = buildDetailedProbeErrorMessage(
-                probeResult as Record<string, unknown>,
+          await runWithConcurrency(
+            ids,
+            runtimeStatusProbeConcurrency.dingtalk,
+            async (accountId) => {
+              const previous = runtimeStatusRegistry.get(
+                keyOf("dingtalk", accountId),
               );
-              const probeErrorWithLogFallback = isGenericRuntimeErrorMessage(
-                probeError,
-              )
-                ? pickMoreSpecificErrorMessage(
-                    probeError,
-                    readRecentBridgeErrorFromLog(accountId, "dingtalk"),
-                  )
-                : probeError;
-              if (!ok) {
-                console.error(
-                  `[bridges/main] dingtalk probeAccount failed account=${accountId} raw=${toLogText(probeResult)}`,
+              try {
+                const account = resolveAccount(cfg, accountId);
+                const probeResult = await withProbeTimeout(
+                  probeAccount({ account }),
+                  runtimeStatusProbeTimeoutMs,
+                  `[bridges/main] dingtalk probeAccount timeout account=${accountId} timeoutMs=${runtimeStatusProbeTimeoutMs}`,
                 );
-                console.error(
-                  `[bridges/main] dingtalk probeAccount derived_error account=${accountId} error=${toLogText(probeErrorWithLogFallback || "")}`,
+                const ok = probeResult?.ok !== false;
+                const probeError = buildDetailedProbeErrorMessage(
+                  probeResult as Record<string, unknown>,
                 );
-              }
-              const error = ok
-                ? null
-                : pickMoreSpecificErrorMessage(
-                    previous?.last_error || null,
-                    probeErrorWithLogFallback,
+                const probeErrorWithLogFallback = isGenericRuntimeErrorMessage(
+                  probeError,
+                )
+                  ? pickMoreSpecificErrorMessage(
+                      probeError,
+                      readRecentBridgeErrorFromLog(accountId, "dingtalk"),
+                    )
+                  : probeError;
+                if (!ok) {
+                  console.error(
+                    `[bridges/main] dingtalk probeAccount failed account=${accountId} raw=${toLogText(probeResult)}`,
                   );
-              if (!ok) {
-                console.error(
-                  `[bridges/main] dingtalk probeAccount merged_error account=${accountId} error=${toLogText(error || "")}`,
-                );
+                  console.error(
+                    `[bridges/main] dingtalk probeAccount derived_error account=${accountId} error=${toLogText(probeErrorWithLogFallback || "")}`,
+                  );
+                }
+                const error = ok
+                  ? null
+                  : pickMoreSpecificErrorMessage(
+                      previous?.last_error || null,
+                      probeErrorWithLogFallback,
+                    );
+                if (!ok) {
+                  console.error(
+                    `[bridges/main] dingtalk probeAccount merged_error account=${accountId} error=${toLogText(error || "")}`,
+                  );
+                }
+                upsertRuntimeStatus({
+                  platform: "dingtalk",
+                  bot_account_id: accountId,
+                  link_status: ok ? "connected" : "error",
+                  started_at: previous?.started_at || nowIso(),
+                  last_heartbeat_at: nowIso(),
+                  last_error: error,
+                  status_source: "probe",
+                  last_probe_at: nowIso(),
+                });
+              } catch (err) {
+                upsertRuntimeStatus({
+                  platform: "dingtalk",
+                  bot_account_id: accountId,
+                  link_status: "error",
+                  started_at: previous?.started_at || nowIso(),
+                  last_heartbeat_at: nowIso(),
+                  last_error: pickMoreSpecificErrorMessage(
+                    previous?.last_error || null,
+                    (err as Error).message,
+                  ),
+                  status_source: "probe",
+                  last_probe_at: nowIso(),
+                });
               }
-              upsertRuntimeStatus({
-                platform: "dingtalk",
-                bot_account_id: accountId,
-                link_status: ok ? "connected" : "error",
-                started_at: previous?.started_at || nowIso(),
-                last_heartbeat_at: nowIso(),
-                last_error: error,
-                status_source: "probe",
-                last_probe_at: nowIso(),
-              });
-            } catch (err) {
-              upsertRuntimeStatus({
-                platform: "dingtalk",
-                bot_account_id: accountId,
-                link_status: "error",
-                started_at: previous?.started_at || nowIso(),
-                last_heartbeat_at: nowIso(),
-                last_error: pickMoreSpecificErrorMessage(
-                  previous?.last_error || null,
-                  (err as Error).message,
-                ),
-                status_source: "probe",
-                last_probe_at: nowIso(),
-              });
-            }
-          }
+            },
+          );
         } else if (probe) {
-          for (const accountId of ids) {
-            const probeResult = await probe({ cfg, accountId });
-            const ok = Boolean(probeResult?.ok);
-            if (!ok) {
-              console.error(
-                `[bridges/main] dingtalk probe failed raw=${toLogText(probeResult)}`,
+          await runWithConcurrency(
+            ids,
+            runtimeStatusProbeConcurrency.dingtalk,
+            async (accountId) => {
+              const previous = runtimeStatusRegistry.get(
+                keyOf("dingtalk", accountId),
               );
-            }
-            const previous = runtimeStatusRegistry.get(
-              keyOf("dingtalk", accountId),
-            );
-            const probeError = buildDetailedProbeErrorMessage(
-              probeResult as Record<string, unknown>,
-            );
-            const probeErrorWithLogFallback = isGenericRuntimeErrorMessage(
-              probeError,
-            )
-              ? pickMoreSpecificErrorMessage(
+              try {
+                const probeResult = await withProbeTimeout(
+                  probe({ cfg, accountId }),
+                  runtimeStatusProbeTimeoutMs,
+                  `[bridges/main] dingtalk probe timeout account=${accountId} timeoutMs=${runtimeStatusProbeTimeoutMs}`,
+                );
+                const ok = Boolean(probeResult?.ok);
+                if (!ok) {
+                  console.error(
+                    `[bridges/main] dingtalk probe failed raw=${toLogText(probeResult)}`,
+                  );
+                }
+                const probeError = buildDetailedProbeErrorMessage(
+                  probeResult as Record<string, unknown>,
+                );
+                const probeErrorWithLogFallback = isGenericRuntimeErrorMessage(
                   probeError,
-                  readRecentBridgeErrorFromLog(accountId, "dingtalk"),
                 )
-              : probeError;
-            if (!ok) {
-              console.error(
-                `[bridges/main] dingtalk probe derived_error account=${accountId} error=${toLogText(probeErrorWithLogFallback || "")}`,
-              );
-            }
-            const error = ok
-              ? null
-              : pickMoreSpecificErrorMessage(
-                  previous?.last_error || null,
-                  probeErrorWithLogFallback,
-                );
-            if (!ok) {
-              console.error(
-                `[bridges/main] dingtalk probe merged_error account=${accountId} error=${toLogText(error || "")}`,
-              );
-            }
-            upsertRuntimeStatus({
-              platform: "dingtalk",
-              bot_account_id: accountId,
-              link_status: ok ? "connected" : "error",
-              started_at: previous?.started_at || nowIso(),
-              last_heartbeat_at: nowIso(),
-              last_error: error,
-              status_source: "probe",
-              last_probe_at: nowIso(),
-            });
-          }
+                  ? pickMoreSpecificErrorMessage(
+                      probeError,
+                      readRecentBridgeErrorFromLog(accountId, "dingtalk"),
+                    )
+                  : probeError;
+                if (!ok) {
+                  console.error(
+                    `[bridges/main] dingtalk probe derived_error account=${accountId} error=${toLogText(probeErrorWithLogFallback || "")}`,
+                  );
+                }
+                const error = ok
+                  ? null
+                  : pickMoreSpecificErrorMessage(
+                      previous?.last_error || null,
+                      probeErrorWithLogFallback,
+                    );
+                if (!ok) {
+                  console.error(
+                    `[bridges/main] dingtalk probe merged_error account=${accountId} error=${toLogText(error || "")}`,
+                  );
+                }
+                upsertRuntimeStatus({
+                  platform: "dingtalk",
+                  bot_account_id: accountId,
+                  link_status: ok ? "connected" : "error",
+                  started_at: previous?.started_at || nowIso(),
+                  last_heartbeat_at: nowIso(),
+                  last_error: error,
+                  status_source: "probe",
+                  last_probe_at: nowIso(),
+                });
+              } catch (err) {
+                upsertRuntimeStatus({
+                  platform: "dingtalk",
+                  bot_account_id: accountId,
+                  link_status: "error",
+                  started_at: previous?.started_at || nowIso(),
+                  last_heartbeat_at: nowIso(),
+                  last_error: pickMoreSpecificErrorMessage(
+                    previous?.last_error || null,
+                    (err as Error).message,
+                  ),
+                  status_source: "probe",
+                  last_probe_at: nowIso(),
+                });
+              }
+            },
+          );
         }
       }
     }
@@ -970,117 +1349,206 @@ async function probeAndRefreshStatuses(): Promise<void> {
 
       if (listAccountIds && resolveAccount && probeAccount) {
         const ids = configuredIds;
-        for (const accountId of ids) {
+        await runWithConcurrency(
+          ids,
+          runtimeStatusProbeConcurrency.feishu,
+          async (accountId) => {
+            try {
+              const previous = runtimeStatusRegistry.get(
+                keyOf("feishu", accountId),
+              );
+              const account = resolveAccount(cfg, accountId);
+              const probeResult = await withProbeTimeout(
+                probeAccount({ account }),
+                runtimeStatusProbeTimeoutMs,
+                `[bridges/main] feishu probeAccount timeout account=${accountId} timeoutMs=${runtimeStatusProbeTimeoutMs}`,
+              );
+              const ok = probeResult?.ok !== false;
+              const probeError = buildDetailedProbeErrorMessage(
+                probeResult as Record<string, unknown>,
+              );
+              const probeErrorWithLogFallback = isGenericRuntimeErrorMessage(
+                probeError,
+              )
+                ? pickMoreSpecificErrorMessage(
+                    probeError,
+                    readRecentBridgeErrorFromLog(accountId, "feishu"),
+                  )
+                : probeError;
+              const preserveEventStatus =
+                previous?.status_source === "event" &&
+                (previous.link_status === "error" ||
+                  previous.link_status === "disconnected" ||
+                  previous.link_status === "degraded");
+
+              const nextStatus: RuntimeBotStatus["link_status"] =
+                preserveEventStatus
+                  ? previous?.link_status || "connecting"
+                  : ok
+                    ? "connected"
+                    : "error";
+              const nextError =
+                nextStatus === "connected"
+                  ? null
+                  : pickMoreSpecificErrorMessage(
+                      previous?.last_error || null,
+                      probeErrorWithLogFallback,
+                    );
+
+              upsertRuntimeStatus({
+                platform: "feishu",
+                bot_account_id: accountId,
+                link_status: nextStatus,
+                started_at: previous?.started_at || nowIso(),
+                last_heartbeat_at: nowIso(),
+                last_error: nextError,
+                status_source: preserveEventStatus ? "event" : "probe",
+                last_probe_at: nowIso(),
+              });
+            } catch (err) {
+              upsertRuntimeStatus({
+                platform: "feishu",
+                bot_account_id: accountId,
+                link_status: "error",
+                started_at:
+                  runtimeStatusRegistry.get(keyOf("feishu", accountId))
+                    ?.started_at || nowIso(),
+                last_heartbeat_at: nowIso(),
+                last_error: (err as Error).message,
+                status_source: "probe",
+                last_probe_at: nowIso(),
+              });
+            }
+          },
+        );
+      }
+    }
+  } catch (err) {
+    console.error("[bridges/main] feishu probe failed", (err as Error).message);
+  }
+
+  try {
+    const configuredIds = readConfiguredAccountIds(cfg, "openclaw-weixin");
+    if (configuredIds.length === 0) {
+      clearPlatformStatuses("weixin");
+    } else {
+      await runWithConcurrency(
+        configuredIds,
+        runtimeStatusProbeConcurrency.weixin,
+        async (accountId) => {
+          const previous = runtimeStatusRegistry.get(
+            keyOf("weixin", accountId),
+          );
           try {
-            const account = resolveAccount(cfg, accountId);
-            const probeResult = await probeAccount({ account });
-            const ok = probeResult?.ok !== false;
-            const previous = runtimeStatusRegistry.get(
-              keyOf("feishu", accountId),
-            );
-            const probeError = buildDetailedProbeErrorMessage(
-              probeResult as Record<string, unknown>,
+            const invoke = await withProbeTimeout(
+              invokeGatewayMethodByChannel({
+                channel: "weixin",
+                method: "weixin.probe",
+                params: { accountId },
+                accountId,
+              }),
+              runtimeStatusProbeTimeoutMsWeixin,
+              `[bridges/main] weixin probe timeout account=${accountId} timeoutMs=${runtimeStatusProbeTimeoutMsWeixin}`,
             );
-            const error = ok
-              ? null
-              : pickMoreSpecificErrorMessage(
-                  previous?.last_error || null,
+            const probeResult =
+              invoke?.result && typeof invoke.result === "object"
+                ? (invoke.result as Record<string, unknown>)
+                : null;
+            const probeOk =
+              invoke?.ok === true &&
+              (!probeResult ||
+                probeResult.ok === undefined ||
+                probeResult.ok !== false);
+            const probeError = probeResult
+              ? buildDetailedProbeErrorMessage(probeResult)
+              : String(invoke?.error || "").trim();
+            const probeErrorWithLogFallback = isGenericRuntimeErrorMessage(
+              probeError,
+            )
+              ? pickMoreSpecificErrorMessage(
                   probeError,
-                );
+                  readRecentBridgeErrorFromLog(accountId, "weixin"),
+                )
+              : probeError;
+            const linkStatus: RuntimeBotStatus["link_status"] = probeOk
+              ? "connected"
+              : weixinBridgeStarted
+                ? "error"
+                : "connecting";
             upsertRuntimeStatus({
-              platform: "feishu",
+              platform: "weixin",
               bot_account_id: accountId,
-              link_status: ok ? "connected" : "error",
+              link_status: linkStatus,
               started_at: previous?.started_at || nowIso(),
               last_heartbeat_at: nowIso(),
-              last_error: error,
+              last_error: probeOk
+                ? null
+                : pickMoreSpecificErrorMessage(
+                    previous?.last_error || null,
+                    probeErrorWithLogFallback || invoke?.error || null,
+                  ),
               status_source: "probe",
               last_probe_at: nowIso(),
             });
           } catch (err) {
             upsertRuntimeStatus({
-              platform: "feishu",
+              platform: "weixin",
               bot_account_id: accountId,
-              link_status: "error",
-              started_at:
-                runtimeStatusRegistry.get(keyOf("feishu", accountId))
-                  ?.started_at || nowIso(),
+              link_status: weixinBridgeStarted ? "error" : "connecting",
+              started_at: previous?.started_at || nowIso(),
               last_heartbeat_at: nowIso(),
-              last_error: (err as Error).message,
+              last_error: pickMoreSpecificErrorMessage(
+                previous?.last_error || null,
+                (err as Error).message,
+              ),
               status_source: "probe",
               last_probe_at: nowIso(),
             });
           }
-        }
-      }
+        },
+      );
     }
   } catch (err) {
-    console.error("[bridges/main] feishu probe failed", (err as Error).message);
+    console.error("[bridges/main] weixin probe failed", (err as Error).message);
   }
+}
 
-  try {
-    const configuredIds = readConfiguredAccountIds(cfg, "openclaw-weixin");
-    if (configuredIds.length === 0) {
-      clearPlatformStatuses("weixin");
-    } else {
-      for (const accountId of configuredIds) {
-        const previous = runtimeStatusRegistry.get(keyOf("weixin", accountId));
-        const invoke = await invokeGatewayMethodByChannel({
-          channel: "weixin",
-          method: "weixin.probe",
-          params: { accountId },
-          accountId,
-        });
-        const probeResult =
-          invoke?.result && typeof invoke.result === "object"
-            ? (invoke.result as Record<string, unknown>)
-            : null;
-        const probeOk =
-          invoke?.ok === true &&
-          (!probeResult || probeResult.ok === undefined || probeResult.ok !== false);
-        const probeError = probeResult
-          ? buildDetailedProbeErrorMessage(probeResult)
-          : String(invoke?.error || "").trim();
-        const probeErrorWithLogFallback = isGenericRuntimeErrorMessage(probeError)
-          ? pickMoreSpecificErrorMessage(
-              probeError,
-              readRecentBridgeErrorFromLog(accountId, "weixin"),
-            )
-          : probeError;
-        const linkStatus: RuntimeBotStatus["link_status"] = probeOk
-          ? "connected"
-          : weixinBridgeStarted
-            ? "error"
-            : "connecting";
-        upsertRuntimeStatus({
-          platform: "weixin",
-          bot_account_id: accountId,
-          link_status: linkStatus,
-          started_at: previous?.started_at || nowIso(),
-          last_heartbeat_at: nowIso(),
-          last_error: probeOk
-            ? null
-            : pickMoreSpecificErrorMessage(
-                previous?.last_error || null,
-                probeErrorWithLogFallback || invoke?.error || null,
-              ),
-          status_source: "probe",
-          last_probe_at: nowIso(),
-        });
-      }
-    }
-  } catch (err) {
-    console.error("[bridges/main] weixin probe failed", (err as Error).message);
+async function probeAndRefreshStatuses(
+  options: ProbeRefreshOptions = {},
+): Promise<void> {
+  const forceProbe = options.force === true;
+
+  if (!forceProbe && isProbeFresh()) {
+    runtimeStatusCacheHitTotal += 1;
+    return;
+  }
+
+  if (probeInFlight) {
+    runtimeStatusSingleflightReusedTotal += 1;
+    await probeInFlight;
+    return;
   }
+
+  const startedAt = Date.now();
+  lastProbeStartedAt = new Date(startedAt).toISOString();
+
+  probeInFlight = (async () => {
+    await runFullProbeAndRefreshStatuses();
+  })().finally(() => {
+    const finishedAt = Date.now();
+    lastProbeFinishedAt = new Date(finishedAt).toISOString();
+    lastProbeDurationMs = Math.max(0, finishedAt - startedAt);
+    probeInFlight = null;
+  });
+
+  await probeInFlight;
 }
 
 function startProbeLoop(): void {
-  const intervalMs = Number(
-    process.env.RUNTIME_STATUS_PROBE_INTERVAL_MS || "15000",
-  );
+  const intervalMs = runtimeStatusProbeIntervalMs;
   if (intervalMs <= 0) return;
   setInterval(() => {
-    void probeAndRefreshStatuses();
+    void probeAndRefreshStatuses({ reason: "loop" });
   }, intervalMs);
 }
 
@@ -1148,11 +1616,16 @@ async function pullRuntimeConfigFromPython(forceFull = false): Promise<{
 
     const notModified = Boolean(data?.not_modified);
     if (notModified) {
+      const pulledVersion = String(data?.version || "").trim();
+      if (pulledVersion) {
+        configVersionHash = pulledVersion;
+        configVersionUpdatedAt = nowIso();
+      }
       return {
         ok: true,
         pulled: false,
         not_modified: true,
-        version: String(data?.version || configVersionHash || "unknown"),
+        version: pulledVersion || configVersionHash || "unknown",
       };
     }
 
@@ -1182,10 +1655,13 @@ async function pullRuntimeConfigFromPython(forceFull = false): Promise<{
       loadedConfigForRuntime,
       loadedConfigPathForRuntime,
     );
-    updateConfigVersion(normalizedResult.normalized);
+    updateConfigVersion(
+      normalizedResult.normalized,
+      String(data?.version || "").trim() || undefined,
+    );
     applyRemoteRuntimeConfigToPluginHome();
     markConfiguredBotsAsConnecting(normalizedResult.normalized);
-    await probeAndRefreshStatuses();
+    await probeAndRefreshStatuses({ force: true, reason: "config_pull" });
 
     if (runtimeConfigPullPersist) {
       const targetPath =
@@ -1280,7 +1756,7 @@ async function waitRestartCompletion(
   const deadline = Date.now() + Math.max(1000, timeoutMs);
   const interval = Math.max(200, pollIntervalMs);
   while (Date.now() < deadline) {
-    await probeAndRefreshStatuses();
+    await probeAndRefreshStatuses({ force: true, reason: "restart_wait" });
     const summary = summarizeBots();
     const unsettled =
       summary.connecting + summary.degraded + summary.disconnected;
@@ -1345,10 +1821,11 @@ function readEffectiveWhitelistFromConfig(
         "allowFrom",
         "groupPolicy",
         "requireMention",
+        "scope_kind",
+        "scopeKind",
         "scopeType",
         "projectId",
         "scope_type",
-        "type",
         "project_id",
       ],
     },
@@ -1371,10 +1848,11 @@ function readEffectiveWhitelistFromConfig(
         "dmPolicy",
         "allowFrom",
         "groupPolicy",
+        "scope_kind",
+        "scopeKind",
         "scopeType",
         "projectId",
         "scope_type",
-        "type",
         "project_id",
       ],
     },
@@ -1389,10 +1867,11 @@ function readEffectiveWhitelistFromConfig(
         "uploadHost",
       ],
       runtimeReadonlyFields: [
+        "scope_kind",
+        "scopeKind",
         "scopeType",
         "projectId",
         "scope_type",
-        "type",
         "project_id",
       ],
     },
@@ -1505,8 +1984,12 @@ function calcSchemaHash(rawSchema: unknown): string {
   return calcSchemaHashFromRuntime(rawSchema);
 }
 
-function updateConfigVersion(config: Record<string, unknown>): void {
-  configVersionHash = calcSchemaHash(config);
+function updateConfigVersion(
+  config: Record<string, unknown>,
+  preferredVersion?: string,
+): void {
+  const normalizedPreferredVersion = String(preferredVersion || "").trim();
+  configVersionHash = normalizedPreferredVersion || calcSchemaHash(config);
   configVersionUpdatedAt = nowIso();
 }
 
@@ -1674,7 +2157,11 @@ async function startInternalApiServer(): Promise<void> {
       req.method === "GET" &&
       reqUrl.pathname === "/internal/runtime/bots/status"
     ) {
-      await probeAndRefreshStatuses();
+      const forceProbe = parseBoolFlag(reqUrl.searchParams.get("force_probe"));
+      await probeAndRefreshStatuses({
+        force: forceProbe,
+        reason: forceProbe ? "status_force" : "status_read",
+      });
       const bots = Array.from(runtimeStatusRegistry.values());
       const summary = summarizeBots();
       res.writeHead(200, { "Content-Type": "application/json" });
@@ -1685,6 +2172,22 @@ async function startInternalApiServer(): Promise<void> {
           runtime_state: runtimeState,
           version: configVersionHash || "unknown",
           generated_at: nowIso(),
+          probe_meta: {
+            ttl_ms: runtimeStatusProbeTtlMs,
+            per_account_timeout_ms: runtimeStatusProbeTimeoutMs,
+            per_account_timeout_ms_weixin: runtimeStatusProbeTimeoutMsWeixin,
+            concurrency: runtimeStatusProbeConcurrency,
+            force_probe: forceProbe,
+            in_flight: Boolean(probeInFlight),
+            is_fresh: isProbeFresh(),
+            last_started_at: lastProbeStartedAt,
+            last_finished_at: lastProbeFinishedAt,
+            last_duration_ms: lastProbeDurationMs,
+            cache_hit_total: runtimeStatusCacheHitTotal,
+            singleflight_reused_total: runtimeStatusSingleflightReusedTotal,
+            timeout_total: runtimeStatusProbeTimeoutTotal,
+          },
+          runtime_heartbeat: buildRuntimeHeartbeatSnapshot(),
           summary,
           bots,
         }),
@@ -1708,6 +2211,18 @@ async function startInternalApiServer(): Promise<void> {
       );
       return;
     }
+    if (
+      req.method === "GET" &&
+      reqUrl.pathname === "/internal/runtime/logs/download"
+    ) {
+      const maxBytesRaw = String(
+        reqUrl.searchParams.get("max_bytes") ||
+          reqUrl.searchParams.get("maxBytes") ||
+          "",
+      ).trim();
+      streamRuntimeLogDownload(res, { maxBytesRaw });
+      return;
+    }
     if (
       req.method === "GET" &&
       reqUrl.pathname === "/internal/runtime/plugins/config-schema"
@@ -1776,85 +2291,229 @@ async function startInternalApiServer(): Promise<void> {
       );
       return;
     }
-    if (
-      req.method === "POST" &&
-      reqUrl.pathname === "/internal/runtime/config/reload"
-    ) {
-      let pullDroppedFields: Array<{
-        channel: string;
-        accountId: string;
-        field: string;
-      }> = [];
-      const canPull = Boolean(runtimeConfigPullUrl);
-      const canReadLocal = Boolean(
-        loadedConfigPathForRuntime && fs.existsSync(loadedConfigPathForRuntime),
-      );
-      if (!canPull && !canReadLocal && !loadedConfigForRuntime) {
+    const botControlAction =
+      req.method === "POST" && reqUrl.pathname === "/internal/runtime/bot/start"
+        ? "start"
+        : req.method === "POST" &&
+            reqUrl.pathname === "/internal/runtime/bot/stop"
+          ? "stop"
+          : req.method === "POST" &&
+              reqUrl.pathname === "/internal/runtime/bot/restart"
+            ? "restart"
+            : null;
+    if (botControlAction) {
+      const body = await readRequestJson(req);
+      const platform = normalizeRuntimePlatform(body.platform || body.channel);
+      const botAccountId = String(
+        body.bot_account_id || body.account_id || body.accountId || "",
+      ).trim();
+      const reason =
+        String(body.reason || "").trim() || `manual_${botControlAction}`;
+
+      if (!platform || !botAccountId) {
         res.writeHead(400, { "Content-Type": "application/json" });
         res.end(
           JSON.stringify({
             ok: false,
-            error: "no runtime config source available",
+            error: "platform and bot_account_id are required",
           }),
         );
         return;
       }
-      if (runtimeConfigPullUrl) {
-        const pullResult = await pullRuntimeConfigFromPython(true);
-        if (!pullResult.ok) {
-          res.writeHead(500, { "Content-Type": "application/json" });
-          res.end(
-            JSON.stringify({
-              ok: false,
-              error: `reload pull failed: ${pullResult.error || "unknown"}`,
-            }),
-          );
-          return;
-        }
-        if ((pullResult.dropped_fields || []).length > 0) {
-          pullDroppedFields = pullResult.dropped_fields || [];
-          console.log(
-            `[bridges/main] reload dropped fields from pull: ${pullResult.dropped_fields
-              ?.map((item) => `${item.channel}/${item.accountId}:${item.field}`)
-              .join(", ")}`,
-          );
-        }
+
+      if (runtimeState === "restarting") {
+        res.writeHead(409, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            ok: false,
+            error:
+              "runtime is restarting, bot control is temporarily unavailable",
+          }),
+        );
+        return;
       }
-      if (
-        loadedConfigPathForRuntime &&
-        fs.existsSync(loadedConfigPathForRuntime)
-      ) {
-        try {
-          const content = fs.readFileSync(loadedConfigPathForRuntime, "utf-8");
-          const parsed = JSON.parse(content) as Record<string, unknown>;
-          const normalizedResult = normalizeRuntimeConfigByWhitelist(parsed);
-          loadedConfigForRuntime = normalizedResult.normalized;
-          updateConfigVersion(normalizedResult.normalized);
-        } catch (err) {
-          res.writeHead(500, { "Content-Type": "application/json" });
-          res.end(
-            JSON.stringify({
-              ok: false,
-              error: `reload failed: ${(err as Error).message}`,
-            }),
-          );
-          return;
-        }
+
+      const channelKey = platformToChannelKey(platform);
+      if (!isChannelEnabled(channelKey)) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            ok: false,
+            error: `channel disabled: ${channelKey}`,
+          }),
+        );
+        return;
       }
-      if (loadedConfigForRuntime) {
-        markConfiguredBotsAsConnecting(loadedConfigForRuntime);
-        await probeAndRefreshStatuses();
+      if (!isConfiguredRuntimeAccount(platform, botAccountId)) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            ok: false,
+            error: `bot account not configured: ${platform}/${botAccountId}`,
+          }),
+        );
+        return;
+      }
+
+      const inFlightKey = keyOf(platform, botAccountId);
+      if (botControlInFlight.has(inFlightKey)) {
+        res.writeHead(409, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            ok: false,
+            error: "bot control operation already in progress",
+            platform,
+            bot_account_id: botAccountId,
+          }),
+        );
+        return;
+      }
+      botControlInFlight.add(inFlightKey);
+
+      const control = resolveRuntimeBridgeControl(platform);
+      if (!control) {
+        botControlInFlight.delete(inFlightKey);
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            ok: false,
+            error: `${platform} bridge control not available`,
+          }),
+        );
+        return;
+      }
+
+      const operationId = generateOperationId(`bot_${botControlAction}`);
+      const key = keyOf(platform, botAccountId);
+      const previous = runtimeStatusRegistry.get(key);
+      const now = nowIso();
+
+      try {
+        if (botControlAction === "start") {
+          if (typeof control.startAccount !== "function") {
+            res.writeHead(501, { "Content-Type": "application/json" });
+            res.end(
+              JSON.stringify({
+                ok: false,
+                error: `${platform} bridge startAccount not implemented`,
+              }),
+            );
+            return;
+          }
+          upsertRuntimeStatus({
+            platform,
+            bot_account_id: botAccountId,
+            link_status: "connecting",
+            started_at: previous?.started_at || now,
+            last_heartbeat_at: now,
+            last_error: null,
+            reconnect_count: previous?.reconnect_count || 0,
+            last_event: "manual_start_request",
+            status_source: "manual",
+            last_probe_at: previous?.last_probe_at || null,
+          });
+          await control.startAccount(botAccountId);
+        } else if (botControlAction === "stop") {
+          if (typeof control.stopAccount !== "function") {
+            res.writeHead(501, { "Content-Type": "application/json" });
+            res.end(
+              JSON.stringify({
+                ok: false,
+                error: `${platform} bridge stopAccount not implemented`,
+              }),
+            );
+            return;
+          }
+          await control.stopAccount(botAccountId);
+          upsertRuntimeStatus({
+            platform,
+            bot_account_id: botAccountId,
+            link_status: "disconnected",
+            started_at: previous?.started_at || now,
+            last_heartbeat_at: now,
+            last_error: null,
+            reconnect_count: previous?.reconnect_count || 0,
+            last_event: "manual_stop_request",
+            status_source: "manual",
+            last_probe_at: previous?.last_probe_at || null,
+          });
+        } else {
+          if (typeof control.restartAccount !== "function") {
+            res.writeHead(501, { "Content-Type": "application/json" });
+            res.end(
+              JSON.stringify({
+                ok: false,
+                error: `${platform} bridge restartAccount not implemented`,
+              }),
+            );
+            return;
+          }
+          upsertRuntimeStatus({
+            platform,
+            bot_account_id: botAccountId,
+            link_status: "connecting",
+            started_at: previous?.started_at || now,
+            last_heartbeat_at: now,
+            last_error: null,
+            reconnect_count: previous?.reconnect_count || 0,
+            last_event: "manual_restart_request",
+            status_source: "manual",
+            last_probe_at: previous?.last_probe_at || null,
+          });
+          await control.restartAccount(botAccountId);
+        }
+
+        const bot = runtimeStatusRegistry.get(key) || null;
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            ok: true,
+            status: "accepted",
+            action: botControlAction,
+            operation_id: operationId,
+            platform,
+            bot_account_id: botAccountId,
+            reason,
+            runtime_instance_id: runtimeInstanceId,
+            runtime_state: runtimeState,
+            issued_at: now,
+            bot,
+          }),
+        );
+      } catch (err) {
+        const message =
+          err instanceof Error ? err.message : "bot control failed";
+        upsertRuntimeStatus({
+          platform,
+          bot_account_id: botAccountId,
+          link_status: "error",
+          started_at: previous?.started_at || now,
+          last_heartbeat_at: now,
+          last_error: message,
+          reconnect_count: previous?.reconnect_count || 0,
+          last_event: `manual_${botControlAction}_failed`,
+          status_source: "manual",
+          last_probe_at: previous?.last_probe_at || null,
+        });
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            ok: false,
+            status: "fail",
+            action: botControlAction,
+            operation_id: operationId,
+            platform,
+            bot_account_id: botAccountId,
+            reason,
+            error: message,
+            runtime_instance_id: runtimeInstanceId,
+            runtime_state: runtimeState,
+            issued_at: now,
+          }),
+        );
+      } finally {
+        botControlInFlight.delete(inFlightKey);
       }
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(
-        JSON.stringify({
-          ok: true,
-          reloaded: true,
-          version: configVersionHash || "unknown",
-          updated_at: configVersionUpdatedAt,
-          dropped_fields: pullDroppedFields,
-        }),
-      );
       return;
     }
     if (
@@ -1864,6 +2523,7 @@ async function startInternalApiServer(): Promise<void> {
       const body = await readRequestJson(req);
       const config = body.config as Record<string, unknown> | undefined;
       const persist = body.persist !== false;
+      const requestedVersion = String(body.version || "").trim();
       if (!config || typeof config !== "object") {
         res.writeHead(400, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ ok: false, error: "config is required" }));
@@ -1893,9 +2553,13 @@ async function startInternalApiServer(): Promise<void> {
         loadedConfigForRuntime,
         loadedConfigPathForRuntime,
       );
-      updateConfigVersion(normalizedResult.normalized);
+      updateConfigVersion(
+        normalizedResult.normalized,
+        requestedVersion || undefined,
+      );
+      applyRemoteRuntimeConfigToPluginHome();
       markConfiguredBotsAsConnecting(normalizedResult.normalized);
-      await probeAndRefreshStatuses();
+      await probeAndRefreshStatuses({ force: true, reason: "config_apply" });
 
       if (persist) {
         const targetPath =
@@ -1929,6 +2593,7 @@ async function startInternalApiServer(): Promise<void> {
           status: "applied",
           persisted: persist,
           configPath: loadedConfigPathForRuntime,
+          version: configVersionHash || "unknown",
         }),
       );
       return;
@@ -1937,6 +2602,31 @@ async function startInternalApiServer(): Promise<void> {
       req.method === "POST" &&
       reqUrl.pathname === "/internal/runtime/restart-all"
     ) {
+      if (runtimeState === "restarting") {
+        res.writeHead(409, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            ok: false,
+            status: "busy",
+            error: "runtime is already restarting",
+            runtime_instance_id: runtimeInstanceId,
+          }),
+        );
+        return;
+      }
+      if (botControlInFlight.size > 0) {
+        res.writeHead(409, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            ok: false,
+            status: "busy",
+            error: "bot control operations are in progress",
+            in_flight_count: botControlInFlight.size,
+            runtime_instance_id: runtimeInstanceId,
+          }),
+        );
+        return;
+      }
       const body = await readRequestJson(req);
       const restartModeRaw = String(body.mode || "")
         .trim()
@@ -2277,12 +2967,14 @@ async function startInternalApiServer(): Promise<void> {
       const platform = String(body.platform || "").trim();
       const botAccountId = String(body.bot_account_id || "").trim();
       const linkStatus = String(body.link_status || "").trim();
+      const eventName = String(body.event_name || "").trim() || null;
+      const isHeartbeatEvent = isHeartbeatOnlyEvent(eventName);
       if (
         (platform !== "dingtalk" &&
           platform !== "feishu" &&
           platform !== "weixin") ||
         !botAccountId ||
-        !linkStatus
+        (!isHeartbeatEvent && !linkStatus)
       ) {
         res.writeHead(400, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ ok: false, error: "invalid payload" }));
@@ -2303,6 +2995,18 @@ async function startInternalApiServer(): Promise<void> {
         );
         return;
       }
+      const heartbeatAt = String(body.last_heartbeat_at || nowIso());
+      upsertRuntimeHeartbeat({
+        platform: p,
+        bot_account_id: botAccountId,
+        last_heartbeat_at: heartbeatAt,
+        last_event: eventName,
+      });
+      if (isHeartbeatEvent) {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: true, heartbeat_only: true }));
+        return;
+      }
       const normalizedStatus = [
         "connecting",
         "connected",
@@ -2313,7 +3017,6 @@ async function startInternalApiServer(): Promise<void> {
         ? (linkStatus as RuntimeBotStatus["link_status"])
         : "degraded";
       const prev = runtimeStatusRegistry.get(keyOf(p, botAccountId));
-      const eventName = String(body.event_name || "").trim() || null;
       const reconnectCountRaw = body.reconnect_count;
       const reconnectCountFromBody =
         typeof reconnectCountRaw === "number"
@@ -2330,7 +3033,7 @@ async function startInternalApiServer(): Promise<void> {
         bot_account_id: botAccountId,
         link_status: normalizedStatus,
         started_at: String(body.started_at || prev?.started_at || nowIso()),
-        last_heartbeat_at: String(body.last_heartbeat_at || nowIso()),
+        last_heartbeat_at: heartbeatAt,
         last_error: String(body.last_error || "") || null,
         reconnect_count: reconnectCount,
         last_event: eventName,
@@ -2484,6 +3187,7 @@ function printConfigBootstrapGuide(): void {
 }
 
 async function main(): Promise<void> {
+  debugger;
   const logFilePath = setupBridgeLogger("bridges-main");
   console.log("[bridges/main] log file:", logFilePath);