@xmanrui/dsh-im 4.19.0 → 4.19.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmanrui/dsh-im",
-  "version": "4.19.0",
+  "version": "4.19.2",
   "description": "把十一种 IM 渠道和公网 AI Office 接入本机 DeepSeek Harness。 Connect eleven IM channels and a public AI Office to a local DeepSeek Harness.",
   "keywords": [
     "deepseek-harness",
@@ -52,6 +52,10 @@
     {
       "name": "geekyfoxlab",
       "url": "https://github.com/geekyfoxlab"
+    },
+    {
+      "name": "grloper",
+      "url": "https://github.com/grloper"
     }
   ],
   "license": "MIT",

package/plugin-src/client/bot-alias.js

@@ -72,10 +72,87 @@ function AliasDialog({ bot, onSave, onClose }) {
   return globalThis.document?.body ? createPortal(content, document.body) : content;
 }
 
+function BotNameTooltip({ anchorRef, id, name, onDismiss }) {
+  const tooltipRef = React.useRef(null);
+  const [position, setPosition] = React.useState(null);
+  React.useLayoutEffect(() => {
+    const anchor = anchorRef.current;
+    const tooltip = tooltipRef.current;
+    if (!anchor || !tooltip) return undefined;
+    const document = anchor.ownerDocument;
+    const view = document.defaultView;
+    const place = () => {
+      const rect = anchor.getBoundingClientRect();
+      const { width, height } = tooltip.getBoundingClientRect();
+      const viewport = document.documentElement;
+      const margin = 8;
+      const below = rect.bottom + 6;
+      setPosition({
+        left: Math.max(margin, Math.min(rect.left, viewport.clientWidth - width - margin)),
+        top: Math.max(margin, Math.min(
+          below + height <= viewport.clientHeight - margin ? below : rect.top - height - 6,
+          viewport.clientHeight - height - margin,
+        )),
+      });
+    };
+    const dismiss = (event) => {
+      if (event.key === 'Escape') { event.stopPropagation(); onDismiss(); }
+    };
+    place();
+    view.addEventListener('resize', place);
+    // Capture nested scrolling containers as well as page scrolling.
+    document.addEventListener('scroll', onDismiss, true);
+    document.addEventListener('keydown', dismiss, true);
+    return () => {
+      view.removeEventListener('resize', place);
+      document.removeEventListener('scroll', onDismiss, true);
+      document.removeEventListener('keydown', dismiss, true);
+    };
+  }, [anchorRef, name, onDismiss]);
+  const body = anchorRef.current?.ownerDocument.body;
+  return body ? createPortal(h('span', {
+    ref: tooltipRef, id, role: 'tooltip', className: 'dim-botNameTooltip',
+    style: position ?? { visibility: 'hidden' },
+  }, name), body) : null;
+}
+
 export function BotName({ bot, id, disabled = false, onSave }) {
   const [open, setOpen] = React.useState(false);
+  const nameRef = React.useRef(null);
+  const tooltipId = React.useId();
+  const [truncated, setTruncated] = React.useState(false);
+  const [hovered, setHovered] = React.useState(false);
+  const [focused, setFocused] = React.useState(false);
+  const [dismissed, setDismissed] = React.useState(false);
+  const dismissTooltip = React.useCallback(() => setDismissed(true), []);
+  const measure = React.useCallback(() => {
+    const node = nameRef.current;
+    setTruncated(Boolean(node && node.scrollWidth > node.clientWidth));
+  }, []);
+  React.useEffect(() => {
+    const node = nameRef.current;
+    if (!node) return undefined;
+    measure();
+    const view = node.ownerDocument.defaultView;
+    const observer = view.ResizeObserver ? new view.ResizeObserver(measure) : null;
+    observer?.observe(node);
+    view.addEventListener('resize', measure);
+    return () => { observer?.disconnect(); view.removeEventListener('resize', measure); };
+  }, [bot.name, measure]);
+  const showTooltip = truncated && !dismissed && !open && (hovered || focused);
   return h('div', { className: 'dim-aliasName' },
-    h('h3', { id, title: bot.name }, bot.name),
+    h('h3', {
+      id, ref: nameRef, tabIndex: truncated ? 0 : undefined,
+      'aria-describedby': showTooltip ? tooltipId : undefined,
+      onMouseEnter: () => { measure(); setHovered(true); setDismissed(false); },
+      onMouseLeave: () => setHovered(false),
+      onFocus: () => { measure(); setFocused(true); setDismissed(false); },
+      onBlur: () => setFocused(false),
+      onClick: dismissTooltip,
+    }, bot.name),
+    showTooltip ? h(BotNameTooltip, {
+      anchorRef: nameRef, id: tooltipId, name: bot.name, onDismiss: dismissTooltip,
+    }) : null,
     h('span', {
       className: 'dim-aliasEntry',
       onClick: (event) => event.stopPropagation(),

package/plugin-src/client/index.js

@@ -51,6 +51,10 @@ import { IMESSAGE_RPC_CHANNEL } from './channels/imessage/api.js';
 import { IMessageSettingsTab } from './channels/imessage/index.js';
 import { installIMessageStyles } from './channels/imessage/styles.js';
 import { en, h, IM_LOCALE_NAMESPACE, setImTranslator, zh } from './i18n.js';
+import {
+  HOST_LANGUAGE_RPC_CHANNEL,
+  installInterfaceLanguageMirror,
+} from './interface-language.js';
 import { BotSettingsContext } from './channel-card-meta.js';
 import {
   DELIVERY_RPC_CHANNEL,
@@ -398,6 +402,17 @@ export function apply(ctx) {
   const t = ctx.locale.bind(IM_LOCALE_NAMESPACE);
   setImTranslator(t);
 
+  // The settings page is the only place that knows the locale the interface is
+  // actually rendered in: DSH stores nothing when it came from the browser's
+  // language list. Report it so bot messages follow the same language.
+  ctx.effect(
+    () => installInterfaceLanguageMirror(ctx, {
+      rpcCall: (endpoint, payload, signal) =>
+        callManagementRpc(ctx.connection, HOST_LANGUAGE_RPC_CHANNEL, endpoint, payload, signal),
+    }),
+    'im-settings: mirror the DSH interface language',
+  );
+
   ctx.effect(() => installSessionChannelLogos(), 'im-settings: Session channel logos');
 
   ctx.effect(() => {

package/plugin-src/client/interface-language.js

@@ -0,0 +1,89 @@
+import { normalizeInterfaceLanguageTag } from '../../src/channels/shared/interface-language.mjs';
+import { createPollScheduler } from './lifecycle.js';
+
+/** Host route serving the interface-language mirror (plugin-src/host/host-language-rpc.mjs). */
+export const HOST_LANGUAGE_RPC_CHANNEL = '/dsh-im-language';
+export const HOST_LANGUAGE_ENDPOINTS = Object.freeze({
+  get: 'settings.language.get',
+  mirror: 'settings.language.mirror',
+});
+
+/** Widening retry delays for a report the Connection could not carry yet. */
+const RETRY_DELAYS_MS = Object.freeze([1_000, 4_000, 15_000]);
+
+/**
+ * Report the locale the settings UI is actually rendered in to the Host, so
+ * bot chat messages and command menus follow the DSH interface language.
+ *
+ * DSH stores a locale preference only when the reader picks one in the
+ * Language row: a locale derived from the browser's language list leaves the
+ * Host user-settings document empty. This mirror closes that gap, and the Host
+ * keeps an explicit selection ranked above it (see
+ * src/channels/shared/interface-language.mjs).
+ *
+ * The first report runs at plugin load, when the Connection may not be
+ * established yet, so a failed report is retried on a widening delay rather
+ * than waiting for a locale change that may never come. A failure is both a
+ * rejected promise and a resolved `{ ok: false }` envelope — the Host returns
+ * the latter when it could not persist the mirror, and that must retry too.
+ *
+ * @param ctx - client cordis context providing `locale` and the event bus.
+ * @param options.rpcCall - management RPC caller for HOST_LANGUAGE_RPC_CHANNEL.
+ * @returns an idempotent disposer that stops reporting and cancels any retry.
+ */
+export function installInterfaceLanguageMirror(ctx, {
+  rpcCall,
+  setTimeoutFn = (callback, delayMs) => globalThis.setTimeout(callback, delayMs),
+  clearTimeoutFn = (timer) => globalThis.clearTimeout(timer),
+  retryDelaysMs = RETRY_DELAYS_MS,
+} = {}) {
+  if (typeof rpcCall !== 'function' || typeof ctx?.locale?.getLocale !== 'function') {
+    return () => {};
+  }
+  const delays = retryDelaysMs.length > 0 ? retryDelaysMs : RETRY_DELAYS_MS;
+  const scheduler = createPollScheduler({ setTimeoutFn, clearTimeoutFn });
+  let mirrored = null;
+  let attempt = 0;
+
+  const retry = (active) => {
+    // Leave the tag unmirrored so the retry re-sends it. A Host that cannot
+    // persist the mirror still answers in its stored language; there is
+    // nothing for the reader to act on here.
+    if (mirrored === active) mirrored = null;
+    scheduler.schedule(report, delays[Math.min(attempt, delays.length - 1)]);
+    attempt += 1;
+  };
+
+  const report = () => {
+    if (scheduler.disposed) return;
+    const active = normalizeInterfaceLanguageTag(ctx.locale.getLocale()?.active);
+    if (active === null || active === mirrored) return;
+    mirrored = active;
+    Promise.resolve(rpcCall(HOST_LANGUAGE_ENDPOINTS.mirror, { locale: active })).then(
+      (result) => {
+        // Connection resolves failed business results normally; only a
+        // resolved ok envelope proves the Host actually persisted the mirror.
+        if (result?.ok === true) {
+          attempt = 0;
+          return;
+        }
+        retry(active);
+      },
+      () => retry(active),
+    );
+  };
+
+  report();
+  // A deliberate switch is worth reporting immediately, so it restarts the
+  // delay ladder instead of inheriting a previous failure's backoff.
+  const off = typeof ctx.on === 'function'
+    ? ctx.on('locale/change', () => {
+      attempt = 0;
+      report();
+    })
+    : null;
+  return () => {
+    scheduler.dispose();
+    if (typeof off === 'function') off();
+  };
+}

package/plugin-src/client/styles.js

@@ -3,9 +3,15 @@ export const IM_STYLE_ID = 'xmanrui-dsh-im-settings';
 const CSS = String.raw`
 .dim-aliasName { display: flex; align-items: center; gap: 4px; min-width: 0; }
 .dim-aliasName h3 { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.dim-aliasName h3:focus-visible { outline: 2px solid var(--dsw-alias-state-business-primary, #3370ff); outline-offset: 2px; border-radius: 3px; }
+.dim-botNameTooltip { position: fixed; z-index: 1000; box-sizing: border-box; width: max-content; max-width: min(320px, calc(100vw - 16px)); padding: 6px 9px; border: 1px solid var(--dsw-alias-border-l2, #dfe1e5); border-radius: 7px; color: var(--dsw-alias-label-primary, #1f2329); background: var(--dsw-alias-bg-layer-3, #fff); box-shadow: 0 8px 24px rgb(31 35 41 / 14%); font: 500 12px/18px -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; white-space: normal; overflow-wrap: anywhere; pointer-events: none; animation: dim-botNameTooltip-in .15s ease; }
+@keyframes dim-botNameTooltip-in { from { opacity: 0; } to { opacity: 1; } }
+@media (prefers-reduced-motion: reduce) { .dim-botNameTooltip { animation: none; } }
 .dim-aliasEntry { display: inline-flex; flex: none; }
-.dim-aliasEdit { display: grid; place-items: center; width: 28px; height: 28px; padding: 4px; border: 0; border-radius: 5px; color: var(--dsw-alias-label-secondary, #646a73); background: transparent; cursor: pointer; }
-.dim-aliasEdit:hover:not(:disabled) { color: var(--dsw-alias-state-business-primary, #3370ff); background: var(--dsw-alias-interactive-bg-hover, #f7f8fa); }
+.dim-aliasEdit { display: grid; place-items: center; width: 28px; height: 28px; padding: 4px; border: 0; border-radius: 5px; color: var(--dsw-alias-label-tertiary, #8f959e); background: transparent; cursor: pointer; }
+.dim-aliasEdit svg { opacity: .55; transition: opacity .15s ease; }
+.dim-aliasName:hover .dim-aliasEdit:not(:disabled) svg, .dim-aliasEdit:focus-visible svg { opacity: 1; }
+.dim-aliasEdit:hover:not(:disabled), .dim-aliasEdit:focus-visible { color: var(--dsw-alias-state-business-primary, #3370ff); background: var(--dsw-alias-interactive-bg-hover, #f7f8fa); }
 .dim-aliasDialog { box-sizing: border-box; width: min(380px, calc(100% - 32px)); max-height: calc(100dvh - 32px); overflow-y: auto; padding: 22px; border: 1px solid var(--dsw-alias-border-l2, #dfe1e5); border-radius: 12px; color: var(--dsw-alias-label-primary, #1f2329); background: var(--dsw-alias-bg-layer-3, #fff); box-shadow: 0 12px 36px rgb(0 0 0 / 18%); font: 13px/1.5 -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; }
 .dim-aliasDialog * { box-sizing: border-box; }
 .dim-aliasDialog::backdrop { background: rgb(15 17 21 / 30%); }
@@ -401,9 +407,9 @@ const CSS = String.raw`
 /* Header tooltips may extend beyond the card; the collapsible body clips its own content. */
 .dim-panel .dim-botCard { position: relative; min-width: 0; width: 100%; max-width: 100%; overflow: visible; border: 1px solid var(--dsw-alias-border-l2, #e5e6eb); border-radius: 14px; background: var(--dsw-alias-bg-layer-1, #fff); box-shadow: 0 1px 2px rgb(31 35 41 / 3%); }
 .dim-panel .dim-botCard::before { display: none; }
-.dim-panel .dim-botCardBody { position: relative; min-width: 0; width: 100%; max-width: 100%; padding: 12px; }
+.dim-panel .dim-botCardBody { position: relative; min-width: 0; width: 100%; max-width: 100%; padding: 12px 8px; }
 .dim-collapsibleAccount { min-width: 0; display: flex; flex-direction: column; }
-.dim-collapsibleHead { min-width: 0; display: flex; align-items: center; gap: 10px; cursor: pointer; user-select: none; -webkit-user-select: none; }
+.dim-collapsibleHead { min-width: 0; display: flex; align-items: center; gap: 4px; cursor: pointer; user-select: none; -webkit-user-select: none; }
 .dim-collapsibleHead:focus-visible { outline: 2px solid var(--dsw-alias-state-business-primary, #3370ff); outline-offset: 2px; border-radius: 8px; }
 .dim-collapsibleHeaderContent { min-width: 0; flex: 1 1 auto; display: flex; align-items: center; }
 .dim-collapsibleChevron { flex: 0 0 auto; display: inline-flex; align-items: center; justify-content: center; width: 9px; height: 9px; border-right: 1.6px solid var(--dsw-alias-label-tertiary, #8f959e); border-bottom: 1.6px solid var(--dsw-alias-label-tertiary, #8f959e); transform: rotate(-45deg); transition: transform .22s cubic-bezier(.4, 0, .2, 1); transform-origin: 50% 50%; }
@@ -413,14 +419,17 @@ const CSS = String.raw`
 .dim-collapsibleAccount.is-open > .dim-collapsibleBody { grid-template-rows: 1fr; }
 .dim-collapsibleBodyInner { min-height: 0; overflow: hidden; }
 .dim-collapsibleAccount:not(.is-open) .dim-collapsibleBodyInner { visibility: hidden; }
-.dim-panel .dim-botCardTop { min-width: 0; max-width: 100%; display: flex; align-items: flex-start; justify-content: space-between; gap: 12px; }
-.dim-panel .dim-botIdentity { min-width: 0; flex: 1 1 0; display: flex; align-items: center; gap: 10px; }
+/* Reclaim horizontal spacing for names while keeping status on the same row,
+   including when a channel's mobile stylesheet requests a column layout. */
+.dim-panel .dim-botCardTop { min-width: 0; width: 100%; max-width: 100%; display: flex; flex-direction: row; flex-wrap: nowrap; align-items: flex-start; justify-content: space-between; gap: 6px; }
+.dim-panel .dim-botIdentity { min-width: 0; flex: 1 1 0; display: flex; align-items: center; gap: 6px; }
 .dim-panel .dim-botAvatar { flex: none; width: 38px; height: 38px; display: grid; place-items: center; overflow: hidden; border-radius: 11px; box-shadow: none; }
 .dim-panel .dim-botAvatar svg { width: 27px; height: 27px; }
-.dim-panel .dim-botName { min-width: 0; }
+.dim-panel .dim-botName { min-width: 0; flex: 1; }
+.dim-panel .dim-aliasName { gap: 2px; }
 .dim-panel .dim-botName h3 { overflow: hidden; margin: 0; color: var(--dsw-alias-label-primary, #1f2329); font-size: 15px; font-weight: 650; line-height: normal; text-overflow: ellipsis; white-space: nowrap; }
 .dim-panel .dim-botName p { overflow: hidden; margin: 4px 0 0; color: var(--dsw-alias-label-secondary, #646a73); font: 12px ui-monospace, SFMono-Regular, monospace; line-height: normal; text-overflow: ellipsis; white-space: nowrap; }
-.dim-panel .dim-botCardTools { flex: none; display: flex; align-items: flex-start; gap: 8px; }
+.dim-panel .dim-botCardTools { flex: none; display: flex; align-items: flex-start; gap: 4px; }
 .dim-panel .dim-botHealthGroup { min-width: 0; max-width: 100%; flex: none; display: grid; justify-items: end; gap: 5px; }
 .dim-panel .dim-botCard .dim-botHealth { flex: none; min-height: 0; display: inline-flex; align-items: center; gap: 7px; padding: 0; border: 0; border-radius: 0; color: var(--dsw-alias-label-secondary, #646a73); background: transparent; font: inherit; font-size: 12px; font-weight: 400; line-height: normal; white-space: nowrap; }
 .dim-panel .dim-lastChecked { display: inline-flex; align-items: baseline; gap: 4px; color: var(--dsw-alias-label-tertiary, #8f959e); font: inherit; font-size: 11px; font-weight: 400; line-height: normal; white-space: nowrap; }

package/plugin-src/host/channels/shared/startup.mjs

@@ -1,7 +1,29 @@
 import { registerManagementRpc } from '../../../management-rpc.mjs';
+import { onImHostLanguageChange } from '../../../../src/channels/shared/i18n.mjs';
 import { resolveRpcAuthority } from '../../rpc-authority.mjs';
 import { publicChannelInitializing, publicChannelStartupError } from './startup-error.mjs';
 
+/**
+ * Keep a channel's platform-side command menu in the current host message
+ * language. Menus are registered with the platform when a bot connects, so a
+ * later language change has to re-send them; channels that publish no menu
+ * expose no refresh hook and are left alone.
+ */
+function followHostLanguage(ctx, channel, controller, logger) {
+  if (typeof controller?.refreshCommandMenus !== 'function') return;
+  const unsubscribe = onImHostLanguageChange(() => {
+    // Never run a slow or failing platform call inside the language switch:
+    // subscribers are synchronous and must not delay or break one another.
+    void Promise.resolve()
+      .then(() => controller.refreshCommandMenus())
+      .catch((error) => logger.warn?.(
+        `[dsh-im] failed to re-send the ${channel} command menu after a language change`,
+        error,
+      ));
+  });
+  ctx.effect(() => unsubscribe, `dsh-im: follow the host language for ${channel} command menus`);
+}
+
 /** Mount the native management RPC before any fallible production initialization. */
 export async function installProductionChannel(ctx, config, {
   channel, rpcChannel, createProduction, createHandler,
@@ -31,6 +53,7 @@ export async function installProductionChannel(ctx, config, {
       ? config.deliveryService.registerAdapter(production.deliveryAdapter) : undefined;
     const readyHandler = createHandler(production.controller);
     ctx.effect(() => closeProduction, `dsh-im: close ${channel} connections`);
+    followHostLanguage(ctx, channel, production.controller, logger);
     handler = readyHandler;
   } catch (error) {
     startupError = publicChannelStartupError(channel, error);

package/plugin-src/host/host-language-rpc.mjs

@@ -0,0 +1,71 @@
+import { registerManagementRpc } from '../management-rpc.mjs';
+import { normalizeInterfaceLanguageTag } from '../../src/channels/shared/interface-language.mjs';
+
+export const HOST_LANGUAGE_RPC_CHANNEL = '/dsh-im-language';
+export const HOST_LANGUAGE_ENDPOINTS = Object.freeze({
+  get: 'settings.language.get',
+  mirror: 'settings.language.mirror',
+});
+
+const ENDPOINTS = new Set(Object.values(HOST_LANGUAGE_ENDPOINTS));
+
+export function validHostLanguagePayload(endpoint, payload) {
+  if (!ENDPOINTS.has(endpoint)) return false;
+  if (payload === null || typeof payload !== 'object' || Array.isArray(payload)) return false;
+  const keys = Object.keys(payload);
+  if (endpoint === HOST_LANGUAGE_ENDPOINTS.mirror) {
+    if (keys.length !== 1 || keys[0] !== 'locale') return false;
+    // An explicit null clears the mirror; anything else must be a usable tag.
+    return payload.locale === null || normalizeInterfaceLanguageTag(payload.locale) !== null;
+  }
+  return keys.length === 0;
+}
+
+/**
+ * Serve the interface-language mirror. The settings UI is the only caller: it
+ * knows the locale the interface is actually rendered in, including a
+ * browser-derived one that DSH never stores.
+ */
+export function createHostLanguageRpcHandler({ controller, logger = null } = {}) {
+  if (!controller || typeof controller.snapshot !== 'function'
+    || typeof controller.mirror !== 'function') {
+    throw new TypeError('createHostLanguageRpcHandler requires a host language controller');
+  }
+  return async (endpoint, payload, signal) => {
+    if (!validHostLanguagePayload(endpoint, payload)) {
+      return { ok: false, error: { code: 'bad-request', message: 'Invalid interface language request.' } };
+    }
+    if (signal?.aborted) {
+      return { ok: false, error: { code: 'cancelled', message: 'Request cancelled.' } };
+    }
+    try {
+      if (endpoint === HOST_LANGUAGE_ENDPOINTS.get) {
+        return { ok: true, value: controller.snapshot() };
+      }
+      return { ok: true, value: await controller.mirror(payload.locale) };
+    } catch (error) {
+      // The failure is almost always a settings-directory write problem; keep
+      // the path and the underlying message out of the browser response.
+      logger?.warn?.('[dsh-im] could not persist the mirrored DSH interface language', error);
+      return {
+        ok: false,
+        error: {
+          code: 'interface-language-unavailable',
+          message: 'interface-language-unavailable',
+        },
+      };
+    }
+  };
+}
+
+export function installHostLanguageRpc(ctx, controller, authority) {
+  const logger = typeof ctx?.logger === 'function'
+    ? ctx.logger('dsh-im:language')
+    : (ctx?.logger ?? null);
+  return registerManagementRpc(
+    ctx,
+    HOST_LANGUAGE_RPC_CHANNEL,
+    createHostLanguageRpcHandler({ controller, logger }),
+    { authority },
+  );
+}

package/plugin-src/host/host-language.mjs

@@ -0,0 +1,157 @@
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+
+import {
+  getImHostLanguage,
+  normalizeImHostLanguage,
+  onImHostLanguageChange,
+  setImHostLanguage,
+} from '../../src/channels/shared/i18n.mjs';
+import {
+  normalizeInterfaceLanguageTag,
+  resolveHostLanguageTag,
+} from '../../src/channels/shared/interface-language.mjs';
+import { InterfaceLanguageStore } from '../../src/channels/shared/interface-language-store.mjs';
+
+/** Settings namespace and field owned by @deepseek-ai/dsh-client-locale. */
+export const DSH_LOCALE_NAMESPACE = 'locale';
+export const DSH_LOCALE_PREFERENCE_FIELD = 'preference';
+
+/**
+ * Resolve the durable interface-language mirror. The dshHome resolution
+ * mirrors pluginPaths: config.dshHome, then DSH_HOME, then the user's home
+ * directory. Channel-specific dataDir values never apply.
+ */
+export function interfaceLanguageSettingsPath(config = {}) {
+  const dshHome = resolve(config.dshHome ?? process.env.DSH_HOME ?? join(homedir(), '.dsh'));
+  return resolve(dshHome, 'integrations', 'dsh-im', 'interface-language.json');
+}
+
+/**
+ * Own the host message language across its resolution layers. `apply()` is
+ * idempotent: it re-resolves the layers and hands the winner to
+ * setImHostLanguage, which notifies observers only on a real change.
+ */
+export function createHostLanguageController({
+  store = null,
+  config: configLanguage,
+  readSettingsPreference = () => undefined,
+  logger = null,
+} = {}) {
+  const pinned = normalizeInterfaceLanguageTag(configLanguage);
+  let readPreference = typeof readSettingsPreference === 'function'
+    ? readSettingsPreference
+    : () => undefined;
+
+  const settingsTag = () => {
+    // A pinned language wins outright, so never consult the settings service
+    // for it: a detached provider must not produce a spurious diagnostic.
+    if (pinned !== null) return undefined;
+    try {
+      return readPreference();
+    } catch (error) {
+      logger?.warn?.(
+        '[dsh-im] could not read the DSH interface language preference; using the mirrored language',
+        error,
+      );
+      return undefined;
+    }
+  };
+
+  const mirrorTag = () => (typeof store?.getLanguageTag === 'function' ? store.getLanguageTag() : null);
+
+  const resolution = () => resolveHostLanguageTag({
+    config: configLanguage,
+    settings: settingsTag(),
+    mirror: mirrorTag(),
+  });
+
+  const describe = (resolved) => Object.freeze({
+    language: normalizeImHostLanguage(resolved.tag),
+    tag: resolved.tag,
+    source: resolved.source,
+    pinned: pinned !== null,
+  });
+
+  const apply = () => {
+    const resolved = resolution();
+    setImHostLanguage(resolved.tag ?? undefined);
+    return describe(resolved);
+  };
+
+  return Object.freeze({
+    apply,
+
+    /** The resolution as it stands, without switching the active language. */
+    snapshot: () => describe(resolution()),
+
+    /** Record the interface locale reported by the settings UI, then re-resolve. */
+    async mirror(value) {
+      if (typeof store?.setLanguageTag !== 'function') return apply();
+      await store.setLanguageTag(value ?? null);
+      return apply();
+    },
+
+    /** Replace the settings-preference reader once the service is injectable. */
+    observeSettings(read) {
+      readPreference = typeof read === 'function' ? read : () => undefined;
+      return apply();
+    },
+
+    /** Observe committed host language changes (see onImHostLanguageChange). */
+    observe: onImHostLanguageChange,
+
+    /** The active host message language, for callers that only need the switch. */
+    language: () => getImHostLanguage(),
+  });
+}
+
+/**
+ * Bind the host message language to DSH's interface language.
+ *
+ * The plugin's own `language` option stays authoritative for operators who set
+ * it. Otherwise the language follows DSH: the explicit Language-row selection
+ * from the Host user-settings document, and — because DSH stores nothing for a
+ * browser-derived locale — the language mirrored by the settings UI.
+ */
+export function installHostLanguage(ctx, config = {}, internals = {}) {
+  const logger = typeof ctx?.logger === 'function'
+    ? ctx.logger('dsh-im:language')
+    : (ctx?.logger ?? null);
+  const store = internals.store
+    ?? new InterfaceLanguageStore(interfaceLanguageSettingsPath(config));
+  const controller = createHostLanguageController({
+    store,
+    config: config.language ?? process.env.DSH_IM_LANGUAGE,
+    logger,
+  });
+  // Read an already-attached settings service synchronously: channels start
+  // inside the same activation, and waiting for the injection callback would
+  // let the first bot register its command menu in the previous language and
+  // then need a second push. The injection below keeps it live afterwards and
+  // covers a provider that attaches later.
+  controller.observeSettings(
+    () => ctx?.settings?.get?.(DSH_LOCALE_NAMESPACE)?.[DSH_LOCALE_PREFERENCE_FIELD],
+  );
+  const ready = Promise.resolve()
+    .then(() => store.load?.())
+    .then(() => controller.apply(), (error) => {
+      logger?.error?.(
+        '[dsh-im] could not read the mirrored DSH interface language; falling back to Chinese',
+        error,
+      );
+      return controller.snapshot();
+    });
+  if (typeof ctx?.inject === 'function') {
+    ctx.inject(['settings'], (settingsCtx) => {
+      controller.observeSettings(
+        () => settingsCtx.settings?.get?.(DSH_LOCALE_NAMESPACE)?.[DSH_LOCALE_PREFERENCE_FIELD],
+      );
+      settingsCtx.on('settings/updated', (namespace) => {
+        if (namespace !== DSH_LOCALE_NAMESPACE) return;
+        controller.apply();
+      });
+    });
+  }
+  return Object.freeze({ ...controller, ready });
+}

package/plugin-src/host/index.mjs

@@ -11,7 +11,8 @@ import { apply as applyWeixin } from './channels/weixin/index.mjs';
 import { apply as applyWhatsapp } from './channels/whatsapp/index.mjs';
 import { apply as applyIMessage } from './channels/imessage/index.mjs';
 import { installOutboundArtifactTool } from '../../src/channels/shared/semantic/artifact.mjs';
-import { setImHostLanguage } from '../../src/channels/shared/i18n.mjs';
+import { installHostLanguage } from './host-language.mjs';
+import { installHostLanguageRpc } from './host-language-rpc.mjs';
 import { installDeliveryRpc } from './delivery-rpc.mjs';
 import { installDeliveryHttp } from './delivery-http.mjs';
 import { createDeliveryService } from './delivery-service.mjs';
@@ -36,6 +37,8 @@ function channelConfig(config, name, deliveryService) {
 }
 
 export function createImHostPlugin(internals = {}) {
+  const startHostLanguage = internals.installHostLanguage ?? installHostLanguage;
+  const startHostLanguageRpc = internals.installHostLanguageRpc ?? installHostLanguageRpc;
   const startUpdate = internals.installUpdateRpc ?? installUpdateRpc;
   const startInboundTtl = internals.installInboundTtlRpc ?? installInboundTtlRpc;
   const startDelivery = internals.installDeliveryRpc ?? installDeliveryRpc;
@@ -109,7 +112,10 @@ export function createImHostPlugin(internals = {}) {
   });
 
   async function activateChannels(ctx, config, deliveryService) {
-    setImHostLanguage(config.language ?? process.env.DSH_IM_LANGUAGE);
+    // Bind the bot message language before any channel connects, so the first
+    // command menu a platform stores is already in the interface language.
+    const hostLanguage = startHostLanguage(ctx, config);
+    await hostLanguage?.ready;
     const startTitlePrefix = (titleCtx) => {
       // The installer owns its cleanup through ctx.effect(). Cordis startup
       // callbacks must not return its controller object as an effect.
@@ -134,6 +140,13 @@ export function createImHostPlugin(internals = {}) {
       ? ctx.logger(name)
       : (ctx?.logger ?? console);
     if (ctx?.connection?.fetch) {
+      if (hostLanguage) {
+        try {
+          startHostLanguageRpc(ctx, hostLanguage, config.rpcAuthority);
+        } catch (error) {
+          logger.error?.('[dsh-im] failed to activate interface language mirroring; continuing with channels', error);
+        }
+      }
       try {
         startUpdate(ctx);
       } catch (error) {

package/plugin-src/host/session-sync-coordinator.mjs

@@ -3,10 +3,7 @@ import {
   consumeDshImInputOrigin,
   textFromHarnessContent,
 } from '../../src/channels/shared/harness-client.mjs';
-import {
-  isSessionSyncMirrored,
-  releaseSessionSyncMirror,
-} from '../../src/channels/shared/session-sync-registry.mjs';
+import { deliverSessionSyncMirror } from '../../src/channels/shared/session-sync-registry.mjs';
 
 const DSH_USER_PREFIX = '[来自 DSH]\n';
 const DSH_ASSISTANT_PREFIX = '[DSH 助手]\n';
@@ -159,15 +156,19 @@ export function createSessionSyncCoordinator({ deliveryService, logger = console
     turns.delete(sessionId);
     if (state.origin !== 'dsh' || !completedTurn(event.data?.reason)
       || !state.recipients?.size || !state.assistant.text) return;
-    // Per-target suppression: targets whose process-card mirror delivered
-    // the answer are skipped; every other synced target still gets the text.
-    const mirrored = [];
-    const plain = [];
-    for (const target of state.recipients.values()) {
-      if (isSessionSyncMirrored(sessionId, target.targetId, state.turn)) mirrored.push(target);
-      else plain.push(target);
-    }
-    for (const target of mirrored) releaseSessionSyncMirror(sessionId, target.targetId);
+    // A pending card is not proof of delivery. Only suppress this target's
+    // text after its renderer confirms the complete final answer is visible.
+    // Targets without a renderer retain the original text delivery path.
+    const recipients = [...state.recipients.values()];
+    const rendered = await Promise.all(recipients.map(async (target) => {
+      try {
+        return await deliverSessionSyncMirror(target, sessionId, state.turn, state.assistant.text);
+      } catch (error) {
+        logFailure('card delivery', target, error);
+        return false;
+      }
+    }));
+    const plain = recipients.filter((_target, index) => !rendered[index]);
     if (plain.length === 0) return;
     await deliver(
       sessionId,