@xmanrui/dsh-im 4.14.0 → 4.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmanrui/dsh-im",
-  "version": "4.14.0",
+  "version": "4.15.0",
   "description": "把九种 IM 机器人和公网 AI Office 接入本机 DeepSeek Harness。 Connect nine IM channels and a public AI Office to a local DeepSeek Harness.",
   "keywords": [
     "deepseek-harness",

package/plugin-src/client/channels/feishu/index.js

@@ -310,7 +310,7 @@ function QrPane({ provision, now, onRefresh, onCancel, busy }) {
               ? "使用飞书确认群消息权限"
               : "使用飞书扫码创建机器人"),
         h("p", null, repairing
-          ? "扫码会更新现有飞书应用，增量补充当前缺少的卡片按钮回调、读取用户消息内图片或文件所需的 im:message:readonly（飞书显示为“获取单聊、群组消息”）、上传机器人图片或文件所需的 im:resource，以及原生命令面板所需的 application:app_slash_command:read / write；不会创建新应用。确认页只显示当前缺少项，完成后此机器人会短暂重连，其他机器人不受影响。"
+          ? "扫码会更新现有飞书应用，增量补充当前缺少的卡片按钮回调、读取用户消息内图片或文件所需的 im:message:readonly（飞书显示为“获取单聊、群组消息”）、上传机器人图片或文件所需的 im:resource、接收群内其他机器人 @ 当前机器人所需的 im:message.group_at_msg.include_bot:readonly，以及原生命令面板所需的 application:app_slash_command:read / write；不会创建新应用。确认页只显示当前缺少项，完成后此机器人会短暂重连，其他机器人不受影响。"
           : grantingGroupMessages
             ? "扫码会更新现有飞书应用，只增量开通“获取群组中所有消息”权限；不会创建新应用。确认后会自动启用“响应所有群消息”，其他机器人不受影响。"
             : "扫码只会新增一个机器人，已接入的机器人会继续正常收发消息。"),

package/plugin-src/client/i18n.js

@@ -459,7 +459,7 @@ const EN = Object.freeze({
   '权限配置已提交，正在启用全部消息模式并重连此机器人；此阶段无法取消，其他机器人不会中断。': 'The permission update was submitted. Enabling all-message mode and reconnecting this bot. This stage cannot be cancelled; other bots will not be interrupted.',
   '正在为现有飞书应用申请群消息权限二维码，请稍候。': 'Requesting a group-message permission QR code for the existing Feishu app…',
   '群消息权限没有开通完成': 'Group-message permission was not granted',
-  '扫码会更新现有飞书应用，增量补充当前缺少的卡片按钮回调、读取用户消息内图片或文件所需的 im:message:readonly（飞书显示为“获取单聊、群组消息”）、上传机器人图片或文件所需的 im:resource，以及原生命令面板所需的 application:app_slash_command:read / write；不会创建新应用。确认页只显示当前缺少项，完成后此机器人会短暂重连，其他机器人不受影响。': 'Scanning updates the existing Feishu app with the missing card-button callback, im:message:readonly for reading images or files in user messages (shown by Feishu as “Read direct and group messages”), im:resource for uploading images or files sent by the bot, and application:app_slash_command:read / write for the native command panel. It does not create a new app. The confirmation page shows only missing items; this bot reconnects briefly afterward, while other bots are unaffected.',
+  '扫码会更新现有飞书应用，增量补充当前缺少的卡片按钮回调、读取用户消息内图片或文件所需的 im:message:readonly（飞书显示为“获取单聊、群组消息”）、上传机器人图片或文件所需的 im:resource、接收群内其他机器人 @ 当前机器人所需的 im:message.group_at_msg.include_bot:readonly，以及原生命令面板所需的 application:app_slash_command:read / write；不会创建新应用。确认页只显示当前缺少项，完成后此机器人会短暂重连，其他机器人不受影响。': 'Scanning updates the existing Feishu app with the missing card-button callback, im:message:readonly for reading images or files in user messages (shown by Feishu as “Read direct and group messages”), im:resource for uploading images or files sent by the bot, im:message.group_at_msg.include_bot:readonly for receiving group messages from other bots that mention this bot, and application:app_slash_command:read / write for the native command panel. It does not create a new app. The confirmation page shows only missing items; this bot reconnects briefly afterward, while other bots are unaffected.',
   '核对现有应用名称，并确认只新增当前缺少的上述配置': 'Review the existing app name and confirm that only the missing items described above are added',
   '保持本页打开，等待权限与回调补全完成': 'Keep this page open until permissions and the callback are complete',
   '取消补全': 'Cancel setup',

package/plugin-src/client/index.js

@@ -59,6 +59,7 @@ import {
   replacePageLocation,
 } from './loopback-recovery.js';
 import { installImStyles } from './styles.js';
+import { installSessionChannelLogos } from './session-channel-logos.js';
 import { UpdatePanel, UPDATE_RPC_CHANNEL } from './update-panel.js';
 import { WorkspaceDirectoryPickerContext } from './workspace-editor.js';
 
@@ -366,6 +367,8 @@ export function apply(ctx) {
   const t = ctx.locale.bind(IM_LOCALE_NAMESPACE);
   setImTranslator(t);
 
+  ctx.effect(() => installSessionChannelLogos(), 'im-settings: Session channel logos');
+
   ctx.effect(() => {
     const disposers = [
       installFeishuStyles(),

package/plugin-src/client/session-channel-logos.js

@@ -0,0 +1,241 @@
+import { parseSessionChannelTitle } from '../../src/channels/shared/session-channel-labels.mjs';
+import {
+  WeixinLogoGlyph, FeishuLogoGlyph, DingtalkLogoGlyph, WecomLogoGlyph, QqLogoGlyph,
+  SlackLogoGlyph, TelegramLogoGlyph, DiscordLogoGlyph, WhatsappLogoGlyph, OfficeLogoGlyph,
+} from './channel-logos.js';
+
+const GLYPHS = Object.freeze({
+  weixin: [WeixinLogoGlyph, '#07c160'],
+  feishu: [FeishuLogoGlyph, '#3370ff'],
+  dingtalk: [DingtalkLogoGlyph, '#1677ff'],
+  wecom: [WecomLogoGlyph, '#3370ff'],
+  qq: [QqLogoGlyph, '#12b7f5'],
+  slack: [SlackLogoGlyph, '#e01e5a'],
+  telegram: [TelegramLogoGlyph, '#229ed9'],
+  discord: [DiscordLogoGlyph, '#5865f2'],
+  whatsapp: [WhatsappLogoGlyph, '#25d366'],
+  office: [OfficeLogoGlyph, '#f97316'],
+});
+const CHANNEL_ATTR = 'data-dsh-im-session-channel';
+const TITLE_ATTR = 'data-dsh-im-session-text';
+const MARKED = `[${CHANNEL_ATTR}]`;
+const ROW = '[role="treeitem"][aria-selected]';
+const SVG_NS = 'http://www.w3.org/2000/svg';
+const installations = new WeakMap();
+
+function hasClassPart(element, part) {
+  const match = new RegExp(`(?:^|[_-])${part}(?:$|[_-])`, 'u');
+  return [...element.classList].some((token) => match.test(token));
+}
+
+function titleOf(row) {
+  if (!row.matches(ROW) || row.closest('input, textarea, [contenteditable]:not([contenteditable="false"])')) return null;
+  let title;
+  if (row.tagName === 'DIV' && hasClassPart(row, 'sessionRow')) {
+    title = [...row.children].find((child) => child.tagName === 'SPAN' && hasClassPart(child, 'title'));
+  } else if (row.tagName === 'BUTTON' && hasClassPart(row, 'searchResultRow')) {
+    const heading = [...row.children].find((child) => hasClassPart(child, 'searchResultHeading'));
+    title = heading && [...heading.children].find((child) => child.tagName === 'SPAN' && hasClassPart(child, 'searchResultTitle'));
+  }
+  // Never cover inline rename inputs, highlighted search markup, or a future
+  // row structure that this adapter does not understand.
+  return title?.childNodes.length === 1 && title.firstChild.nodeType === 3 ? title : null;
+}
+
+/** Serialize the existing, static SVG glyphs without mounting React nodes. */
+function logoUri(document, channel) {
+  const [Glyph, color] = GLYPHS[channel];
+  const render = (node) => {
+    if (!['svg', 'path'].includes(node.type)) throw new Error('Unsupported channel logo element');
+    const element = document.createElementNS(SVG_NS, node.type);
+    for (const [name, value] of Object.entries(node.props)) {
+      if (name === 'children') continue;
+      const attribute = name.startsWith('stroke')
+        ? name.replace(/[A-Z]/gu, (letter) => `-${letter.toLowerCase()}`)
+        : name;
+      element.setAttribute(attribute, String(value));
+    }
+    for (const child of [node.props.children].flat().filter(Boolean)) element.appendChild(render(child));
+    return element;
+  };
+  const svg = render(Glyph({ size: 16 }));
+  svg.setAttribute('xmlns', SVG_NS);
+  svg.setAttribute('color', color);
+  return `data:image/svg+xml,${encodeURIComponent(svg.outerHTML)}`;
+}
+
+function createInstallation(document) {
+  const view = document.defaultView;
+  const ready = new Set();
+  const owned = new Map();
+  const queued = new Set();
+  const images = [];
+  let closed = false;
+  let scheduled = false;
+  const style = document.createElement('style');
+  style.dataset.pluginCss = 'dsh-im-session-channel-logos';
+  const uris = Object.fromEntries(Object.keys(GLYPHS).map((channel) => [channel, logoUri(document, channel)]));
+  style.textContent = `
+${MARKED}[${TITLE_ATTR}] {
+  position: relative;
+  -webkit-text-fill-color: transparent;
+  text-overflow: clip !important;
+  overflow: hidden;
+}
+${MARKED}[${TITLE_ATTR}]::before {
+  content: "";
+  position: absolute;
+  inset-inline-start: 0;
+  top: 50%;
+  transform: translateY(-50%);
+  width: 16px;
+  height: 16px;
+  background: var(--dsh-im-session-logo) center / contain no-repeat;
+  text-indent: 0;
+  pointer-events: none;
+}
+${MARKED}[${TITLE_ATTR}]::after {
+  content: attr(${TITLE_ATTR}) / "";
+  position: absolute;
+  inset: 0;
+  inset-inline-start: 22px;
+  -webkit-text-fill-color: currentColor;
+  text-indent: 0;
+  overflow: hidden;
+  white-space: nowrap;
+  text-overflow: ellipsis;
+  pointer-events: none;
+}
+${Object.entries(uris).map(([channel, uri]) => `[${CHANNEL_ATTR}="${channel}"] { --dsh-im-session-logo: url("${uri}"); }`).join('\n')}
+`;
+  document.head.appendChild(style);
+
+  const restore = (title) => {
+    const previous = owned.get(title);
+    if (!previous) return;
+    owned.delete(title);
+    for (const [attribute, value] of previous) {
+      if (value === null) title.removeAttribute(attribute);
+      else title.setAttribute(attribute, value);
+    }
+  };
+  const update = (row) => {
+    const title = row.isConnected ? titleOf(row) : null;
+    for (const marked of row.querySelectorAll(MARKED)) {
+      if (marked !== title) restore(marked);
+    }
+    if (!title) return;
+    const parsed = parseSessionChannelTitle(title.textContent);
+    if (!parsed || !ready.has(parsed.channel)) {
+      restore(title);
+      return;
+    }
+    if (!owned.has(title)) {
+      owned.set(title, [CHANNEL_ATTR, TITLE_ATTR].map((attribute) => [attribute, title.getAttribute(attribute)]));
+    }
+    // React retains its original text node, content, row, and handlers. Only
+    // plugin-owned attributes drive the visual replacement via pseudo-elements.
+    title.setAttribute(TITLE_ATTR, parsed.title);
+    title.setAttribute(CHANNEL_ATTR, parsed.channel);
+  };
+  const schedule = () => {
+    if (closed || scheduled || !queued.size) return;
+    scheduled = true;
+    queueMicrotask(() => {
+      scheduled = false;
+      if (closed) return;
+      const rows = [...queued];
+      queued.clear();
+      for (const row of rows) {
+        try {
+          update(row);
+        } catch {
+          for (const marked of row.querySelectorAll(MARKED)) restore(marked);
+        }
+      }
+    });
+  };
+  const collect = (node, descendants = false) => {
+    const element = node.nodeType === 1 ? node : node.parentElement;
+    if (!element) return;
+    const row = element.closest(ROW);
+    if (row) queued.add(row);
+    if (descendants) {
+      for (const child of element.querySelectorAll(ROW)) queued.add(child);
+      // Also restore an already decorated title moved outside a recognized row.
+      const marked = [...element.querySelectorAll(MARKED)];
+      if (owned.has(element)) marked.push(element);
+      for (const title of marked) {
+        const owner = title.closest(ROW);
+        if (owner) queued.add(owner);
+        else restore(title);
+      }
+    }
+    schedule();
+  };
+  const observer = new view.MutationObserver((records) => {
+    if (closed) return;
+    for (const record of records) {
+      collect(record.target, record.type === 'attributes');
+      if (record.type !== 'childList') continue;
+      for (const node of record.addedNodes) collect(node, true);
+      for (const node of record.removedNodes) {
+        if (node.nodeType !== 1 || node.isConnected) continue;
+        if (owned.has(node)) restore(node);
+        for (const title of node.querySelectorAll(MARKED)) restore(title);
+      }
+    }
+  });
+  observer.observe(document.body, {
+    subtree: true, childList: true, characterData: true,
+    attributes: true, attributeFilter: ['class', 'role', 'aria-selected', 'contenteditable'],
+  });
+
+  // A CSP or an image-loading failure leaves that channel's readable text
+  // prefix in place. No title is hidden until its actual SVG has loaded.
+  for (const [channel, uri] of Object.entries(uris)) {
+    const image = new view.Image();
+    images.push(image);
+    image.onload = () => {
+      if (closed) return;
+      ready.add(channel);
+      collect(document.body, true);
+    };
+    image.src = uri;
+  }
+  return () => {
+    closed = true;
+    observer.disconnect();
+    queued.clear();
+    for (const image of images) image.onload = null;
+    for (const title of [...owned.keys()]) restore(title);
+    style.remove();
+  };
+}
+
+/** Browser-only enhancement; unknown/unsupported surfaces keep text prefixes. */
+export function installSessionChannelLogos(document = globalThis.document) {
+  const view = document?.defaultView;
+  if (!document?.body || !document?.head || !view?.MutationObserver || !view?.Image
+    || !view.CSS?.supports?.('content', `attr(${TITLE_ATTR}) / ""`)
+    || !view.CSS.supports('-webkit-text-fill-color', 'transparent')) return () => {};
+  let entry = installations.get(document);
+  if (!entry) {
+    try {
+      entry = { references: 0, close: createInstallation(document) };
+    } catch {
+      return () => {};
+    }
+    installations.set(document, entry);
+  }
+  entry.references += 1;
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    entry.references -= 1;
+    if (entry.references > 0) return;
+    entry.close();
+    installations.delete(document);
+  };
+}

package/plugin-src/host/index.mjs

@@ -15,6 +15,7 @@ import { installDeliveryHttp } from './delivery-http.mjs';
 import { createDeliveryService } from './delivery-service.mjs';
 import { installInboundTtlRpc } from './inbound-ttl-rpc.mjs';
 import { installSessionSyncCoordinator } from './session-sync-coordinator.mjs';
+import { installSessionTitlePrefix } from './session-title-prefix.mjs';
 import { installUpdateRpc } from './update-rpc.mjs';
 
 export const name = 'dsh-im-host';
@@ -103,6 +104,19 @@ export function createImHostPlugin(internals = {}) {
 
   async function activateChannels(ctx, config, deliveryService) {
     setImHostLanguage(config.language ?? process.env.DSH_IM_LANGUAGE);
+    const startTitlePrefix = (titleCtx) => {
+      // The installer owns its cleanup through ctx.effect(). Cordis startup
+      // callbacks must not return its controller object as an effect.
+      installSessionTitlePrefix(titleCtx, {
+        logger: typeof titleCtx?.logger === 'function'
+          ? titleCtx.logger('dsh-im:session-title') : (titleCtx?.logger ?? console),
+      });
+    };
+    if (typeof ctx?.inject === 'function') {
+      ctx.inject(['sessions'], startTitlePrefix);
+    } else if (ctx?.sessions && typeof ctx.on === 'function') {
+      startTitlePrefix(ctx);
+    }
     if (typeof ctx?.inject === 'function') {
       ctx.inject(['tools', 'systemPrompt'], (artifactCtx) => {
         installOutboundArtifactTool(artifactCtx);

package/plugin-src/host/session-title-prefix.mjs

@@ -0,0 +1,122 @@
+import { getImHostLanguage } from '../../src/channels/shared/i18n.mjs';
+import { SESSION_CHANNEL_LABELS as CHANNEL_LABELS } from '../../src/channels/shared/session-channel-labels.mjs';
+const UUID = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}';
+// HarnessClient uses these ids for prompts and steering, independently of
+// context enhancement. Read the durable source, never the message's text.
+const IM_RPC_ID = new RegExp(`^(${Object.keys(CHANNEL_LABELS).join('|')})-(?:steer-)?${UUID}$`, 'u');
+const LEGACY_SESSION_ID = new RegExp(`^(${Object.keys(CHANNEL_LABELS).join('|')})-.+`, 'u');
+
+function eventsOf(session) {
+  const events = typeof session?.snapshotEvents === 'function'
+    ? session.snapshotEvents()
+    : session?.events;
+  return Array.isArray(events) ? events : [];
+}
+
+function channelOf(session, events) {
+  // A Web-created fork must not acquire a channel just from its parent's
+  // messages. Both supported Session implementations expose this boundary.
+  const inherited = session.inheritedEventCount;
+  if (session.header?.parentSession && !Number.isSafeInteger(inherited)) return null;
+  for (const event of events) {
+    if (Number.isSafeInteger(inherited) && event.seq < inherited) continue;
+    if (event.type !== 'user/message' || event.data?.source?.kind !== 'user') continue;
+    const channel = IM_RPC_ID.exec(event.data.source.rpcId)?.[1];
+    if (channel) return channel;
+  }
+  if (session.header?.parentSession) return null;
+  return LEGACY_SESSION_ID.exec(session.id ?? session.sessionId)?.[1] ?? null;
+}
+
+export function withSessionChannelPrefix(title, channel, language = getImHostLanguage()) {
+  const labels = CHANNEL_LABELS[channel];
+  if (!labels || typeof title !== 'string' || !title.trim()) return title;
+  // Keep the original title intact, including Unicode graphemes. The Host
+  // has already normalized and capped its generated text before this point.
+  if (labels.some((label) => title.startsWith(`${label} · `))) return title;
+  return `${labels[language === 'en' ? 1 : 0]} · ${title}`;
+}
+
+function validTitleData(data) {
+  if (typeof data?.title !== 'string' || !data.title.trim()
+    || !Array.isArray(data.messageSeqs)) return false;
+  if (data.source?.kind === 'user') return data.messageSeqs.length === 0;
+  if (!['fallback', 'provider'].includes(data.source?.kind)
+    || data.messageSeqs.length === 0
+    || data.messageSeqs.some((seq) => !Number.isSafeInteger(seq) || seq < 0)) return false;
+  return data.source.kind !== 'provider'
+    || (typeof data.source.provider === 'string' && Boolean(data.source.provider));
+}
+
+/**
+ * Decorate accepted titles without session.rename(): rename pins them as
+ * user-owned and supersedes automatic generation. Appending a log-only title
+ * with the same source and citations preserves the Host's scheduling and
+ * explicit-rename semantics. No provider, prompt, or stored event is changed.
+ */
+export function installSessionTitlePrefix(ctx, { logger = console } = {}) {
+  if (typeof ctx?.on !== 'function' || typeof ctx?.sessions?.get !== 'function'
+    || typeof ctx?.sessions?.list !== 'function') {
+    throw new TypeError('Session title prefixes require Host sessions and events');
+  }
+  const pending = new Map();
+  let closed = false;
+
+  const decorate = (session) => {
+    if (closed || ctx.sessions.get(session.id ?? session.sessionId) !== session
+      || typeof session.append !== 'function') return;
+    const events = eventsOf(session);
+    const channel = channelOf(session, events);
+    if (!channel) return;
+    const latest = events.findLast((event) => event.type === 'session/title');
+    if (!validTitleData(latest?.data)) return;
+    const title = withSessionChannelPrefix(latest.data.title, channel);
+    if (title === latest.data.title) return;
+    // There is no await between the latest-title read and this append. A
+    // queued old result can therefore never replace a newer/manual title.
+    session.append('session/title', {
+      ...structuredClone(latest.data),
+      title,
+    });
+  };
+
+  const enqueue = (session) => {
+    if (closed || pending.has(session)) return;
+    // Leave the current append/notification stack before writing another
+    // event, so persistence and client projections observe monotonically
+    // ordered events. Read the newest title when the microtask runs.
+    const task = Promise.resolve().then(() => {
+      pending.delete(session);
+      decorate(session);
+    }).catch((error) => {
+      logger.warn?.('[dsh-im] unable to add Session channel prefix:', error?.message ?? error);
+    }).finally(() => {
+      if (pending.get(session) === task) pending.delete(session);
+    });
+    pending.set(session, task);
+  };
+
+  const disposeEvent = ctx.on('session/event', (session, event) => {
+    if (event?.type === 'session/title'
+      || (event?.type === 'user/message' && IM_RPC_ID.test(event.data?.source?.rpcId))) {
+      enqueue(session);
+    }
+  }, { global: true });
+  const disposeCreated = ctx.on('session/created', enqueue, { global: true });
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    disposeEvent?.();
+    disposeCreated?.();
+  };
+  if (typeof ctx.effect === 'function') {
+    ctx.effect(() => close, 'dsh-im: Session title channel prefixes');
+  }
+  for (const session of ctx.sessions.list()) enqueue(session);
+  return Object.freeze({
+    close,
+    async whenIdle() {
+      while (pending.size) await Promise.allSettled([...pending.values()]);
+    },
+  });
+}

package/scripts/verify-session-channel-logos.mjs

@@ -0,0 +1,59 @@
+// Real browser/React verification, with no running DSH Host or IM accounts.
+// CHROME_PATH overrides the browser executable. An optional argument is the output directory.
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { resolve, join } from 'node:path';
+import { promisify } from 'node:util';
+import { pathToFileURL } from 'node:url';
+import { build } from 'esbuild';
+
+const args = process.argv.slice(2);
+const prepareOnly = args.includes('--prepare-only');
+const outputArg = args.find((argument) => argument !== '--prepare-only');
+const browser = process.env.CHROME_PATH ?? [
+  '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+  '/usr/bin/chromium', '/usr/bin/chromium-browser', '/usr/bin/google-chrome',
+].find(existsSync);
+if (!browser && !prepareOnly) throw new Error('Set CHROME_PATH to a Chromium/Chrome executable.');
+const output = outputArg ? resolve(outputArg) : await mkdtemp(join(tmpdir(), 'dsh-im-session-logos-'));
+await mkdir(output, { recursive: true });
+const built = await build({
+  entryPoints: [resolve(import.meta.dirname, '../test/browser/session-channel-logos.fixture.js')],
+  bundle: true, write: false, format: 'iife', platform: 'browser', target: 'chrome100',
+  define: { 'process.env.NODE_ENV': '"development"' },
+});
+const html = `<!doctype html><html lang="zh-CN"><meta charset="utf-8"><title>DSH-IM Session Logo Preview</title>
+<style>
+*{box-sizing:border-box}body{margin:0;background:#f8f9fb;color:#202329;font:14px/20px -apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif}
+.preview{display:flex;min-height:720px}aside{width:350px;flex:none;padding:24px 12px;background:#f0f2f5;border-right:1px solid #e4e6eb}header{padding:0 12px 26px}header strong{display:block;font-size:17px;line-height:26px}small{display:block;color:#7a818e;font-size:11px}.workspace{padding:8px 12px;color:#6f7684;font-size:12px}
+._sessionRow_dsh_104{height:32px;display:flex;align-items:center;gap:0;border-radius:8px;padding:0 8px;cursor:pointer;user-select:none;color:inherit}._sessionRow_dsh_104:hover,._sessionRow_dsh_104.selected{background:#e0e5ec}._title_dsh_170{flex:1;min-width:0;margin:0 6px 0 4px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:14px;line-height:20px}.status{width:16px;flex:none;color:#77a891;text-align:center}.time{font-size:10px;color:#8d95a1}button{font:inherit;cursor:pointer}aside button{border:0;background:none;color:#707a89;width:22px;height:24px}
+main{flex:1;padding:55px 44px}.eyebrow{font-size:10px;font-weight:650;letter-spacing:.13em;color:#788292}h1{font-size:30px;line-height:40px;font-weight:650;margin:12px 0}main>p{color:#727c8a}.message{margin-top:35px;padding:18px 22px;border:1px solid #e3e7ed;border-radius:12px;background:#fff}.message strong{font-size:12px}.message p{color:#626d7c}h2{font-size:13px;font-weight:550;margin:26px 0 8px}._searchResultRow_dsh_25{display:flex;flex-direction:column;align-items:stretch;width:100%;border:1px solid #e3e7ed;border-radius:8px;padding:10px;background:white;text-align:left}._searchResultHeading_dsh_305{display:flex;min-width:0}._searchResultTitle_dsh_313{flex:1;min-width:0;font-size:14px;line-height:20px;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}.search small{margin-top:5px}.note{font-size:11px;margin-top:32px}#result{margin:0;padding:14px 24px;border-top:1px solid #e4e6eb;background:#eef6f1;color:#357759;font:10px/16px ui-monospace,monospace}body[data-result=failed] #result{color:#a22;background:#fee}
+@media(prefers-color-scheme:dark){body{background:#1b1e23;color:#e4e7eb}aside{background:#22262d;border-color:#333941}._sessionRow_dsh_104:hover,._sessionRow_dsh_104.selected{background:#353d49}.message,._searchResultRow_dsh_25{background:#252a32;border-color:#39404b;color:inherit}.message p{color:#c1c8d1}#result{background:#23382e;color:#a2d0b2;border-color:#39404b}}
+</style><body><div id="app"></div><pre id="result">Running browser checks…</pre>
+<script>${built.outputFiles[0].text.replace(/<\/script/giu, '<\\/script')}</script></body></html>`;
+const htmlPath = join(output, 'preview.html');
+await writeFile(htmlPath, html
+  .replace('._sessionRow_dsh_104{', '._dsh_sessionRow,._sessionRow_dsh_104{')
+  .replaceAll('._sessionRow_dsh_104:hover,._sessionRow_dsh_104.selected{', '._dsh_sessionRow:hover,._dsh_sessionRow.selected,._sessionRow_dsh_104:hover,._sessionRow_dsh_104.selected{')
+  .replace('._title_dsh_170{', '._dsh_title,._title_dsh_170{')
+  .replace('._searchResultTitle_dsh_313{flex:1;', '._searchResultTitle_dsh_313{flex:0 auto;'));
+if (prepareOnly) {
+  console.log(`Prepared browser fixture: ${htmlPath}`);
+  process.exit(0);
+}
+const profile = await mkdtemp(join(tmpdir(), 'dsh-im-logo-browser-'));
+const screenshot = join(output, 'preview.png');
+const { stdout, stderr } = await promisify(execFile)(browser, [
+  '--headless', '--disable-gpu', '--no-sandbox', '--hide-scrollbars',
+  `--user-data-dir=${profile}`, '--no-first-run', '--no-default-browser-check',
+  '--window-size=1100,800', '--force-device-scale-factor=1', '--virtual-time-budget=8000',
+  `--screenshot=${screenshot}`, '--dump-dom', pathToFileURL(htmlPath).href,
+], { maxBuffer: 8 * 1024 * 1024, timeout: 30_000 }).finally(() => rm(profile, { recursive: true, force: true }));
+await writeFile(join(output, 'browser.log'), stderr);
+await writeFile(join(output, 'result.html'), stdout);
+const result = stdout.match(/<pre id="result">([\s\S]*?)<\/pre>/u)?.[1] ?? 'No browser result';
+if (!stdout.includes('data-result="passed"')) throw new Error(result);
+console.log(result);
+console.log(`Preview: ${screenshot}`);

package/scripts/verify-session-title-prefix.mjs

@@ -0,0 +1,149 @@
+// Exercise the plugin against an actual built Harness checkout, without an
+// LLM request or a running Host. Run:
+// node scripts/verify-session-title-prefix.mjs /path/to/dsh [all-prompts|first-prompt]
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import { createImHostPlugin } from '../plugin-src/host/index.mjs';
+
+if (!process.argv[2]) throw new Error('Pass the path of a built DSH checkout.');
+const root = resolve(process.argv[2]);
+const automatic = process.argv[3] ?? 'all-prompts';
+assert.ok(['all-prompts', 'first-prompt'].includes(automatic));
+const fromHarness = createRequire(resolve(root, 'packages/session/session-title/package.json'));
+const load = (name) => import(pathToFileURL(fromHarness.resolve(name)).href);
+const { Context } = await load('@deepseek-ai/cordis');
+const { default: SessionStore, SessionId } = await load('@deepseek-ai/dsh-session');
+const { default: SessionProjectionRegistry } = await load('@deepseek-ai/dsh-session-projection');
+const { default: SessionTitleService, SessionTitleProviderId } = await load('@deepseek-ai/dsh-session-title');
+const { createUserMessage } = await load('@deepseek-ai/dsh-llm');
+
+const ctx = new Context();
+const fibers = [];
+for (const [plugin, config] of [
+  [SessionStore],
+  [SessionProjectionRegistry],
+  [SessionTitleService, { fallbackMaxWords: 10, fallbackMaxBytes: 60, maxTitleBytes: 60 }],
+]) {
+  const fiber = ctx.plugin(plugin, config);
+  fibers.push(fiber);
+  await fiber.await();
+}
+// Use the complete Host activation path: Cordis treats returned controller
+// objects as invalid effects and disposes their listeners after startup.
+for (const [name, value] of Object.entries({
+  connection: { rpc: { handle: () => () => {} } }, credentials: {},
+  typertGateway: { stream() {} }, sessionController: {}, workspaceController: {},
+})) ctx.provide(name, value);
+const internals = Object.fromEntries(
+  ['Feishu', 'Weixin', 'Dingtalk', 'Wecom', 'Qq', 'Slack', 'Telegram', 'Discord', 'Whatsapp', 'Office']
+    .map((channel) => [`apply${channel}`, async () => {}]),
+);
+Object.assign(internals, {
+  installUpdateRpc: () => {}, installInboundTtlRpc: () => {},
+  installDeliveryRpc: () => {}, installSessionSyncCoordinator: () => {},
+});
+const host = ctx.plugin(createImHostPlugin(internals));
+fibers.push(host);
+await host.await();
+const settle = async () => {
+  await new Promise((done) => setTimeout(done, 0));
+};
+await settle();
+const prompt = (session, text, channel = 'weixin') => session.append('user/message', createUserMessage({
+  content: [{ type: 'text', text }],
+  source: { kind: 'user', rpcId: `${channel}-00000000-0000-4000-8000-000000000000` },
+}), { surfaceOp: 'append' });
+const request = (session) => session.append('request/header', {
+  header: { config: { provider: 'test-provider', model: 'test-model' } }, reason: 'change',
+});
+let calls = 0;
+let release;
+let aborted = false;
+ctx.sessionTitle.register({
+  id: SessionTitleProviderId('test-title-provider'),
+  automatic,
+  async generate(input) {
+    calls += 1;
+    input.signal.addEventListener('abort', () => { aborted = true; });
+    if (calls === 1) await new Promise((done) => { release = done; });
+    return { title: `自动标题 ${calls}`, messageSeqs: input.messages.map((message) => message.seq) };
+  },
+});
+const session = ctx.sessions.create(SessionId('ordinary-host-generated-id'));
+session.append('turn/start', { turn: 1 });
+prompt(session, '第一次消息');
+request(session);
+await settle();
+assert.equal(ctx.sessionTitle.get(session).title, '微信 · 第一次消息');
+assert.equal(ctx.sessionTitle.get(session).source.kind, 'fallback');
+assert.equal(calls, 1);
+assert.equal(aborted, false, 'adding the fallback prefix must not abort the active title provider');
+release();
+await settle();
+assert.equal(ctx.sessionTitle.get(session).title, '微信 · 自动标题 1');
+assert.equal(ctx.sessionTitle.get(session).source.kind, 'provider');
+assert.equal(ctx.sessionTitle.get(session).source.provider, 'test-title-provider');
+
+prompt(session, '第二次消息');
+request(session);
+await settle();
+const automaticCalls = automatic === 'all-prompts' ? 2 : 1;
+assert.equal(calls, automaticCalls, 'the original automatic generation cadence must be preserved');
+assert.equal(ctx.sessionTitle.get(session).title, `微信 · 自动标题 ${automaticCalls}`);
+assert.equal(ctx.sessionProjections.stateOf(session, 'title'), `微信 · 自动标题 ${automaticCalls}`);
+assert.equal(aborted, false);
+
+ctx.sessionTitle.rename(session, '自定义标题');
+await settle();
+assert.equal(ctx.sessionTitle.get(session).title, '微信 · 自定义标题');
+assert.equal(ctx.sessionTitle.get(session).source.kind, 'user');
+prompt(session, '手动命名后的消息');
+request(session);
+await settle();
+assert.equal(calls, automaticCalls, 'a real user rename must retain the normal pin');
+await ctx.sessionTitle.refresh(session);
+await settle();
+assert.equal(calls, automaticCalls + 1);
+assert.equal(ctx.sessionTitle.get(session).title, `微信 · 自动标题 ${automaticCalls + 1}`);
+assert.equal(ctx.sessionTitle.get(session).source.kind, 'provider');
+
+const ordinary = ctx.sessions.create(SessionId('web-created'));
+ordinary.append('turn/start', { turn: 1 });
+prompt(ordinary, '网页消息', 'web');
+await settle();
+assert.equal(ctx.sessionTitle.get(ordinary).title, '网页消息');
+
+// The production Feishu path can create its initial title before the first
+// prompt. The listener must still be alive after the Host has finished loading.
+let feishu;
+const creator = ctx.plugin({
+  name: 'feishu-session-regression', inject: ['sessions'],
+  apply(scoped) {
+    feishu = scoped.sessions.create(SessionId('feishu-host-generated-id'));
+    feishu.append('session/title', {
+      title: '你好，你是谁？', messageSeqs: [], source: { kind: 'user' },
+    });
+    prompt(feishu, '你好，你是谁？', 'feishu');
+  },
+});
+fibers.push(creator);
+await creator.await();
+await settle();
+assert.equal(ctx.sessionTitle.get(feishu).title, '飞书 · 你好，你是谁？');
+assert.equal(ctx.sessionTitle.get(feishu).source.kind, 'user');
+
+const sourceEvents = session.snapshotEvents();
+for (const event of sourceEvents.filter((entry) => entry.type === 'session/title')) {
+  assert.equal(event.data.messageSeqs.length === 0, event.data.source.kind === 'user');
+  for (const seq of event.data.messageSeqs) {
+    assert.equal(sourceEvents[seq].type, 'user/message');
+    assert.equal(sourceEvents[seq].data.source.kind, 'user');
+    assert.ok(seq < event.seq);
+  }
+  assert.ok(!event.data.title.includes('微信 · 微信 · '));
+}
+for (const fiber of fibers.reverse()) await fiber.dispose();
+console.log(`Session channel prefix verified against ${root} (${automatic}): active generation, later generation, projections, manual rename, refresh, Web sessions, and title-source invariants passed.`);