dsh-panel-control 0.7.2 → 0.8.3

package/README.md

@@ -10,6 +10,7 @@
 - **分组折叠** — 点分组标题收起该组，只留标题与计数；`Enter` / 空格同样可切换，状态写进配置。侧栏收成图标条时不显示标题，也不折叠。
 - **侧栏溢出兜底** — 导航项变多时，官方侧栏会把下方的会话/工作区列表压到 0 高且无法滚动（[讨论 #12083](https://github.com/deepseek-ai/deepseek-harness/discussions/12083)）。本插件给导航列表加上限高与滚动，给下方区域留最小高度。
 - **自动分类** — 用当前 profile 的默认模型读入口名称，自动分成 2–4 组。只处理没见过的入口，不会改动你排好的顺序；随时可手动「重新分类」。
+- **设置页补入口** — 有的第三方插件只注册了设置页（`settings.section`），却没给面板入口，设置页只能从设置弹窗里翻到。本插件为这类插件自动补一行侧栏入口：点开就是宿主渲染的完整设置页，顶部带「返回对话」；不依赖插件白名单，整体可在「侧栏布局」里关掉。
 - **面板管理自己不可隐藏** — 避免把自己锁在门外；未接管的节点（如「更多」）始终排在最后。
 
 ## 界面
@@ -22,13 +23,15 @@
 
 两个入口：侧栏导航里的「面板管理」行，以及 **设置 → 面板管理**（同一套管理界面整块嵌在设置页）。
 
+补出来的设置页入口也出现在同一个侧栏列表里，排在普通入口之后、本插件自己之前；标题沿用设置页自己的名称，重复时附带设置页 id 以区分。
+
 ## 安装
 
 从 npm 安装（推荐）：
 
 ```bash
 cd C:/Users/<you>/.dsh/profiles/desktop
-npm install dsh-panel-control@0.7.2
+npm install dsh-panel-control@0.8.3
 ```
 
 把包名加进同一目录 `package.json` 的 `dsh.profile.bundles`：
@@ -64,24 +67,26 @@ cmd //c mklink /J node_modules\dsh-panel-control D:\Github\dsh-panel-control
 
 - 高度兜底开关，以及 35 / 45 / 55 / 不限 四档上限；
 - 分组折叠开关，以及「全部收起 / 全部展开」；
+- 设置页入口开关（默认开）。关掉后补出来的行会连同注册一起撤掉，不只是藏起来；
 - 折叠状态按分组 id 记在配置里，重启后保留。
 
 ## 配置与存储
 
-布局写在 Host 侧：`~/.dsh/panel-control/prefs.json`（`~` 是这个 profile 的用户目录）。包含顺序、隐藏项、分组、折叠状态、布局开关与分类结果。
+布局写在 Host 侧：`~/.dsh/panel-control/prefs.json`（`~` 是这个 profile 的用户目录）。包含顺序、隐藏项、分组、折叠状态、布局开关、设置页入口开关与分类结果。
 
 页面 origin 是 Host 的 loopback 端口，每次启动都会换端口，`localStorage` 会因此"看起来每次清空"——所以真实存储放在 Host 侧，`localStorage` 只留镜像；读不到 Host 时才回退到镜像。配置按安装维度生效，不跟随工作区。
 
 ## 排错
 
 - **侧栏没有「面板管理」**：先重载一次页面。仍没有，看 `~/.dsh/panel-control/host.log` 与 `client.log`。
+- **设置页入口没补出来**：`host.log` 里先搜 `bridge-scan`，启动后的前几次扫描会列出当时可见的设置页（`id:registrant`）和侧栏条目；再搜 `kind=bridge` 看最终补出的 id。目标插件出现在 `sections` 里但 `ids` 没它，说明它的 section id 或 label 与某个已有面板重合，被归属规则当成了已有入口；始终不出现，是它的设置页注册得比扫描更晚（见 `docs/bridged-settings-pages.md`）。
 - **插件管理显示运行，界面却没变化**：页面多半还在用旧的 bundle revision（刚改过 `client.js` 时常见），重载一次即可。
 - **改了代码没反应**：确认 `BUILD_STAMP` 与 `package.json` 的版本一致，并跑一遍 `npm run check`。
 
 ## 开发与测试
 
 ```bash
-npm run check     # 语法检查 + 宿主路由 smoke + 布局/版本静态断言
+npm run check     # 语法检查 + 宿主路由 smoke + 布局/桥接静态与行为断言
 npm run smoke     # 只跑宿主路由用例
 npm run doctor    # 体检 profile 安装状态
 ```
@@ -89,8 +94,9 @@ npm run doctor    # 体检 profile 安装状态
 - `.scratch/harness.html`：引擎测试页（伪造 DOM 与 ctx），覆盖排序、隐藏、分组、折叠、脏数据清洗。
 - `scripts/host-smoke.mjs`：驱动宿主侧路由，覆盖设置读写、分类请求与 bundle 兜底。
 - `scripts/layout-smoke.mjs`：断言侧栏布局的 CSS 钩子与关键数值，并校验 `BUILD_STAMP` 与版本号一致。
+- `scripts/bridge-smoke.mjs`：在假 ctx 上跑 `client.js`，断言只给「有设置页、没有侧栏入口」的第三方插件补行，且成对注册 main、开关关闭后整体撤回、桥接页经自有子槽交给宿主渲染并能返回对话。
 
-进一步材料：[docs/sidebar-layout.md](docs/sidebar-layout.md)（布局与折叠实现）、[docs/ui-design-notes.md](docs/ui-design-notes.md)（界面规范与踩坑）、[docs/discussion-bundle-evaluated-twice.md](docs/discussion-bundle-evaluated-twice.md)（bundle 被求值两次的事故复盘）。
+进一步材料：[docs/sidebar-layout.md](docs/sidebar-layout.md)（布局与折叠实现）、[docs/bridged-settings-pages.md](docs/bridged-settings-pages.md)（设置页补入口的识别与渲染）、[docs/ui-design-notes.md](docs/ui-design-notes.md)（界面规范与踩坑）、[docs/discussion-bundle-evaluated-twice.md](docs/discussion-bundle-evaluated-twice.md)（bundle 被求值两次的事故复盘）。
 
 ## 边界
 
@@ -99,6 +105,7 @@ npm run doctor    # 体检 profile 安装状态
 - 依赖宿主侧栏的 DOM 结构（`[class*="panelList"]` 与面板按钮的 `aria-label`），官方大改版时需要跟进。
 - 只写 `style.order`、`style.display` 与 `data-dpc-*` 属性，不移动 React 节点，不改宿主代码。
 - 排序、隐藏、分组都只影响本机这份安装。
+- 设置页入口按「section id / label 是否已被某个面板占用」识别归属，不依赖插件声明的注册者（client runner 会把多个插件报成同一个名字）；代价是启发式：与面板同名的第三方设置页会被视为已有入口，新增内置设置页需要更新 `CORE_SECTION_IDS`。第三方设置页按宿主渲染器原位渲染，若它自己依赖设置弹窗的私有上下文，可能出现布局差异。
 
 ## 许可
 

package/client.js

@@ -5,7 +5,7 @@
   // Everything below therefore lives inside this closure. Re-evaluation must stay possible: when the
   // plugin is switched off the loader drops our factory, so switching it back on re-executes this
   // script and needs the registration that follows.
-  const BUILD_STAMP = 'dsh-panel-control/0.7.2';
+  const BUILD_STAMP = 'dsh-panel-control/0.8.3';
   try { window.__dpcEvaluated = BUILD_STAMP; } catch { /* ignore */ }
 /**
  * Client half of dsh-panel-control.
@@ -265,6 +265,14 @@ function build(require) {
   const SLOT_MAIN = 'main';
   const SLOT_SETTINGS = 'settings.section';
   const PANEL_KEY = 'panel-control';
+  /** Bridged pages get their own ids; the prefix also keeps them out of the host's reserved keys. */
+  const BRIDGE_PREFIX = 'dpc-bridge-';
+  const BRIDGE_SLOT_PREFIX = 'dpc-bridge-slot-';
+  /** Between the ordinary entries and this manager's own row (order 90). */
+  const BRIDGE_ORDER = 85;
+  const BRIDGE_DEBOUNCE_MS = 120;
+  /** Boot-time rescans: plugins register their settings page while the page starts. */
+  const BRIDGE_RETRY_MS = [350, 900, 2000, 4200, 8000, 15000];
   const STORAGE_KEY = 'dsh.panel-control.v1';
   /** Host route that answers "file these entries into groups" (see index.js). */
   const RPC_CHANNEL = '/api';
@@ -377,6 +385,16 @@ function build(require) {
     layoutCollapseHint: { zh: '点分组标题收起该组，标题与数量仍保留。', en: 'Click a group title to fold it; the title and count stay.' },
     layoutMax: { zh: '高度上限', en: 'Height cap' },
     layoutMaxNone: { zh: '不限', en: 'No cap' },
+    layoutBridge: { zh: '补全设置页入口', en: 'Entries for settings pages' },
+    layoutBridgeHint: {
+      zh: '第三方插件只做了设置页、没做侧栏入口时，替它在侧栏补一个入口。关掉后这些入口全部移除，插件自己的设置页不受影响。',
+      en: 'When a third-party plugin ships a settings page but no sidebar entry, add one for it. Turning this off removes only those entries; the plugin keeps its settings page.',
+    },
+    bridgeBack: { zh: '返回对话', en: 'Back to conversation' },
+    bridgeTag: { zh: '设置页', en: 'Settings page' },
+    bridgeFrom: { zh: '来自 {p}', en: 'From {p}' },
+    bridgeMissing: { zh: '这个设置页已经不可用。', en: 'This settings page is no longer available.' },
+    diagBridge: { zh: '补全入口', en: 'bridged entries' },
     layoutCollapseAll: { zh: '全部收起', en: 'Fold all' },
     layoutExpandAll: { zh: '全部展开', en: 'Unfold all' },
     layoutCollapseOne: { zh: '点此收起', en: 'click to fold' },
@@ -468,6 +486,7 @@ function build(require) {
     collapsed: [],
     guard: true,
     collapse: true,
+    bridge: true,
     panelMax: 45,
   });
 
@@ -508,6 +527,9 @@ function build(require) {
     // explicit false is the only way to turn the CSS off.
     out.guard = raw.guard !== false;
     out.collapse = raw.collapse !== false;
+    // Missing in files written before the bridge existed: those installs get the
+    // feature by default, exactly like a fresh one.
+    out.bridge = raw.bridge !== false;
     const cap = Math.round(Number(raw.panelMax));
     out.panelMax = Number.isFinite(cap) ? Math.min(70, Math.max(0, cap)) : 45;
     if (Array.isArray(raw.groups)) {
@@ -559,7 +581,13 @@ function build(require) {
       (prefs.groups || []).length > 0 ||
       (prefs.collapsed || []).length > 0 ||
       (prefs.autoFiled || []).length > 0 ||
-      prefs.auto === true);
+      prefs.auto === true ||
+      // A file that only turned a switch off is still a file the reader edited;
+      // without this, the next load treats it as empty and drops the edit.
+      prefs.guard === false ||
+      prefs.collapse === false ||
+      prefs.bridge === false ||
+      (typeof prefs.panelMax === 'number' && prefs.panelMax !== 45));
 
   /** One call to the Host half, or null when this Client cannot reach it. */
   async function hostCall(method, payload) {
@@ -900,6 +928,339 @@ function build(require) {
     left.length === right.length &&
     left.every((row, index) => row.id === right[index].id && row.label === right[index].label);
 
+  /* -------------------------------------------------------------- bridges */
+
+  /**
+   * Settings pages with no panel of their own.
+   *
+   * A Client plugin addresses its settings page with `settings.section`; the
+   * sidebar only lists `sidebar.panellist` entries, and the two registries are
+   * unrelated. A plugin that never registers a panel therefore has a reachable
+   * settings page and no way to open it from the navigation rail. This block
+   * gives each such page a panel of its own: a panellist row plus the `main`
+   * entry it addresses, whose body is the host's own renderer for that section.
+   *
+   * A slot entry's `registrant` names the Cordis fiber that registered it, but
+   * the client runner applies many plugins inside one fiber: in practice every
+   * plugin except the market reports the same name, so a registrant match cannot
+   * tell one plugin from another. Attribution is therefore by ownership of the
+   * navigation row: a settings id whose base name (with a trailing `-settings`
+   * removed) is an existing panel id, or whose label is an existing panel label,
+   * belongs to a plugin that already has a way in. Core settings ids are listed
+   * explicitly; they ship without a panel because that is the product decision,
+   * not a gap.
+   */
+  const CORE_SECTION_IDS = new Set(['account', 'general', 'models', 'agent-presets', 'plugins']);
+
+  const bridgeState = {
+    entries: new Map(),
+    labels: new Map(),
+    timer: null,
+    retries: new Set(),
+    retriesStarted: false,
+    syncing: false,
+    scans: 0,
+    unsub: null,
+  };
+
+  function registrantOf(entry) {
+    const options = (entry && entry.options) || {};
+    const value = (entry && entry.registrant) || options.registrant;
+    return typeof value === 'string' ? value : '';
+  }
+
+  function readSections(slots) {
+    try {
+      const raw = slots && typeof slots.entriesOfSlot === 'function' ? slots.entriesOfSlot(SLOT_SETTINGS) || [] : [];
+      return raw
+        .map((entry) => {
+          const options = (entry && entry.options) || {};
+          return {
+            id: typeof options.id === 'string' ? options.id : '',
+            label: options.label,
+            registrant: registrantOf(entry),
+            component: entry && entry.component,
+            inject: options.inject,
+            store: options.store,
+            locale: options.locale,
+          };
+        })
+        .filter((section) => section.id !== '');
+    } catch {
+      return [];
+    }
+  }
+
+  function panelEntries(slots) {
+    try {
+      return (slots && typeof slots.entriesOfSlot === 'function' ? slots.entriesOfSlot(SLOT_PANELS) || [] : [])
+        .map((entry) => entry && entry.options)
+        .filter((options) => options && typeof options.id === 'string' && options.id !== '')
+        .map((options) => ({ id: options.id, label: resolveLabel(options.label, options.id) }));
+    } catch {
+      return [];
+    }
+  }
+
+  function sectionBase(id) {
+    return id.endsWith('-settings') ? id.slice(0, -'-settings'.length) : id;
+  }
+
+  /**
+   * Every settings page whose plugin owns no sidebar entry.
+   *
+   * A plugin may expose more than one settings page; each becomes its own row,
+   * labelled with the plugin's own section label. A label already used by a real
+   * panel is suffixed with the settings id so two rows never read the same.
+   */
+  function bridgeCandidates(slots) {
+    const rows = panelEntries(slots).filter((row) => !row.id.startsWith(BRIDGE_PREFIX));
+    const panelIds = new Set(rows.map((row) => row.id));
+    const panelLabels = new Set(rows.map((row) => row.label));
+    // Real panel labels own their names; a bridged row must not steal one, and
+    // must not collide with another bridged row either.
+    const used = new Set(panelLabels);
+    const out = [];
+    const taken = new Set();
+    for (const section of readSections(slots)) {
+      if (CORE_SECTION_IDS.has(section.id)) continue;
+      const base = sectionBase(section.id);
+      let owned = panelIds.has(section.id) || panelIds.has(base);
+      if (!owned) {
+        for (const panelId of panelIds) {
+          if (panelId.endsWith('-' + base)) {
+            owned = true;
+            break;
+          }
+        }
+      }
+      if (owned) continue;
+      const label = resolveLabel(section.label, section.id);
+      if (panelLabels.has(label)) continue;
+      if (typeof section.component !== 'function') continue;
+      const bridgeId = BRIDGE_PREFIX + section.id;
+      if (bridgeId.length > LIMITS.key || taken.has(bridgeId)) continue;
+      taken.add(bridgeId);
+      const chosen = used.has(label) ? `${label} · ${section.id}` : label;
+      used.add(chosen);
+      out.push({
+        bridgeId,
+        sectionId: section.id,
+        label: chosen,
+        component: section.component,
+        inject: section.inject,
+        store: section.store,
+        locale: section.locale,
+      });
+    }
+    return out;
+  }
+
+  /** The layout's live selection, read through the public store when it exposes one. */
+  function activePanelId() {
+    try {
+      const layout = optionalService(ctxRef, 'layout');
+      const info = layout && layout.panelInfo;
+      const snapshot = info && typeof info.getSnapshot === 'function' ? info.getSnapshot() : info;
+      return snapshot && typeof snapshot.activePanelId === 'string' ? snapshot.activePanelId : null;
+    } catch {
+      return null;
+    }
+  }
+
+  function disposeBridge(id, record) {
+    bridgeState.entries.delete(id);
+    for (const dispose of record.disposers.slice().reverse()) {
+      try {
+        dispose();
+      } catch (error) {
+        console.warn(`[${PACKAGE}] bridge cleanup failed for "${id}"`, error);
+      }
+    }
+    // The main key this row addressed is gone, so a reader sitting on it would
+    // stare at an empty centre column. The Conversation is the only safe landing.
+    if (activePanelId() === id) {
+      try {
+        const layout = optionalService(ctxRef, 'layout');
+        if (layout && typeof layout.selectPanel === 'function') layout.selectPanel(null);
+      } catch {
+        /* nothing was selected after all */
+      }
+    }
+  }
+
+  function syncBridges() {
+    const slots = ctxRef && ctxRef.slots;
+    if (!slots || typeof slots.register !== 'function' || bridgeState.syncing) return;
+    bridgeState.syncing = true;
+    bridgeState.scans += 1;
+    let changed = false;
+    try {
+      const enabled = prefsNow().bridge !== false;
+      watchSettings();
+      const sections = readSections(slots);
+      const panelIds = panelEntries(slots).map((row) => row.id);
+      const candidates = enabled ? bridgeCandidates(slots) : [];
+      const desired = new Set(candidates.map((candidate) => candidate.bridgeId));
+      bridgeState.labels = new Map(candidates.map((candidate) => [candidate.bridgeId, candidate.label]));
+      for (const [id, record] of Array.from(bridgeState.entries)) {
+        if (desired.has(id)) continue;
+        disposeBridge(id, record);
+        changed = true;
+      }
+      for (const candidate of candidates) {
+        if (bridgeState.entries.has(candidate.bridgeId)) continue;
+        const slotName = BRIDGE_SLOT_PREFIX + candidate.sectionId;
+        const record = { disposers: [] };
+        try {
+          record.disposers.push(
+            slots.register(
+              {
+                name: SLOT_MAIN,
+                key: candidate.bridgeId,
+                locale: NS,
+                children: { [slotName]: { kind: 'single', scope: 'root' } },
+              },
+              makeBridgePanel(candidate, slotName),
+            ),
+          );
+          // The settings shell owns the `settings.section` declaration, so its
+          // props-face renderer is not ours to call. Declaring one child slot of
+          // our own and re-registering the same component into it gives the
+          // section the host kit it expects (inject, locale, store, boundary)
+          // without touching the shell or the foreign registration.
+          record.disposers.push(
+            slots.register(
+              {
+                name: slotName,
+                inject: candidate.inject,
+                store: candidate.store,
+                locale: candidate.locale,
+              },
+              candidate.component,
+            ),
+          );
+          record.disposers.push(
+            slots.register(
+              {
+                name: SLOT_PANELS,
+                id: candidate.bridgeId,
+                order: BRIDGE_ORDER,
+                locale: NS,
+                label: () => bridgeState.labels.get(candidate.bridgeId) || candidate.label,
+              },
+              BridgeIcon,
+            ),
+          );
+          bridgeState.entries.set(candidate.bridgeId, record);
+          changed = true;
+        } catch (error) {
+          for (const dispose of record.disposers.slice().reverse()) {
+            try {
+              dispose();
+            } catch {
+              /* the pair is already half gone */
+            }
+          }
+          console.warn(`[${PACKAGE}] could not add a panel for "${candidate.sectionId}"`, error);
+        }
+      }
+      // Early scans run while plugins are still registering. Keeping a trace of
+      // exactly what the slot returned tells a later reader whether a missing
+      // row is a timing problem or an ownership guess that did not hold.
+      if (bridgeState.scans <= 8 || changed) {
+        reportHost({
+          kind: 'bridge-scan',
+          enabled,
+          scans: bridgeState.scans,
+          sections: sections.map((section) => `${section.id}:${section.registrant || '?'}`).join('|'),
+          panels: panelIds.join('|'),
+          ids: Array.from(bridgeState.entries.keys()).join(','),
+        });
+      }
+      if (changed) {
+        reportHost({
+          kind: 'bridge',
+          enabled,
+          ids: Array.from(bridgeState.entries.keys()).join(','),
+          sections: candidates.length,
+        });
+        // The diagnostics line in the settings card reads this count; without a
+        // re-render it would keep showing the value from before the sync.
+        emit();
+      }
+    } catch (error) {
+      console.warn(`[${PACKAGE}] bridge sync failed`, error);
+    } finally {
+      bridgeState.syncing = false;
+    }
+  }
+
+  function scheduleBridgeSync() {
+    if (bridgeState.timer) clearTimeout(bridgeState.timer);
+    bridgeState.timer = setTimeout(() => {
+      bridgeState.timer = null;
+      syncBridges();
+    }, BRIDGE_DEBOUNCE_MS);
+  }
+
+  /**
+   * Watch the section registry.
+   *
+   * `subscribe` is trustworthy only once the slot is declared. The plugin runs
+   * before some of the plugins it bridges, so an early subscription can resolve
+   * to nothing and never be retried; the declaration callback calls this again.
+   */
+  function watchSettings() {
+    if (bridgeState.unsub) return;
+    const slots = ctxRef && ctxRef.slots;
+    if (!slots || typeof slots.subscribe !== 'function') return;
+    try {
+      const dispose = slots.subscribe(SLOT_SETTINGS, () => scheduleBridgeSync());
+      bridgeState.unsub = typeof dispose === 'function' ? dispose : () => {};
+    } catch {
+      /* not declared yet; the next scan or declaration retries */
+    }
+  }
+
+  function unwatchSettings() {
+    if (!bridgeState.unsub) return;
+    try {
+      bridgeState.unsub();
+    } catch {
+      /* the slot is already gone */
+    }
+    bridgeState.unsub = null;
+  }
+
+  function scheduleBridgeRetry(delay) {
+    const id = setTimeout(() => {
+      bridgeState.retries.delete(id);
+      if (ctxRef) syncBridges();
+    }, delay);
+    // Browsers return a number; Node returns an object. Letting the harness
+    // exit without waiting out the last boot scan keeps `npm run check` quick.
+    if (id && typeof id.unref === 'function') id.unref();
+    bridgeState.retries.add(id);
+  }
+
+  function scheduleBridgeRetries() {
+    if (bridgeState.retriesStarted) return;
+    bridgeState.retriesStarted = true;
+    for (const delay of BRIDGE_RETRY_MS) scheduleBridgeRetry(delay);
+  }
+
+  function disposeBridges() {
+    if (bridgeState.timer) {
+      clearTimeout(bridgeState.timer);
+      bridgeState.timer = null;
+    }
+    for (const id of Array.from(bridgeState.retries)) clearTimeout(id);
+    bridgeState.retries.clear();
+    unwatchSettings();
+    for (const [id, record] of Array.from(bridgeState.entries)) disposeBridge(id, record);
+  }
+
   /** The stored order, extended with every entry that is new since it was saved. */
   function normalize(prefs, entries) {
     const known = new Set(entries.map((entry) => entry.id));
@@ -1447,6 +1808,9 @@ function build(require) {
     scheduleSaveToHost();
     emit();
     if (engineRef) engineRef.schedule();
+    // The bridge switch lives here too; toggling it must add or drop the rows
+    // right away rather than on the next unrelated registration.
+    scheduleBridgeSync();
   }
 
   function setDiag(patch) {
@@ -1477,6 +1841,8 @@ function build(require) {
       if (!stored || !hasContent(stored)) await hostCall('save', { prefs: chosen });
     }
     setDiag({ prefsSource: prefsSource.value, hostFile });
+    // The Host copy may carry the bridge switch with it.
+    scheduleBridgeSync();
   }
 
   const prefsNow = () => store.state.prefs;
@@ -1747,6 +2113,7 @@ function build(require) {
     plus: 'M12 6v12M6 12h12',
     eye: 'M2.5 12S6 6.5 12 6.5 21.5 12 21.5 12 18 17.5 12 17.5 2.5 12 2.5 12Z',
     eyeOff: 'M2.5 12S6 6.5 12 6.5c1.6 0 3 .45 4.2 1.1M21.5 12S18 17.5 12 17.5c-1.6 0-3-.45-4.2-1.1M4 4l16 16',
+    back: 'M14.5 6.5 9 12l5.5 5.5',
   };
 
   /** One 16px line glyph, one 1.5 stroke, colours inherited from the text role. */
@@ -1807,6 +2174,105 @@ function build(require) {
 
   const PanelIcon = SlidersIcon;
 
+  /**
+   * A page glyph with text lines: the settings page, not the plugin's own icon
+   * (that one belongs to the plugin and is not available to the bridge).
+   */
+  function BridgeIcon(props) {
+    const size = props && typeof props.size === 'number' ? props.size : 18;
+    const active = Boolean(props && props.active);
+    return h(
+      'svg',
+      {
+        width: size,
+        height: size,
+        viewBox: '0 0 24 24',
+        fill: 'none',
+        'aria-hidden': true,
+        style: { display: 'block', opacity: active ? 1 : 0.78 },
+      },
+      h('rect', {
+        x: 3.5,
+        y: 4.5,
+        width: 17,
+        height: 15,
+        rx: 2.5,
+        stroke: 'currentColor',
+        strokeWidth: 1.6,
+      }),
+      h('path', {
+        d: 'M8 9.5h8M8 12h5M8 14.5h8',
+        stroke: 'currentColor',
+        strokeWidth: 1.5,
+        strokeLinecap: 'round',
+      }),
+    );
+  }
+
+  /**
+   * One bridged page: a back bar, then the host's renderer for the section.
+   *
+   * The settings shell owns the `settings.section` declaration, so the ctx-level
+   * `slots.renderSlot` cannot reach it: that entry point only renders `root`, and
+   * a child slot is renderable only through the props face of the entry that
+   * declared it. Each bridge therefore declares its own single-child slot and
+   * re-registers the section component into it (see `syncBridges`), and renders
+   * that slot through the `renderSlot` prop the host hands this component. The
+   * host still builds the section's kit — inject, locale, store, boundary and
+   * hooks all stay its own. The owner prop is the same `close` the settings shell
+   * passes, wired to the Conversation because this page has no dialog to close.
+   */
+  function makeBridgePanel(candidate, slotName) {
+    const back = () => {
+      try {
+        const layout = optionalService(ctxRef, 'layout');
+        if (layout && typeof layout.selectPanel === 'function') layout.selectPanel(null);
+      } catch {
+        /* the Conversation is already showing */
+      }
+    };
+    return function BridgePanel(props) {
+      const renderSlot = props && typeof props.renderSlot === 'function' ? props.renderSlot : null;
+      let node = null;
+      try {
+        if (renderSlot) node = renderSlot(slotName, { close: back }, {});
+      } catch (error) {
+        console.warn(`[${PACKAGE}] could not render settings page "${candidate.sectionId}"`, error);
+      }
+      return h(
+        'div',
+        { className: 'dpc-root dpc-bridge' },
+        h(
+          'div',
+          { className: 'dpc-page dpc-bridgePage' },
+          h(
+            'div',
+            { className: 'dpc-bridgeBar' },
+            h(
+              'button',
+              { type: 'button', className: 'dpc-link dpc-bridgeBack', onClick: back },
+              h(Icon, { name: 'back' }),
+              h('span', null, t('bridgeBack')),
+            ),
+            h(
+              'span',
+              { className: 'dpc-bridgeTags' },
+              h('span', { className: 'dpc-bridgeTag' }, t('bridgeTag')),
+              h('span', { className: 'dpc-bridgeFrom' }, fill(t('bridgeFrom'), { p: candidate.sectionId })),
+            ),
+          ),
+          node
+            ? h('div', { className: 'dpc-bridgeBody' }, node)
+            : h(
+                'section',
+                { className: 'dpc-card dpc-empty' },
+                h('p', { className: 'dpc-emptyTitle' }, t('bridgeMissing')),
+              ),
+        ),
+      );
+    };
+  }
+
   /** The entry's own glyph, borrowed from the slot it registered. */
   function Glyph(props) {
     const [node, setNode] = React.useState(null);
@@ -2209,6 +2675,7 @@ function build(require) {
     // is the only place the guard, the cap and the fold switch are explained.
     const layoutOn = prefs.guard !== false;
     const foldingOn = prefs.collapse !== false;
+    const bridgeOn = prefs.bridge !== false;
     const capNow = typeof prefs.panelMax === 'number' ? prefs.panelMax : 45;
     const setLayout = (patch) => commit({ ...prefsNow(), ...patch });
     const layoutSwitch = (on, label, onClick) =>
@@ -2251,6 +2718,14 @@ function build(require) {
         t('layoutCollapseHint'),
         layoutSwitch(foldingOn, t('layoutCollapse'), () => setLayout({ collapse: !foldingOn })),
       ),
+      // The switch is the only way back for a reader who does not want the
+      // extra rows: turning it off also disposes the registrations, not just
+      // the display, so the host list and this page agree.
+      layoutRow(
+        t('layoutBridge'),
+        t('layoutBridgeHint'),
+        layoutSwitch(bridgeOn, t('layoutBridge'), () => setLayout({ bridge: !bridgeOn })),
+      ),
       layoutRow(
         t('layoutMax'),
         null,
@@ -2350,6 +2825,7 @@ function build(require) {
           state.inventory && state.inventory.repeated ? t('diagYes') : t('diagNo'),
           true,
         ),
+        diagRow(t('diagBridge'), String(bridgeState.entries.size), true),
         diagnostics && diagnostics.error ? h('dt', { key: 'et' }, 'error') : null,
         diagnostics && diagnostics.error
           ? h('dd', { key: 'ed', className: 'dpc-error' }, diagnostics.error)
@@ -2525,6 +3001,16 @@ function build(require) {
     .dpc-segmentBtn--on{background:var(--dsw-alias-settings-card-fill,rgba(127,127,127,.22));color:var(--dsw-alias-label-primary,#8a8a8a)}
     .dpc-segmentBtn:disabled{opacity:.4;cursor:default}
 
+    /* A bridged settings page: its own bar, then the host-rendered section. */
+    .dpc-bridgePage{gap:16px}
+    .dpc-bridgeBar{display:flex;align-items:center;justify-content:space-between;gap:16px;min-height:40px;padding-bottom:8px;border-bottom:.5px solid var(--dsw-alias-border-l2,rgba(127,127,127,.14))}
+    .dpc-bridgeBack{display:inline-flex;align-items:center;gap:6px;margin-left:-8px}
+    .dpc-bridgeBack .dpc-ico{width:14px;height:14px}
+    .dpc-bridgeTags{display:flex;align-items:center;gap:8px;min-width:0}
+    .dpc-bridgeTag{flex:none;padding:2px 8px;border:.5px solid var(--dsw-alias-border-l2,rgba(127,127,127,.24));border-radius:999px;font-size:11px;line-height:16px;color:var(--dsw-alias-label-secondary,rgba(127,127,127,.95))}
+    .dpc-bridgeFrom{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-family:var(--dsw-font-family-code,ui-monospace,monospace);font-size:11px;line-height:16px;color:var(--dsw-alias-label-tertiary,rgba(127,127,127,.8))}
+    .dpc-bridgeBody{min-width:0}
+
     @media (max-width:1000px){
       /* Below the column width the frame becomes the gutter instead of pushing
          content past the window edge. */
@@ -2534,6 +3020,7 @@ function build(require) {
       .dpc-row{flex-wrap:wrap;gap:8px}
       .dpc-rowText{flex:1 1 120px}
       .dpc-tags{order:8}
+      .dpc-bridgeFrom{display:none}
     }
     /* The settings column is narrower than the page column: drop what is only
        nice-to-have there instead of letting the row overflow. */
@@ -2672,10 +3159,24 @@ function build(require) {
       // A registration, a rename or a locale switch changes the list this plugin
       // lays out, so every one of them re-runs the pass.
       if (typeof ctx.slots.subscribe === 'function') {
-        ctx.effect(() => ctx.slots.subscribe(SLOT_PANELS, () => engineRef && engineRef.schedule()), `${PACKAGE}: panel entries`);
+        ctx.effect(
+          () =>
+            ctx.slots.subscribe(SLOT_PANELS, () => {
+              if (engineRef) engineRef.schedule();
+              scheduleBridgeSync();
+            }),
+          `${PACKAGE}: panel entries`,
+        );
       }
       if (locale && typeof locale.subscribe === 'function') {
-        ctx.effect(() => locale.subscribe(() => engineRef && engineRef.schedule()), `${PACKAGE}: labels`);
+        ctx.effect(
+          () =>
+            locale.subscribe(() => {
+              if (engineRef) engineRef.schedule();
+              scheduleBridgeSync();
+            }),
+          `${PACKAGE}: labels`,
+        );
       }
 
       ctx.slots.inject(SLOT_MAIN, () => {
@@ -2714,6 +3215,35 @@ function build(require) {
           return undefined;
         }
       });
+
+      // A bridged page follows three registries: the settings sections it
+      // mirrors, the panels it must not duplicate, and the locale that names
+      // both. Each declaration is its own readiness signal, so the sync runs
+      // once the slots exist and again on every later change.
+      const kickBridge = () => {
+        try {
+          watchSettings();
+          scheduleBridgeSync();
+          scheduleBridgeRetries();
+        } catch (error) {
+          console.warn(`[${PACKAGE}] bridge scheduling failed`, error);
+        }
+      };
+      try {
+        // Re-install the watch on every declaration: before the slot exists
+        // `subscribe` cannot observe the section registry, and a stale
+        // subscription would miss the pages that register after us.
+        ctx.slots.inject(SLOT_SETTINGS, () => {
+          unwatchSettings();
+          watchSettings();
+          kickBridge();
+        });
+        ctx.slots.inject(SLOT_PANELS, kickBridge);
+      } catch (error) {
+        console.warn(`[${PACKAGE}] bridge slots unavailable`, error);
+      }
+      ctx.effect(() => () => disposeBridges(), `${PACKAGE}: bridge cleanup`);
+      kickBridge();
     try { window.__dpcApplied = true; } catch { /* ignore */ }
   }
 
@@ -2736,7 +3266,9 @@ function build(require) {
   }
 
   return {
-    inject: ['slots'],
+    // `layout` is only read (never patched): the bridge's back button and its
+    // selection fallback call the public selectPanel action.
+    inject: ['slots', 'layout'],
     // Pure helpers the browser harness drives directly, without a Cordis context.
     testables: { createEngine, mapButtons, readEntries, normalize, sanitize, store, reorderList, applyInner, setCtx: (value) => { ctxRef = value; } },
     apply(ctx) {

package/docs/bridged-settings-pages.md

@@ -0,0 +1,85 @@
+# 设置页补入口：怎么识别，怎么渲染
+
+## 问题
+
+宿主把「侧栏面板」和「设置页」做成两套注册：
+
+- 面板入口 = `sidebar.panellist` 里的一行图标 + 同 id 的 root 作用域 `main` keyed 条目；
+- 设置页 = `settings.section` 里的一个 id。
+
+多数插件两者都注册。少数只注册 `settings.section`，于是它的页面只能从设置弹窗里翻到——
+侧栏没有入口，也没法被单独选中。设置弹窗的打开状态是宿主私有的，没有公开 API 能直接定位到
+某个 section，所以「点一行就打开那个设置页」只能由本插件自己造一页。
+
+## 识别
+
+宿主的槽条目确实带有 `registrant`，但在当前客户端里它**不能用来区分插件**：client runner 把
+大量插件放在同一个 fiber 里 apply，实测 `account/general/models/plugins/agent-presets` 以及
+`plan-mode`、`bili`、`workspace-control-settings`、`composer-rewind-settings` 这些设置页的
+`registrant` 都是同一个 `tk`，侧栏里大多数行也是 `tk`；只有插件市场是它自己的 `dsh-market`。
+按 registrant 过滤会把所有第三方设置页都当成「已有入口」。
+
+因此改为按**侧栏归属**判断，一个设置页有入口当且仅当满足任一条：
+
+1. 它的 id 等于某个 `sidebar.panellist` 的 id；
+2. 去掉末尾 `-settings` 后的 id 等于某个面板 id（`panel-control-settings` ↔ `panel-control`）；
+3. 某个面板 id 以 `-<id>` 结尾（`market` ↔ `dsh-market`）；
+4. 它的 label 与某个面板 label 相同（`market` / `workspace-control-settings` 都命中）。
+
+内置设置页没有面板，因此单独列一组 id 排除：`account`、`general`、`models`、`agent-presets`、
+`plugins`（`plugins` 同时也有面板，列在这里只是双保险）。剩下的每个 section 补一行，id 为
+`dpc-bridge-<section id>`，order 85（在普通入口之后、本插件之前）。标题取该 section 的 label；
+与已有行撞名时追加 ` · <section id>`。
+
+这套判断不读第三方包内部文件，也不依赖插件白名单；代价是**启发式**：一个第三方设置页若恰好
+与某个面板同名/id 同源，会被当成已有入口；未来新增的内置设置页若不在上面的 id 列表里，会被
+多补一行（此时把它加进 `CORE_SECTION_IDS` 即可）。
+
+## 渲染
+
+桥接面板自己注册同 id 的 `main` keyed 条目，并在该条目上声明一个自有子槽（`dpc-bridge-slot-<section id>`）。
+之所以不直接用 `ctx.slots.renderSlot('settings.section', ...)`：ctx 级 `renderSlot` 只渲染 `root`，
+子槽只能通过「声明了它的那个条目的 props 面」渲染；`settings.section` 由设置壳声明，本插件无权调用。
+因此桥接条目把原 section 的组件以同一份 `inject/store/locale` 重新注册进自有子槽，再通过宿主注入的
+`props.renderSlot(slotName, { close: back }, {})` 渲染它。
+
+这样 section 的 `inject`、`store`、locale `t`、`useStore` 和 error boundary 仍由宿主照常提供；直接调用
+section 组件会缺这些。面板只负责外壳：顶部一条 40px 的栏（「返回对话」+ 来源 section id），
+下面一块随页面滚动的主体。`close` 与设置壳里一样只做「关掉这一页」，这里落回对话
+（`layout.selectPanel(null)`）。
+
+桥接面板不常驻：开关关闭、section 消失、插件卸载时，`dispose()` 成对撤掉 `main` 与
+`sidebar.panellist` 注册；若当时正停在这一页，先 `selectPanel(null)` 回到对话，避免选中一个
+已经不存在的 key。
+
+## 同步
+
+`settings.section`、`sidebar.panellist` 与 locale 任意一处变化都会触发一次同步，120ms 去抖。
+启动时还会按 `[350, 900, 2000, 4200, 8000, 15000]ms` 主动重扫：boot 清单的顺序不是应用顺序，
+排在后面的插件可能在第一次同步之后才注册设置页。`settings.section` 槽声明时会重新建立订阅，
+因为槽声明之前 `subscribe` 观察不到这个注册表。
+
+同步本身只做增删对账，不重建未变化的行；注册成对失败时回滚已注册的那一半。
+
+开关存在 `prefs.bridge`（默认 `true`），在「侧栏布局」卡片里；它和排序、隐藏、分组是正交的：
+补出来的行可以像普通行一样拖动、隐藏、分组，关掉开关才会整体消失。
+
+## 验证
+
+- `npm run check`：`layout-smoke` 断言桥接的常量、持久化字段与自有子槽渲染没有被改掉；
+  `bridge-smoke` 在假 `ctx` 上验证识别、成对注册、开关撤回与返回对话。
+- 刷新插件后看 `~/.dsh/panel-control/host.log`：`bridge-scan` 行记录每次扫描看到的 section 与
+  侧栏条目（`id:registrant`），`kind=bridge` 行记录最终补出的 id。目标 section 在 `sections`
+  里却没进 `ids`，说明它被归属规则当成了已有入口（或 id 不在内置列表里而被排除）；一直不在
+  `sections` 里，是注册时序问题。
+- `bridge-smoke` 里另有一条晚注册用例：先启动、后注册 section，订阅必须把新行补出来。
+- 界面：侧栏应多出对应行；点开后是完整设置页，顶部「返回对话」可退回；设置 → 面板管理里
+  「侧栏布局」应出现开关。
+
+## 边界
+
+- 第三方设置页在设置壳外渲染时，若它依赖弹窗的私有上下文（宽度、滚动容器、`close` 之外的 props），
+  可能和设置弹窗里不完全一致；本插件只保证宿主注入的公开部分齐全。
+- 补出来的行参与自动分类，会被分进 2–4 个组之一；想固定位置就手动拖动或分组。
+- 识别是启发式：设置页 id / label 与面板重合时视为已有入口；新增内置设置页需要加进
+  `CORE_SECTION_IDS`。同一个包注册多个设置页会补多行，这是有意的。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-panel-control",
-  "version": "0.7.2",
+  "version": "0.8.3",
   "type": "module",
   "description": "Manage the global panel navigation at the top of the DSH sidebar: reorder, hide and group every entry, with the layout persisted per installation.",
   "keywords": [
@@ -50,7 +50,7 @@
     "url": "https://github.com/QIUZAIYOU/dsh-panel-control/issues"
   },
   "scripts": {
-    "check": "node --check index.js && node --check client.js && node scripts/host-smoke.mjs && node scripts/layout-smoke.mjs",
+    "check": "node --check index.js && node --check client.js && node scripts/host-smoke.mjs && node scripts/layout-smoke.mjs && node scripts/bridge-smoke.mjs",
     "smoke": "node scripts/host-smoke.mjs",
     "doctor": "node scripts/profile-doctor.mjs",
     "enable": "node scripts/enable-local.mjs"

package/scripts/bridge-smoke.mjs

@@ -0,0 +1,324 @@
+// Scratch harness: does the bridge discover settings-only plugins, register the
+// panellist+main pair, avoid plugins that already have a row, and honour the switch?
+import { readFileSync } from 'node:fs';
+import vm from 'node:vm';
+
+const SRC = readFileSync(new URL('../client.js', import.meta.url), 'utf8');
+
+const stubReact = {
+  createElement: (type, props, ...children) => ({ type, props: { ...(props || {}), children } }),
+  useState: (value) => [value, () => {}],
+  useEffect: () => {},
+  useRef: (value) => ({ current: value }),
+  useMemo: (fn) => fn(),
+  useCallback: (fn) => fn,
+};
+
+const element = () => ({
+  style: {},
+  dataset: {},
+  classList: { add() {}, remove() {}, toggle() {} },
+  setAttribute() {},
+  removeAttribute() {},
+  appendChild() {},
+  remove() {},
+  addEventListener() {},
+  removeEventListener() {},
+  contains() {
+    return false;
+  },
+  querySelector() {
+    return null;
+  },
+  querySelectorAll() {
+    return [];
+  },
+  textContent: '',
+  children: [],
+  childNodes: [],
+});
+
+const document = {
+  readyState: 'loading',
+  head: element(),
+  body: element(),
+  documentElement: element(),
+  title: '',
+  visibilityState: 'visible',
+  createElement: () => element(),
+  createTextNode: () => ({ textContent: '' }),
+  createDocumentFragment: () => element(),
+  querySelector: () => null,
+  querySelectorAll: () => [],
+  getElementById: () => null,
+  addEventListener() {},
+  removeEventListener() {},
+};
+
+function makeWindow(localPrefs) {
+  const memory = new Map();
+  if (localPrefs !== undefined) memory.set('dsh.panel-control.v1', JSON.stringify(localPrefs));
+  const localStorage = {
+    getItem: (key) => (memory.has(key) ? memory.get(key) : null),
+    setItem: (key, value) => memory.set(key, String(value)),
+    removeItem: (key) => memory.delete(key),
+    key: () => null,
+    length: 0,
+  };
+  return {
+    document,
+    localStorage,
+    navigator: { language: 'zh-CN' },
+    location: { reload() {} },
+    CSS: { escape: (value) => String(value) },
+    addEventListener() {},
+    removeEventListener() {},
+    __DSH_BOOT__: {
+      rev: 'test-rev',
+      entries: [],
+      ids: [
+        'plugins',
+        'dsh-market',
+        'panel-control',
+        'dsh-flash-presets',
+        'billion-context',
+        'dshmarket',
+        '@deepseek-ai/dsh-client-ui-settings-general',
+      ],
+    },
+    __ModuleLoader__: { def: null, load(def) { this.def = def; } },
+  };
+}
+
+function section(options, registrant) {
+  return { options, component: () => null, registrant };
+}
+function panelEntry(options, registrant) {
+  return { options, component: () => null, registrant };
+}
+
+function install(ctx, slots) {
+  globalThis.window = ctx;
+  globalThis.document = document;
+  globalThis.localStorage = ctx.localStorage;
+  window.__ModuleLoader__.def = null;
+  vm.runInThisContext(SRC, { filename: 'client.js' });
+  return window.__ModuleLoader__.def.factory((name) => {
+    if (name === 'react') return stubReact;
+    throw new Error('unexpected require: ' + name);
+  });
+}
+
+const calls = { selectPanel: [], renders: [] };
+const layout = {
+  panelInfo: { getSnapshot: () => ({ activePanelId: null }) },
+  selectPanel(id) {
+    calls.selectPanel.push(id);
+  },
+};
+const locale = {
+  getLocale: () => ({ active: 'zh-CN' }),
+  register: () => {},
+  subscribe: () => () => {},
+};
+
+function makeCtx(seedSections = true) {
+  const registries = new Map();
+  const list = (name) => {
+    if (!registries.has(name)) registries.set(name, []);
+    return registries.get(name);
+  };
+  const subscribers = new Map();
+  const notify = (name) => {
+    for (const callback of subscribers.get(name) || []) Promise.resolve().then(callback);
+  };
+  const slotService = {
+    register(options, component) {
+      const record = { options, component, registrant: options.registrant || 'dsh-panel-control' };
+      list(options.name).push(record);
+      notify(options.name);
+      return () => {
+        const all = list(options.name);
+        const at = all.indexOf(record);
+        if (at >= 0) all.splice(at, 1);
+        notify(options.name);
+      };
+    },
+    entriesOfSlot(name) {
+      return list(name).slice();
+    },
+    inject(name, callback) {
+      return callback();
+    },
+    subscribe(name, callback) {
+      if (!subscribers.has(name)) subscribers.set(name, []);
+      subscribers.get(name).push(callback);
+      return () => {};
+    },
+    renderSlot(name, props, opts) {
+      calls.renders.push({ name, props, opts });
+      return stubReact.createElement('div', { 'data-slot': name, 'data-only': opts && opts.only });
+    },
+  };
+  list('sidebar.panellist').push(
+    panelEntry({ name: 'sidebar.panellist', id: 'plugins', order: 0, label: '插件' }, 'tk'),
+  );
+  list('sidebar.panellist').push(
+    panelEntry({ name: 'sidebar.panellist', id: 'dsh-market', order: 1, label: '插件市场' }, 'dsh-market'),
+  );
+  list('sidebar.panellist').push(
+    panelEntry({ name: 'sidebar.panellist', id: 'workspace-control', order: 20, label: '工作区管理' }, 'tk'),
+  );
+  list('settings.section').push(
+    section({ name: 'settings.section', id: 'general', order: 0, label: '通用' }, 'tk'),
+  );
+  list('settings.section').push(
+    section({ name: 'settings.section', id: 'market', order: 40, label: '插件市场' }, 'dsh-market'),
+  );
+  if (seedSections) {
+    list('settings.section').push(
+      section({ name: 'settings.section', id: 'plan-mode', order: 5, label: '计划模式' }, 'tk'),
+    );
+    list('settings.section').push(
+      section({ name: 'settings.section', id: 'bili', order: 100, label: () => '上下文' }, 'tk'),
+    );
+    list('settings.section').push(
+      section({ name: 'settings.section', id: 'workspace-control-settings', order: 30, label: '工作区管理' }, 'tk'),
+    );
+    list('settings.section').push(
+      section({ name: 'settings.section', id: 'composer-rewind-settings', order: 50, label: '输入历史' }, 'tk'),
+    );
+    for (const [id, label] of [
+      ['account', '账户'],
+      ['models', '模型'],
+      ['agent-presets', '智能体预设'],
+    ]) {
+      list('settings.section').push(section({ name: 'settings.section', id, order: 1, label }, 'tk'));
+    }
+  }
+  return {
+    registries,
+    subscribers,
+    ctx: {
+      fiber: { name: 'dsh-panel-control' },
+      get(name) {
+        if (name === 'layout') return layout;
+        if (name === 'locale') return locale;
+        return undefined;
+      },
+      effect(fn) {
+        return fn();
+      },
+      slots: slotService,
+    },
+  };
+}
+
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function run(localPrefs) {
+  const app = makeCtx();
+  const mod = install(makeWindow(localPrefs), app.registries);
+  mod.apply(app.ctx);
+  await sleep(260);
+  const rows = app.registries.get('sidebar.panellist') || [];
+  const mains = app.registries.get('main') || [];
+  const labelOf = (options) => (typeof options.label === 'function' ? options.label() : options.label);
+  return {
+    ids: rows.map((row) => row.options.id),
+    labels: rows.map((row) => labelOf(row.options)),
+    mains: mains.map((row) => row.options.key),
+    mainRows: mains,
+    rows,
+    registries: app.registries,
+  };
+}
+
+const failures = [];
+const check = (ok, message) => {
+  if (!ok) failures.push(message);
+};
+
+// Boot order is not registration order: a plugin that applies after us adds its
+// settings section later. The subscription installed when the slot is declared
+// must pick that up without a reload.
+async function runLate() {
+  const app = makeCtx(false);
+  const mod = install(makeWindow(undefined), app.registries);
+  mod.apply(app.ctx);
+  await sleep(300);
+  const before = (app.registries.get('sidebar.panellist') || []).map((row) => row.options.id);
+  app.ctx.slots.register(
+    { name: 'settings.section', id: 'plan-mode', order: 5, label: '计划模式', registrant: 'tk' },
+    () => null,
+  );
+  app.ctx.slots.register(
+    { name: 'settings.section', id: 'bili', order: 100, label: () => '上下文', registrant: 'tk' },
+    () => null,
+  );
+  await sleep(420);
+  const after = (app.registries.get('sidebar.panellist') || []).map((row) => row.options.id);
+  return { before, after };
+}
+
+const late = await runLate();
+check(!late.before.some((id) => id.startsWith('dpc-bridge-')), 'bridged a section before it was registered');
+check(
+  late.after.includes('dpc-bridge-plan-mode') && late.after.includes('dpc-bridge-bili'),
+  'late-registered settings sections were not bridged',
+);
+
+const on = await run(undefined);
+check(on.ids.includes('dpc-bridge-plan-mode'), 'missing bridge row for dsh-flash-presets');
+check(on.ids.includes('dpc-bridge-bili'), 'missing bridge row for billion-context');
+check(on.ids.includes('dpc-bridge-composer-rewind-settings'), 'missing bridge row for dsh-composer-rewind');
+check(!on.ids.includes('dpc-bridge-market'), 'bridged dshmarket even though it has a panel');
+check(!on.ids.includes('dpc-bridge-general'), 'bridged a core settings section');
+check(!on.ids.includes('dpc-bridge-account'), 'bridged a core settings section');
+check(!on.ids.includes('dpc-bridge-models'), 'bridged a core settings section');
+check(!on.ids.includes('dpc-bridge-agent-presets'), 'bridged a core settings section');
+check(!on.ids.includes('dpc-bridge-workspace-control-settings'), 'bridged a plugin whose panel id is the section base');
+check(on.mains.includes('dpc-bridge-plan-mode') && on.mains.includes('dpc-bridge-bili'), 'a bridge row has no main entry');
+const planRow = on.rows.find((row) => row.options.id === 'dpc-bridge-plan-mode');
+check(planRow && planRow.options.order === 85, 'bridge rows lost their order');
+check(planRow && planRow.options.label() === '计划模式', 'bridge label is not the section label');
+
+const tree = on.rows.find((row) => row.options.id === 'dpc-bridge-bili').component({ size: 18, active: false });
+check(tree && tree.type === 'svg', 'bridge icon is not an svg');
+
+const off = await run({ version: 2, bridge: false, order: ['plugins', 'dsh-market', 'panel-control'] });
+check(!off.ids.some((id) => id.startsWith('dpc-bridge-')), 'the switch did not remove the bridge rows');
+
+// The settings shell owns `settings.section`, so the ctx-level renderSlot cannot
+// reach it. The bridge declares its own child slot, registers the section
+// component into it, and renders it through the props face the host binds.
+const biliMain = on.mainRows.find((row) => row.options.key === 'dpc-bridge-bili');
+check(Boolean(biliMain), 'no main key for the bridged row');
+const slotName = 'dpc-bridge-slot-bili';
+const declared = biliMain && biliMain.options.children;
+check(Boolean(declared && declared[slotName]), 'the bridge main entry declared no child slot');
+check(declared && declared[slotName] && declared[slotName].kind === 'single', 'the bridge child slot is not single');
+const face = (name, props, opts) => {
+  if (!declared || !declared[name]) throw new Error('slot ' + name + ' is not declared by this entry children');
+  calls.renders.push({ name, props, opts });
+  return stubReact.createElement('div', { 'data-slot': name });
+};
+const view = biliMain ? biliMain.component({ renderSlot: face }) : null;
+const slot = calls.renders.find((render) => render.name === slotName);
+check(Boolean(slot), 'the bridge page did not render its child slot');
+check(slot && typeof slot.props.close === 'function', 'the bridge page gave the section no close');
+check(Boolean(view) && view.type === 'div', 'the bridge page did not render its frame');
+const childEntries = on.registries.get(slotName) || [];
+check(childEntries.length === 1, 'the section component was not re-registered into the bridge slot');
+check(childEntries[0] && typeof childEntries[0].component === 'function', 'the bridge slot has no component');
+if (slot) slot.props.close();
+check(calls.selectPanel.includes(null), 'closing the bridge page did not select the Conversation');
+
+console.log(JSON.stringify({ on: on.ids, onLabels: on.labels, mains: on.mains, off: off.ids, renders: calls.renders.length }, null, 2));
+if (failures.length) {
+  console.error('bridge-smoke: ' + failures.length + ' problem(s)');
+  for (const failure of failures) console.error(' - ' + failure);
+  process.exit(1);
+}
+console.log('bridge-smoke: ok');
+process.exit(0);

package/scripts/layout-smoke.mjs

@@ -27,12 +27,28 @@ for (const marker of [
   'layoutGuard',
   'layoutMaxNone',
   'toggleCollapse',
+  'layoutBridge',
+  'dpc-bridgeBar',
+  'registrantOf',
 ]) {
   expect(client.includes(marker), 'client.js lost ' + marker);
 }
 
+// A bridged row is only as good as the two halves it registers: a keyed main
+// entry the layout can select, and the host-rendered settings section it shows.
+expect(client.includes('BRIDGE_ORDER = 85'), 'bridged rows lost their order slot');
+expect(client.includes('out.bridge = raw.bridge !== false'), 'the bridge switch is not persisted');
+expect(
+  client.includes('BRIDGE_SLOT_PREFIX') &&
+    client.includes('children: { [slotName]: { kind: \'single\', scope: \'root\' } }') &&
+    client.includes('renderSlot(slotName, { close: back }, {})'),
+  'the bridged page no longer renders through its own child slot',
+);
+expect(/\.dpc-bridgeBar\{[^}]*min-height:40px/.test(client), 'the bridge bar lost its 40px row height');
+
 expect(client.includes("const BUILD_STAMP = 'dsh-panel-control/" + pkg.version + "'"), 'BUILD_STAMP and package.json version disagree');
 expect(pkg.scripts && String(pkg.scripts.check).includes('layout-smoke'), 'npm run check no longer runs this gate');
+expect(pkg.scripts && String(pkg.scripts.check).includes('bridge-smoke'), 'npm run check no longer runs the bridge gate');
 expect(/\[data-dpc-list\]\{[^}]*overflow-y:auto/.test(client), 'the panel list is not scrollable');
 expect(/\[data-dpc-list\]\{[^}]*max-height:max\(120px,var\(--dpc-panellist-max,45vh\)\)/.test(client), 'the panel list lost its height cap');
 expect(/\[data-dpc-region\]\{[^}]*min-height/.test(client), 'the region below the list lost its floor');