ylib-syim 0.0.24 → 0.0.26

package/bridges/main.ts

@@ -10,6 +10,7 @@ import { pullRuntimeConfig } from "./runtime/config-client.ts";
 import {
   buildRuntimeReadinessSnapshot as buildRuntimeReadinessSnapshotByPolicy,
   evaluateRuntimeHealth,
+  shouldApplyReportedFailureOverManualConnecting,
   resolveRuntimeDisplayState as resolveRuntimeDisplayStateByPolicy,
   resolveRuntimeHealthGuardTriggerReason as resolveRuntimeHealthGuardTriggerReasonByPolicy,
   type RuntimeHealthGuardTriggerReason,
@@ -35,8 +36,8 @@ let runtimeInstanceId = `bridges-${process.pid}-${Date.now()}`;
 const internalToken = (process.env.INTERNAL_FIXED_TOKEN || "").trim();
 // 内部控制面监听端口。
 const internalPort = Number(process.env.INTERNAL_CONTROL_PORT || "18999");
-// 内部控制面监听地址，容器部署默认 0.0.0.0 便于跨容器访问。
-const internalHost = (process.env.INTERNAL_CONTROL_HOST || "0.0.0.0").trim();
+// 内部控制面监听地址，容器部署默认 127.0.0.1 便于跨容器访问。
+const internalHost = (process.env.INTERNAL_CONTROL_HOST || "127.0.0.1").trim();
 // 是否启用内部控制面 API。
 const enableInternalApi = process.env.ENABLE_INTERNAL_API !== "0";
 
@@ -523,6 +524,10 @@ let runtimeStateExitHooksRegistered = false;
 // 最近一次收到任意 heartbeat 的时间。
 let runtimeHeartbeatLastReceivedAt: string | null = null;
 // 当前运行时生效配置（channels/bindings）。
+// 初始值为空配置，避免启动阶段各处 null 检查散落。
+// 真实的 channels / bindings 在 pullRuntimeConfigFromPython() 或 config/apply 之后写入。
+// 不要依赖本变量是否为 null 来判断"配置是否加载完成"——用 runtimeReady 标志。
+// 以上三行注释不可删除。
 let loadedConfigForRuntime: Record<string, unknown> | null = {
   channels: {},
   bindings: [],
@@ -1644,15 +1649,26 @@ function resolveRuntimeRestartPendingForUpdate(params: {
   previous: RuntimeBotStatus | null | undefined;
   hintedRestartPending: boolean | null | undefined;
   nextLinkStatus: RuntimeBotStatus["link_status"];
+  nextStatusSource?: RuntimeBotStatus["status_source"] | undefined;
 }): boolean {
-  const { previous, hintedRestartPending, nextLinkStatus } = params;
+  const {
+    previous,
+    hintedRestartPending,
+    nextLinkStatus,
+    nextStatusSource,
+  } = params;
   if (typeof hintedRestartPending === "boolean") {
     return hintedRestartPending;
   }
 
-  // Preserve pending restart lifecycle until an explicit signal clears it,
-  // or the account has clearly re-entered connected state.
+  // Preserve pending restart lifecycle until an explicit signal clears it.
+  // 在重启生命周期中，event/manual 的 connected 仍可能是过渡态，
+  // 仅 probe/connected 作为“重启完成并可对外收敛”的证据。
   if (nextLinkStatus === "connected") {
+    const source = nextStatusSource || "probe";
+    if (previous?.restart_pending === true && source !== "probe") {
+      return true;
+    }
     return false;
   }
   return previous?.restart_pending === true;
@@ -1704,15 +1720,44 @@ function isProbeDowngradeLinkStatus(
   );
 }
 
+function resolveRuntimeLifecycleAnchorMsForGuard(
+  status: RuntimeBotStatus,
+): number | null {
+  const startedAtMs = parseIsoTimeMs(
+    String(status.started_at || "").trim() || null,
+  );
+  const transitionAtMs = parseIsoTimeMs(
+    String(status.transition_at || "").trim() || null,
+  );
+  if (startedAtMs == null && transitionAtMs == null) return null;
+  if (startedAtMs == null) return transitionAtMs;
+  if (transitionAtMs == null) return startedAtMs;
+  return Math.max(startedAtMs, transitionAtMs);
+}
+
+function isWithinRuntimeConnectGraceForGuard(
+  status: RuntimeBotStatus,
+  nowMs = Date.now(),
+): boolean {
+  const lifecycleAnchorMs = resolveRuntimeLifecycleAnchorMsForGuard(status);
+  if (lifecycleAnchorMs == null) return false;
+  const lifecycleAgeMs = Math.max(0, nowMs - lifecycleAnchorMs);
+  return lifecycleAgeMs <= runtimeStatusConnectGraceMs;
+}
+
 function hasFreshRuntimeEventLivenessForProbeGuard(
   key: string,
   nowMs = Date.now(),
+  lifecycleAnchorMs: number | null = null,
 ): boolean {
   const eventLiveness = runtimeEventLivenessRegistry.get(key);
   const eventAtMs = parseIsoTimeMs(
     String(eventLiveness?.last_event_at || "").trim() || null,
   );
   if (eventAtMs == null) return false;
+  if (lifecycleAnchorMs != null && eventAtMs < lifecycleAnchorMs) {
+    return false;
+  }
   const ageMs = Math.max(0, nowMs - eventAtMs);
   return ageMs <= runtimeStatusProbeDowngradeGuardEventFreshMs;
 }
@@ -1759,7 +1804,14 @@ function shouldGuardProbeDowngradeByFreshEvent(params: {
   if (next.status_source !== "probe") return false;
   if (!isProbeDowngradeLinkStatus(next.link_status)) return false;
   if (prev.link_status !== "connected") return false;
-  return hasFreshRuntimeEventLivenessForProbeGuard(key);
+  const nowMs = Date.now();
+  if (isWithinRuntimeConnectGraceForGuard(prev, nowMs)) return false;
+  const lifecycleAnchorMs = resolveRuntimeLifecycleAnchorMsForGuard(prev);
+  return hasFreshRuntimeEventLivenessForProbeGuard(
+    key,
+    nowMs,
+    lifecycleAnchorMs,
+  );
 }
 
 function shouldGuardProbeConnectedByEventBroken(params: {
@@ -1777,7 +1829,72 @@ function shouldGuardProbeConnectedByEventBroken(params: {
     prev.link_status === "error" ||
     prev.link_status === "degraded";
   if (!prevBroken) return false;
-  return hasFreshRuntimeEventLivenessForProbeGuard(key);
+  const lifecycleAnchorMs = resolveRuntimeLifecycleAnchorMsForGuard(prev);
+  return hasFreshRuntimeEventLivenessForProbeGuard(
+    key,
+    Date.now(),
+    lifecycleAnchorMs,
+  );
+}
+
+type RuntimeConvergencePhase = "pending" | "steady" | "stopped";
+type RuntimeConvergenceEvidence = "manual" | "event" | "probe";
+type RuntimeConvergenceSignal = "success" | "failure" | "transient";
+
+function resolveRuntimeConvergencePhase(status: RuntimeBotStatus): RuntimeConvergencePhase {
+  if (status.restart_pending === true) return "pending";
+  if (status.status_source === "manual" && status.link_status === "disconnected") {
+    return "stopped";
+  }
+  const lastEventText = String(status.last_event || "")
+    .trim()
+    .toLowerCase();
+  if (
+    status.link_status === "disconnected" &&
+    runtimeStoppedLifecycleEvents.has(lastEventText)
+  ) {
+    return "stopped";
+  }
+  return "steady";
+}
+
+function resolveRuntimeConvergenceEvidence(
+  source: RuntimeBotStatus["status_source"],
+): RuntimeConvergenceEvidence {
+  if (source === "manual") return "manual";
+  if (source === "event") return "event";
+  return "probe";
+}
+
+function resolveRuntimeConvergenceSignal(
+  entry: RuntimeBotStatus,
+): RuntimeConvergenceSignal {
+  if (entry.link_status === "connected") return "success";
+  const evidence = resolveRuntimeConvergenceEvidence(entry.status_source);
+  if (
+    (entry.link_status === "error" ||
+      entry.link_status === "degraded" ||
+      entry.link_status === "disconnected") &&
+    (evidence === "event" || evidence === "probe")
+  ) {
+    return "failure";
+  }
+  return "transient";
+}
+
+function shouldGuardProbeConnectedWhilePendingWithoutEvent(params: {
+  key: string;
+  prev: RuntimeBotStatus;
+  next: RuntimeBotStatus;
+}): boolean {
+  const { key, prev, next } = params;
+  const prevPhase = resolveRuntimeConvergencePhase(prev);
+  if (prevPhase !== "pending") return false;
+  if (resolveRuntimeConvergenceSignal(next) !== "success") return false;
+  const nextEvidence = resolveRuntimeConvergenceEvidence(next.status_source);
+  if (nextEvidence !== "probe") return false;
+  if (!isWithinRuntimeConnectGraceForGuard(prev)) return false;
+  return !hasFreshConnectedRuntimeEventLivenessForRecovery(key);
 }
 
 function shouldBypassProtectWindowForEventRecovery(params: {
@@ -1944,13 +2061,29 @@ function upsertRuntimeStatus(entry: RuntimeBotStatus): void {
     entry.platform,
     entry.bot_account_id,
   );
-  const normalizedEntry: RuntimeBotStatus = {
+  let normalizedEntry: RuntimeBotStatus = {
     ...entry,
     bot_account_id: normalizedAccountId || entry.bot_account_id,
   };
 
   const key = keyOf(normalizedEntry.platform, normalizedEntry.bot_account_id);
   const prev = runtimeStatusRegistry.get(key);
+  if (
+    prev &&
+    resolveRuntimeConvergencePhase(prev) === "pending" &&
+    resolveRuntimeConvergenceSignal(normalizedEntry) === "success"
+  ) {
+    const nextEvidence = resolveRuntimeConvergenceEvidence(
+      normalizedEntry.status_source,
+    );
+    if (nextEvidence !== "probe") {
+      normalizedEntry = {
+        ...normalizedEntry,
+        link_status: "connecting",
+        restart_pending: true,
+      };
+    }
+  }
   const nextRestartPending = normalizedEntry.restart_pending ?? prev?.restart_pending ?? false;
   if (normalizedEntry.running === undefined) {
     normalizedEntry.running = resolveRuntimeRunningForUpdate({
@@ -2107,6 +2240,63 @@ function upsertRuntimeStatus(entry: RuntimeBotStatus): void {
     return;
   }
 
+  if (
+    prev &&
+    shouldGuardProbeConnectedWhilePendingWithoutEvent({
+      key,
+      prev,
+      next: normalizedEntry,
+    })
+  ) {
+    const prevRank = prev.last_status_rank ?? resolveStatusRank(prev);
+    const nextRank = resolveStatusRank(normalizedEntry);
+    const prevTransitionMs = parseIsoTimeMs(
+      prev.transition_at || prev.last_heartbeat_at,
+    );
+    const ageMs =
+      prevTransitionMs == null
+        ? null
+        : Math.max(0, Date.now() - prevTransitionMs);
+
+    logSuppressedTransition({
+      key,
+      prev,
+      next: normalizedEntry,
+      reason: "probe_connected_guarded_by_pending_without_event",
+      ageMs,
+      windowMs: resolveStatusProtectWindowMs(prev),
+      prevRank,
+      nextRank,
+    });
+
+    const guardedApplied: RuntimeBotStatus = {
+      ...prev,
+      last_heartbeat_at:
+        normalizedEntry.last_heartbeat_at || prev.last_heartbeat_at,
+      last_probe_at: normalizedEntry.last_probe_at || prev.last_probe_at,
+      reconnect_count:
+        normalizedEntry.reconnect_count ?? prev.reconnect_count,
+      restart_pending:
+        normalizedEntry.restart_pending ?? prev.restart_pending ?? true,
+      running: prev.running ?? true,
+      busy: normalizedEntry.busy ?? prev.busy,
+      active_runs: normalizedEntry.active_runs ?? prev.active_runs,
+      last_run_activity_at:
+        normalizedEntry.last_run_activity_at || prev.last_run_activity_at,
+      mode: normalizedEntry.mode || prev.mode,
+    };
+
+    runtimeStatusRegistry.set(key, guardedApplied);
+    syncRuntimeChannelSnapshotFromStatus(guardedApplied);
+    mirrorHeartbeatFromStatus(guardedApplied);
+    maybeAppendRuntimeStatusTransitionJournal(prev, guardedApplied);
+    scheduleRuntimeStateSnapshotPersist();
+    logRuntimeStatusDebug(
+      `status guarded key=${key} prev=${prev.status_source || "probe"}/${prev.link_status} next=${normalizedEntry.status_source || "probe"}/${normalizedEntry.link_status} reason=probe_connected_guarded_by_pending_without_event`,
+    );
+    return;
+  }
+
   if (prev && normalizedEntry.status_source !== "manual") {
     // manual 写入代表显式操作，优先级最高，不参与降级抑制。
     const prevRank = prev.last_status_rank ?? resolveStatusRank(prev);
@@ -2125,12 +2315,18 @@ function upsertRuntimeStatus(entry: RuntimeBotStatus): void {
         prev,
         next: normalizedEntry,
       });
+    const bypassProtectWindowForReportedFailure =
+      shouldApplyReportedFailureOverManualConnecting({
+        previous: prev,
+        next: normalizedEntry,
+      });
     const withinWindow = ageMs == null ? true : ageMs <= windowMs;
 
     if (
       nextRank < prevRank &&
       withinWindow &&
-      !bypassProtectWindowForEventRecovery
+      !bypassProtectWindowForEventRecovery &&
+      !bypassProtectWindowForReportedFailure
     ) {
       // 低优先级回写被抑制时，仍更新部分时效字段，避免观测面停滞。
       const preserveManualStopLifecycle =
@@ -4320,7 +4516,7 @@ function markRuntimeAccountsConnecting(
       last_heartbeat_at: startedAt,
       last_error: null,
       reconnect_count: 0,
-      restart_pending: false,
+      restart_pending: true,
       busy: false,
       active_runs: 0,
       last_run_activity_at: startedAt,
@@ -4980,6 +5176,7 @@ function applyRuntimeStatusSinkPayload(payload: RuntimeStatusSinkPayload): void
     hintedRestartPending:
       typeof payload.restart_pending === "boolean" ? payload.restart_pending : undefined,
     nextLinkStatus,
+    nextStatusSource: statusSource,
   });
   const startedAt = normalizeRuntimeHintTimestamp(payload.started_at);
   const heartbeatAt = normalizeRuntimeHeartbeatAt(
@@ -5805,18 +6002,25 @@ async function runFullProbeAndRefreshStatuses(params: {
         clearPlatformStatuses("weixin");
       }
     } else {
-      let weixinStatusApiForAudit: Record<string, unknown> = {};
-      try {
-        const weixinMod = (await import("ylib-openclaw-weixin")) as Record<
-          string,
-          unknown
-        >;
-        const wp = weixinMod.weixinPlugin as Record<string, unknown> | undefined;
-        weixinStatusApiForAudit =
-          (wp?.status as Record<string, unknown> | undefined) || {};
-      } catch {
-        weixinStatusApiForAudit = {};
-      }
+      const weixinMod = (await import("ylib-openclaw-weixin")) as Record<
+        string,
+        unknown
+      >;
+      const weixinPlugin = weixinMod.weixinPlugin as Record<string, unknown>;
+      const configApi = weixinPlugin.config as Record<string, unknown>;
+      const statusApi = weixinPlugin.status as Record<string, unknown>;
+      const resolveAccount = configApi?.resolveAccount as
+        | ((
+            inputCfg: Record<string, unknown>,
+            accountId: string,
+          ) => Record<string, unknown>)
+        | undefined;
+      const probeAccount = statusApi?.probeAccount as
+        | ((args: {
+            account: Record<string, unknown>;
+          }) => Promise<Record<string, unknown>>)
+        | undefined;
+
       prunePlatformStatusesByAccounts("weixin", configuredIds, cfg);
       const weixinProbeTargets = filterRuntimeIdsForOnlyKey(
         "weixin",
@@ -5829,7 +6033,7 @@ async function runFullProbeAndRefreshStatuses(params: {
             ? weixinProbeTargets
             : configuredIds
           : [];
-      if (weixinTargetsEffective.length > 0) {
+      if (resolveAccount && probeAccount && weixinTargetsEffective.length > 0) {
       await runWithConcurrency(
         weixinTargetsEffective,
         runtimeStatusProbeConcurrency.weixin,
@@ -5838,33 +6042,21 @@ async function runFullProbeAndRefreshStatuses(params: {
           if (shouldSkipAccountProbe(wk, forceProbeSweep)) return;
           const previous = getRuntimeBotStatusByKey(keyOf("weixin", accountId));
           try {
-            const invoke = await withProbeTimeout(
-              invokeGatewayMethodByChannel({
-                channel: "weixin",
-                method: "weixin.probe",
-                params: {
-                  accountId,
-                  forceProbe: forceProviderProbe,
-                  force_probe: forceProviderProbe,
-                  timeoutMs: tw,
-                },
-                accountId,
+            const account = resolveAccount(cfg, accountId);
+            const probeResult = await withProbeTimeout(
+              probeAccount({
+                account,
+                cfg,
+                forceProbe: forceProviderProbe,
+                force_probe: forceProviderProbe,
               }),
               tw,
-              `[bridges/main] weixin probe timeout account=${accountId} timeoutMs=${tw}`,
+              `[bridges/main] weixin probeAccount timeout account=${accountId} timeoutMs=${tw}`,
+            );
+            const ok = probeResult?.ok !== false;
+            const probeError = buildDetailedProbeErrorMessage(
+              probeResult as Record<string, unknown>,
             );
-            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,
             )
@@ -5873,35 +6065,41 @@ async function runFullProbeAndRefreshStatuses(params: {
                   readRecentBridgeErrorFromLog(accountId, "weixin"),
                 )
               : probeError;
-            const linkStatus: RuntimeBotStatus["link_status"] = probeOk
-              ? "connected"
-              : weixinBridgeStarted
-                ? "error"
-                : "connecting";
-            const probeAt = nowIso();
-            const mergedError = probeOk
+            if (!ok) {
+              console.error(
+                `[bridges/main] weixin probeAccount failed account=${accountId} raw=${toLogText(probeResult)}`,
+              );
+              console.error(
+                `[bridges/main] weixin probeAccount derived_error account=${accountId} error=${toLogText(probeErrorWithLogFallback || "")}`,
+              );
+            }
+            const error = ok
               ? null
               : pickMoreSpecificErrorMessage(
                   previous?.last_error || null,
-                  probeErrorWithLogFallback || invoke?.error || null,
+                  probeErrorWithLogFallback,
                 );
-            const runtimeHints = extractRuntimeStatusHints(
-              probeResult || invoke?.result || invoke || {},
-            );
+            if (!ok) {
+              console.error(
+                `[bridges/main] weixin probeAccount merged_error account=${accountId} error=${toLogText(error || "")}`,
+              );
+            }
+            const probeAt = nowIso();
+            const runtimeHints = extractRuntimeStatusHints(probeResult);
             upsertRuntimeProbe({
               platform: "weixin",
               bot_account_id: accountId,
               last_probe_at: probeAt,
-              ok: probeOk,
-              error: mergedError,
-              result: probeResult,
+              ok,
+              error,
+              result: (probeResult as Record<string, unknown>) || null,
               source: "probe",
             });
             await maybeRunChannelAuditAfterProbe({
-              statusApi: weixinStatusApiForAudit,
-              account: { accountId } as Record<string, unknown>,
+              statusApi,
+              account,
               cfg,
-              probeResult,
+              probeResult: (probeResult as Record<string, unknown>) || null,
               timeoutMs: tw,
               platform: "weixin",
               bot_account_id: accountId,
@@ -5909,16 +6107,16 @@ async function runFullProbeAndRefreshStatuses(params: {
             upsertRuntimeStatus({
               platform: "weixin",
               bot_account_id: accountId,
-              link_status: linkStatus,
+              link_status: ok ? "connected" : "error",
               started_at: previous?.started_at || nowIso(),
               last_heartbeat_at: probeAt,
-              last_error: mergedError,
+              last_error: error,
               reconnect_count:
                 runtimeHints.reconnect_count ?? previous?.reconnect_count ?? 0,
               restart_pending: resolveRuntimeRestartPendingForUpdate({
                 previous,
                 hintedRestartPending: runtimeHints.restart_pending,
-                nextLinkStatus: linkStatus,
+                nextLinkStatus: ok ? "connected" : "error",
               }),
               busy: runtimeHints.busy ?? false,
               active_runs: runtimeHints.active_runs ?? 0,
@@ -5946,7 +6144,7 @@ async function runFullProbeAndRefreshStatuses(params: {
             upsertRuntimeStatus({
               platform: "weixin",
               bot_account_id: accountId,
-              link_status: weixinBridgeStarted ? "error" : "connecting",
+              link_status: "error",
               started_at: previous?.started_at || nowIso(),
               last_heartbeat_at: probeAt,
               last_error: probeError,
@@ -5954,7 +6152,7 @@ async function runFullProbeAndRefreshStatuses(params: {
               restart_pending: resolveRuntimeRestartPendingForUpdate({
                 previous,
                 hintedRestartPending: undefined,
-                nextLinkStatus: weixinBridgeStarted ? "error" : "connecting",
+                nextLinkStatus: "error",
               }),
               busy: false,
               active_runs: 0,
@@ -7478,11 +7676,11 @@ async function startInternalApiServer(): Promise<void> {
             platform,
             bot_account_id: botAccountId,
             link_status: "connecting",
-            started_at: previous?.started_at || now,
+            started_at: now,
             last_heartbeat_at: now,
             last_error: null,
             reconnect_count: previous?.reconnect_count || 0,
-            restart_pending: false,
+            restart_pending: true,
             busy: false,
             active_runs: 0,
             last_run_activity_at: now,
@@ -7508,6 +7706,28 @@ async function startInternalApiServer(): Promise<void> {
             );
             return;
           }
+          if (
+            previous?.link_status === "disconnected" &&
+            previous?.status_source === "manual"
+          ) {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(
+              JSON.stringify({
+                ok: true,
+                status: "noop",
+                action: "stop",
+                reason: "already_stopped",
+                platform,
+                bot_account_id: botAccountId,
+                operation_id: operationId,
+                runtime_instance_id: runtimeInstanceId,
+                runtime_state: runtimeState,
+                issued_at: now,
+                bot: previous,
+              }),
+            );
+            return;
+          }
           await withRuntimeControlTimeout(
             control.stopAccount(botAccountId),
             `bot stop timeout platform=${platform} account=${botAccountId}`,
@@ -7549,7 +7769,7 @@ async function startInternalApiServer(): Promise<void> {
             platform,
             bot_account_id: botAccountId,
             link_status: "connecting",
-            started_at: previous?.started_at || now,
+            started_at: now,
             last_heartbeat_at: now,
             last_error: null,
             reconnect_count: previous?.reconnect_count || 0,
@@ -8333,6 +8553,7 @@ async function startInternalApiServer(): Promise<void> {
             previous: prev,
             hintedRestartPending: runtimeHintsFromEvent.restart_pending,
             nextLinkStatus: prev.link_status,
+            nextStatusSource: prev.status_source,
           });
           upsertRuntimeStatus({
             ...prev,
@@ -8390,6 +8611,7 @@ async function startInternalApiServer(): Promise<void> {
         previous: prev,
         hintedRestartPending: runtimeHintsFromEvent.restart_pending,
         nextLinkStatus: normalizedStatus,
+        nextStatusSource: "event",
       });
       upsertRuntimeStatus({
         platform: p,
@@ -8690,6 +8912,14 @@ async function main(): Promise<void> {
     restorePersistedRuntimeStateSnapshot(
       loadedConfigForRuntime as Record<string, unknown> | null,
     );
+    // 启动恢复后强制进入新生命周期 connecting 态，避免旧快照 connected 直接外显。
+    markConfiguredBotsAsConnecting(
+      (loadedConfigForRuntime as Record<string, unknown>) || {
+        channels: {},
+        bindings: [],
+      },
+      "startup_after_restore_connecting",
+    );
   }
 
   if (runtimeConfigPullUrl && !localConfigOnly && shouldRestoreRuntimeStateSnapshot) {

package/bridges/runtime/runtime-health-policy.ts

@@ -150,6 +150,33 @@ const runtimeSkipStaleHeartbeatModes = new Set(["webhook"]);
 const runtimeBusyActivityStaleMsDefault = 25 * 60_000;
 const runtimeGaveUpReconnectThreshold = 10;
 
+export function isExplicitReportedRuntimeFailure(
+  status: Pick<RuntimeStatusLike, "link_status" | "status_source">,
+): boolean {
+  return (
+    (status.status_source === "probe" || status.status_source === "event") &&
+    (status.link_status === "error" ||
+      status.link_status === "degraded" ||
+      status.link_status === "disconnected")
+  );
+}
+
+export function shouldApplyReportedFailureOverManualConnecting(params: {
+  previous:
+    | Pick<RuntimeStatusLike, "link_status" | "status_source">
+    | null
+    | undefined;
+  next: Pick<RuntimeStatusLike, "link_status" | "status_source">;
+}): boolean {
+  const previous = params.previous;
+  const previousSource = previous?.status_source || "probe";
+  return (
+    previousSource === "manual" &&
+    previous?.link_status === "connecting" &&
+    isExplicitReportedRuntimeFailure(params.next)
+  );
+}
+
 function parseIsoTimeMs(value: string | null | undefined): number | null {
   const text = String(value || "").trim();
   if (!text) return null;
@@ -242,6 +269,10 @@ export function evaluateRuntimeHealth(params: {
     };
   }
 
+  if (isExplicitReportedRuntimeFailure(status)) {
+    return { healthy: false, reason: "disconnected", evaluated_at: nowIsoText };
+  }
+
   // OpenClaw parity: startup grace is a lifecycle-level guard. Once a lifecycle
   // has just started, defer negative judgments until the connect grace elapses.
   if (lastStartAtMs != null) {
@@ -401,11 +432,28 @@ export function resolveRuntimeDisplayState(params: {
   };
 
   const linkConnected = params.status.link_status === "connected";
-  if (params.status.restart_pending === true && !linkConnected) {
+  if (params.status.restart_pending === true) {
+    if (statusText === "error") {
+      return build("error", "status:error", "status", {
+        hint: "重启/启动流程中探测失败，请检查凭证与网络后重试。",
+      });
+    }
+    if (statusText === "disconnected") {
+      return build("offline", "status:disconnected", "status", {
+        hint: "重启/启动流程中连接未建立，请检查运行链路。",
+      });
+    }
+    if (statusText === "degraded") {
+      return build("degraded", "status:degraded", "status", {
+        hint: "重启/启动流程中链路不稳定，等待下一轮探测收敛。",
+      });
+    }
     return build("reconnecting", "status:restart_pending", "status", {
       label: "重连中",
       color: "processing",
-      hint: "重启或重连流程进行中，尚未回到已连接状态。",
+      hint: linkConnected
+        ? "重启流程进行中，等待探测确认完成后再切换在线。"
+        : "重启或重连流程进行中，尚未回到已连接状态。",
     });
   }
 
@@ -458,14 +506,19 @@ export function resolveRuntimeDisplayState(params: {
     });
   }
   if (params.healthReason === "startup_grace") {
-    if (statusText === "connected") {
+    const statusSource = String(params.status.status_source || "")
+      .trim()
+      .toLowerCase();
+    if (statusText === "connected" && statusSource === "event") {
       return build("online", "status:connected", "status", {
         label: "在线",
         color: "success",
-        hint: "连接已建立，当前仍处于启动宽限窗口。",
+        hint: "已收到连接成功事件，当前仍处于启动宽限窗口。",
       });
     }
-    return build("connecting", "health:startup_grace", "health");
+    return build("connecting", "health:startup_grace", "health", {
+      hint: "启动宽限期内先显示连接中，收到连接成功事件后再切换在线。",
+    });
   }
 
   const normalizedFromStatus = normalizeRuntimeDisplayStatusFromText(statusText);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ylib-syim",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "description": "多 IM / 多 Agent 的会话路由与上下文管理（支持 /new）",
   "type": "module",
   "exports": {
@@ -48,7 +48,7 @@
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
     "ylib-dingtalk-connector": "0.7.10-beta.15",
     "ylib-openclaw-lark": "2026.3.17-beta.20",
-    "ylib-openclaw-weixin": "2.1.7-beta.7",
+    "ylib-openclaw-weixin": "2.1.7-beta.8",
     "axios": "^1.6.0",
     "dingtalk-stream": "^2.1.4",
     "fluent-ffmpeg": "^2.1.3",