dsh-sidenote 0.3.2 → 0.3.4

package/lib/types/client/host/contracts.d.ts

@@ -216,6 +216,51 @@ export interface ModelSelection {
     model: string;
     reasoningEffort?: string;
 }
+/**
+ * Remote session face（dsh >= 0.1.5 的模型读写照面；0.1.5 删除了
+ * `connection.api.sessions.*` 的 client 面后由它接管）。
+ * `remote`/`remote.session` 在宿主侧是可注入服务，但本插件不声明 inject
+ * （0.1.2 及更早无此服务，声明会让插件在旧宿主上永不激活）——调用点经
+ * `ctx.get` 惰性探测（cordis 的 get 不受 inject 门禁限制）。
+ * Authority：`@deepseek-ai/dsh-api-session-controller/lib/typert.remote-client.d.ts`
+ * （RemoteResult = `{ok: true, value} | {ok: false, error}`；error 实为
+ * RemoteError 实例，code 必有、message 继承 Error，这里弱化为可读取切片）。
+ */
+export interface RemoteSessionModelFace {
+    selectModel(request: {
+        sessionId: SessionId;
+        provider: string;
+        model: string;
+        reasoningEffort?: string;
+    }): Promise<{
+        ok: true;
+        value: unknown;
+    } | {
+        ok: false;
+        error: {
+            code?: string;
+            message?: string;
+        };
+    }>;
+    /** 宿主级模型目录（authority 同上，`ModelCatalog`）。 */
+    modelCatalog?(): Promise<{
+        ok: true;
+        value: ModelCatalogFace;
+    } | {
+        ok: false;
+        error: {
+            code?: string;
+            message?: string;
+        };
+    }>;
+}
+/** `remote.session.modelCatalog()` 的返回切片（authority: 同上 `ModelCatalog`）。 */
+export interface ModelCatalogFace {
+    readonly default: ModelSelection;
+    readonly routableProviders: readonly string[];
+    readonly groups: SessionModelsResult['groups'];
+    readonly failures?: readonly unknown[];
+}
 export interface SessionModelsResult {
     current: ModelSelection;
     routable: boolean;

package/lib/types/client/sidechat/lifecycle.d.ts

@@ -6,7 +6,7 @@
  * off-face 探测纪律：session.open()、store.update 均为运行时可达但契约不
  * 保证的面——就地 feature-check + 吞错降级，并登记进 host/probes.ts。
  */
-import type { Context, ConversationSnapshot, SessionBinding, SessionFace, SessionModelsResult } from '../host/contracts.ts';
+import type { Context, ConversationSnapshot, ModelSelection, RemoteSessionModelFace, SessionBinding, SessionFace, SessionModelsResult } from '../host/contracts.ts';
 import { type SideChatMeta } from './model.ts';
 /**
  * 首开编排：fork（全量历史快照）→ 登记 meta（先行，绝不丢登记）→
@@ -30,6 +30,36 @@ export declare function ensurePanelOpen(store: unknown): void;
  * 运行时自动 open）。feature-check + 吞错，运行时若移除则降级为只发不收。
  */
 export declare function openSessionWindow(session: SessionFace | undefined): void;
+/**
+ * Current model selection of a session, read from its `modelSelection`
+ * projection (dsh >= 0.1.2): the durable selection is projected state, so no RPC
+ * is needed and the read is safe for any session id. Snapshot shape authority:
+ * `@deepseek-ai/dsh-api-session-controller/lib/types/types.d.ts`
+ * (`ModelSelectionProjection = { lastUsed, next }`，两者均可为 null——
+ * `next` 缺省时按投影文档回落 `lastUsed`）。
+ */
+export declare function projectedModelSelection(ctx: Context, sessionId: string): ModelSelection | undefined;
+/**
+ * Remote session face carrying `selectModel`/`modelCatalog`（dsh 0.1.5 删除
+ * `connection.api.sessions.*` client 面后的模型 RPC 面；事实上 0.1.2-rc.1
+ * 起存在——authority: dsh-api-session-controller lib/typert.remote-client.d.ts）。
+ * 探测走 `ctx.get`（cordis 的 get 不受 inject 门禁限制，本插件为兼容旧宿主
+ * 不声明 inject 'remote.session'；机制见 contracts.ts RemoteSessionModelFace）。
+ * `ctx.get('remote')` 返回命名空间容器时下钻其 `.session` 成员。
+ */
+export declare function remoteSessionFace(ctx: Context): RemoteSessionModelFace | undefined;
+/**
+ * 读会话当前模型选择：投影面（0.1.2+，同步无 RPC）优先；旧
+ * `connection.api.sessions.models` RPC（<= 0.1.2 的 client 面，0.1.5 已删）
+ * 回退（双版本链，同 chatSourceOf 先例）。永不抛错。
+ */
+export declare function readModelSelection(ctx: Context, sessionId: string): Promise<ModelSelection | undefined>;
+/**
+ * 写会话模型选择：`remote.session.selectModel`（新面）优先，旧
+ * `connection.api.sessions.selectModel` 回退。面在而调用失败（模型不可路由等）
+ * 属真实失败，不再落旧面重试。
+ */
+export declare function writeModelSelection(ctx: Context, sessionId: string, selection: ModelSelection): Promise<boolean>;
 /** 读子会话当前模型名（composer 模型标签用）；任何失败回退 null（默认文案）。 */
 export declare function readModelName(ctx: Context, sessionId: string): Promise<string | null>;
 /** 会话内容读取源（0.1.1/0.1.2 双兼容，feature-check 优先链）。 */
@@ -46,7 +76,11 @@ export interface ChatSource {
  * 既有降级，不崩）。
  */
 export declare function chatSourceOf(ctx: Context, binding: SessionBinding | undefined): ChatSource | undefined;
-/** 拉会话模型目录（models RPC 容错；失败 null → 菜单保持只读标签态）。 */
+/**
+ * 拉会话模型目录：0.1.5 走 `remote.session.modelCatalog()`（目录是宿主级，
+ * 菜单选中项所需的 current 由投影/旧面补上）；旧面回退
+ * `connection.api.sessions.models`。失败 null → 菜单保持只读标签态。
+ */
 export declare function listModels(ctx: Context, sessionId: string): Promise<SessionModelsResult | null>;
 /** 切换子会话模型；成功返回新模型展示名，失败 null（best-effort）。 */
 export declare function switchModel(ctx: Context, sessionId: string, provider: string, model: string): Promise<string | null>;

package/lib/types/client/sidechat/native.d.ts

@@ -0,0 +1,87 @@
+/**
+ * better-sidebar >= 0.19 / DSH 0.1.5 bridge.
+ *
+ * From 0.19 on, better-sidebar no longer owns the right column: it hands it to
+ * DSH's native right sidebar (`dsh-client-ui-sidebar-right`) and routes tab
+ * lifecycle calls to that surface (`openTab`/`activateTab`/`updateTab`).
+ * Sidechat tabs opened that way never enter the legacy layout store
+ * (splits/bottomSplits/floats) that `collectSideTabs` walks, so the minted tab
+ * id cannot be recovered from the snapshot — after `openTab` there is no
+ * `updateTab` target until the panel mounts and publishes itself. Drafts must
+ * therefore ride the `openTab` seed.meta (which the native surface honors) or
+ * wait for the panel's registration.
+ *
+ * This module keeps that missing link: a registry of live side-chat panels
+ * (their native tab id, their draft sink, their current meta) plus a lazy
+ * root-context holder. The root context is the plugin's own fiber — unlike the
+ * slot-provided context a panel receives, its inject list contains
+ * `workspaces`, so host calls made from it keep working on 0.1.5.
+ *
+ * Authority: dsh-better-sidebar `src/client/service.ts` (>= 0.19 surface
+ * routing) and `@deepseek-ai/dsh-api-session-controller` (remote session face).
+ */
+import type { Context } from '../host/contracts.ts';
+/** Remember the plugin root context at activation (see module docstring). */
+export declare function setRootContext(ctx: Context): void;
+/** Plugin root context; falls back to the caller's context (legacy behaviour). */
+export declare function rootContext(fallback: Context): Context;
+/**
+ * True when the host keeps sidebar tabs outside the legacy layout store
+ * (better-sidebar >= 0.19). Version parse is best-effort: an unparsable
+ * version reports false, which keeps the pre-0.19 behaviour.
+ */
+export declare function nativeSidebarHost(ctx: Context): boolean;
+interface LiveSideChat {
+    readonly tabId: string;
+    readonly sessionId: string;
+    /** Write text into the panel composer (draft delivery). */
+    seedDraft(text: string): void;
+    /** Current tab meta, read at call time (the panel re-renders on meta change). */
+    readMeta(): unknown;
+    /** Current tab title（聚焦列表/编号数据源的读取面）。 */
+    readTitle(): string;
+}
+/**
+ * Publish a mounted panel so programmatic entry points can focus it and seed
+ * its draft. Returns the disposer for the panel's effect cleanup.
+ */
+export declare function registerLiveSideChat(sessionId: string, tabId: string, seedDraft: (text: string) => void, readMeta: () => unknown, readTitle: () => string): () => void;
+interface OpeningMark {
+    readonly at: number;
+    /** 窗口内到达的待投递草稿（面板注册时经 seedDraft 回放）。 */
+    readonly drafts: string[];
+}
+/** 标记一次已发起、面板尚未注册的 native 打开（create/reopen 铸造后调用）。 */
+export declare function markSideChatOpening(sessionId: string): void;
+/** 进行中的打开；TTL 外视为 openTab 被拒/面板未挂载，清除并返回 undefined。 */
+export declare function sideChatOpening(sessionId: string): OpeningMark | undefined;
+/** Live panel for a native tab id (undefined for legacy layout tabs). */
+export declare function liveSideChat(tabId: string): LiveSideChat | undefined;
+/** 一个会话的全部存活面板（按打开序升序；native 下枚举 side tab 的唯一数据源）。 */
+export declare function liveSideChatsOf(sessionId: string): LiveSideChat[];
+/**
+ * Most recently OPENED live panel of a session — the open-or-focus target
+ * when the legacy snapshot cannot see the tab (mirrors "last opened wins").
+ * 排序锚在首次注册序号上：面板重挂载不翻序（见 birthOrder）。
+ */
+export declare function lastLiveSideChat(sessionId: string): LiveSideChat | undefined;
+/** 插件卸载/重载时清场（apply 的 ctx.effect disposer 调用）。 */
+export declare function clearNativeRuntime(): void;
+/** Native tab shell for reads that go through the layout snapshot (`readTab`). */
+export declare function nativeTabShell(tabId: string, type: string): {
+    id: string;
+    type: string;
+    title: string;
+    meta: unknown;
+} | undefined;
+/**
+ * 聚焦一个 native tab：better-sidebar >= 0.19 的 `surface.activate` 是空操作
+ * （只返回记录存在性——authority: dsh-better-sidebar src/client/native/surface.ts），
+ * 真实聚焦面是 dsh 0.1.5 的 `ISidebarRight.focus`（authority:
+ * dsh-client-ui-sidebar-right lib/types/client/service.d.ts `focus(tabId)`）。
+ * focus 只标记活动 tab/pane，不展开折叠的栏——聚焦的语义包含「让用户看见」，
+ * 故折叠时补 toggleExpanded（authority: 同文件 `isExpanded/toggleExpanded`）。
+ * @returns true = 已通过 focus 聚焦；false = 面缺席（调用方回退 activateTab）。
+ */
+export declare function focusNativeTab(ctx: Context, tabId: string): boolean;
+export {};

package/lib/types/client/sidechat/open.d.ts

@@ -7,7 +7,11 @@
  * 否则写 meta.pendingDraft 移交面板（面板在 composer 就绪后应用并清除）。
  */
 import type { Context, SidebarTab } from '../host/contracts.ts';
-/** 从最新快照读一个 Tab（meta 合并写入前的读取面；布局即注册表）。 */
+/**
+ * 从最新快照读一个 Tab（meta 合并写入前的读取面；布局即注册表）。
+ * better-sidebar >= 0.19: the open tab lives in the native right sidebar, not
+ * in the layout snapshot — fall back to the live-panel registry.
+ */
 export declare function readTab(ctx: Context, tabId: string): SidebarTab | undefined;
 /**
  * 为 sessionId 新建或聚焦一个侧边聊天 Tab；draftText 给出时写入其草稿。

package/lib/types/client/sidechat/slash.d.ts

@@ -2,7 +2,9 @@
  * /side 斜杠命令（spike 落点）：经 client 侧 `ctx.commandUi.register`
  * （dsh-client-ui-commands 的 CommandContribution，ui 形态 popupSelect）
  * 注册。popupSelect 是该注册面唯一的 UI 形态 —— 菜单行被选中后弹一个
- * 选项壳，选项 = 新建 + 当前会话已并存的侧边聊天（聚焦）。
+ * 选项壳，选项 = 新建 + 当前会话已并存的侧边聊天（聚焦）+ 最近关闭（重开）。
+ * native 宿主（better-sidebar >= 0.19）受 dsh sidebar-right 的 held 规则约束
+ * （page kind 每 pane 单实例）：有存活实例时不列「新建」与「重开」。
  *
  * 服务经 ctx.get 惰性解析（commandUi 不在 inject 清单里）：服务缺失、
  * 注册抛错（如与 host 命令撞名）都降级为「只有 Tab 入口」，绝不影响面板。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-sidenote",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "DSH web plugin: Codex-style side chat (fork the current session into a persistent side panel) + selection annotations with numbered badges and a composer chip. A thin consumer of dsh-better-sidebar. / Codex 风格侧边聊天 + 划选注释的 DSH 插件。",
   "type": "module",
   "license": "MIT",

package/src/client/host/contracts.ts

@@ -227,6 +227,35 @@ export interface ModelSelection {
   reasoningEffort?: string
 }
 
+/**
+ * Remote session face（dsh >= 0.1.5 的模型读写照面；0.1.5 删除了
+ * `connection.api.sessions.*` 的 client 面后由它接管）。
+ * `remote`/`remote.session` 在宿主侧是可注入服务，但本插件不声明 inject
+ * （0.1.2 及更早无此服务，声明会让插件在旧宿主上永不激活）——调用点经
+ * `ctx.get` 惰性探测（cordis 的 get 不受 inject 门禁限制）。
+ * Authority：`@deepseek-ai/dsh-api-session-controller/lib/typert.remote-client.d.ts`
+ * （RemoteResult = `{ok: true, value} | {ok: false, error}`；error 实为
+ * RemoteError 实例，code 必有、message 继承 Error，这里弱化为可读取切片）。
+ */
+export interface RemoteSessionModelFace {
+  selectModel(request: {
+    sessionId: SessionId
+    provider: string
+    model: string
+    reasoningEffort?: string
+  }): Promise<{ ok: true; value: unknown } | { ok: false; error: { code?: string; message?: string } }>
+  /** 宿主级模型目录（authority 同上，`ModelCatalog`）。 */
+  modelCatalog?(): Promise<{ ok: true; value: ModelCatalogFace } | { ok: false; error: { code?: string; message?: string } }>
+}
+
+/** `remote.session.modelCatalog()` 的返回切片（authority: 同上 `ModelCatalog`）。 */
+export interface ModelCatalogFace {
+  readonly default: ModelSelection
+  readonly routableProviders: readonly string[]
+  readonly groups: SessionModelsResult['groups']
+  readonly failures?: readonly unknown[]
+}
+
 export interface SessionModelsResult {
   current: ModelSelection
   routable: boolean

package/src/client/host/probes.ts

@@ -9,6 +9,8 @@
  * 新增 off-face 依赖时：调用点照写就地探测，同时把条目加进 PROBES。
  */
 import type { Context } from './contracts.ts'
+import { nativeSidebarHost } from '../sidechat/native.ts'
+import { remoteSessionFace } from '../sidechat/lifecycle.ts'
 
 interface Probe {
   /** 探测项名称（告警文案用）。 */
@@ -57,6 +59,31 @@ const PROBES: readonly Probe[] = [
     },
     fallback: 'ProducedFiles 等动态复用件降级为自绘',
   },
+  {
+    name: 'sidebarRight.focus（native tab 程序化聚焦）',
+    check: (ctx) => {
+      // 仅 better-sidebar >= 0.19（native 右栏）需要的面；老宿主的
+      // activateTab 本就可用，缺失不算降级。
+      if (!nativeSidebarHost(ctx)) return true
+      const face = (ctx as { get?: (k: string) => unknown }).get?.('sidebarRight') as
+        | { focus?: unknown }
+        | undefined
+      return typeof face?.focus === 'function'
+    },
+    fallback: '聚焦既有侧边聊天 tab 不可用（activateTab 在 native 面是空操作）',
+  },
+  {
+    name: '会话模型面（remote.session / connection.api.sessions 双版本链）',
+    check: (ctx) => {
+      // 新面（0.1.5 的 remote.session）与旧面（<= 0.1.2 的 connection.api）
+      // 任一在列即能力在——双版本链的探测与调用点同序（lifecycle.ts）。
+      if (remoteSessionFace(ctx) !== undefined) return true
+      const legacy = (ctx as { connection?: { api?: { sessions?: { models?: unknown } } } })
+        .connection?.api?.sessions?.models
+      return typeof legacy === 'function'
+    },
+    fallback: 'fork 模型同步、模型标签与模型切换不可用（子会话用宿主默认模型）',
+  },
 ]
 
 /** 激活时跑一遍探测清单；缺失项逐项 warn-once。返回缺失项数（测试可断言）。 */

package/src/client/index.tsx

@@ -13,10 +13,18 @@ import { attachLocale, type LocaleServiceLike } from './locales.ts'
 import { createReflowStore } from './reflow.ts'
 import { registerSideChat } from './sidechat/index.tsx'
 import { registerAnnotations } from './annotate/index.tsx'
+import { clearNativeRuntime, setRootContext } from './sidechat/native.ts'
 
 export const inject = ['betterSidebar', 'sessions', 'workspaces', 'slots', 'connection', 'locale']
 
 export function apply(ctx: Context): void {
+  // 侧栏 Tab 的原生面（better-sidebar >= 0.19）与宿主调用都要用插件根 ctx：
+  // 面板拿到的是 slot 注入的收缩 ctx（inject 里没有 workspaces），见 native.ts。
+  // fiber 撤销即清场（registry/openings/birthOrder 全模块级，重激活不得带病存活）。
+  ctx.effect(() => {
+    setRootContext(ctx)
+    return () => { clearNativeRuntime() }
+  }, 'dsh-sidenote: native bridge')
   // 跟随 DSH 通用设置里的语言（locale.preference，Host-backed，实时切换）。
   attachLocale(ctx.locale as LocaleServiceLike | undefined)
   // T2 off-face 全景探测：宿主升级后哪些能力降级了，开发者工具里一眼可见。

package/src/client/sidechat/ModelMenu.tsx

@@ -1,10 +1,10 @@
 /**
  * 模型选择器（WI-02）：composer 脚部的模型 chip → 两级 Menu（provider 分组
- * 标签 + 型号行）。数据走 wire 面（sessions.models/selectModel——fork 时
- * 同步主会话的同款通道）；切的是子会话自己的选择，不回写主会话。
+ * 标签 + 型号行）。数据面走 lifecycle.ts 的双版本链（0.1.5 的
+ * remote.session.modelCatalog/selectModel 优先，<= 0.1.2 的
+ * connection.api.sessions 回退）；切的是子会话自己的选择，不回写主会话。
  *
- * 懒加载：首次打开才拉目录（models RPC 有成本）；切换后本地标签立即更新
- * （selectModel 返回的 selected 为准）。
+ * 懒加载：首次打开才拉目录（catalog RPC 有成本）；切换后本地标签立即更新。
  */
 import { useState } from 'react'
 import { IconCheckOutline16, IconChevronDownOutline14, Menu, type MenuEntry } from '@deepseek-ai/dsh-client-ui-primitives'

package/src/client/sidechat/SideChatPanel.tsx

@@ -16,10 +16,12 @@ import { memo, useCallback, useEffect, useMemo, useRef, useState, useSyncExterna
 import { IconNewChatOutline16 } from '@deepseek-ai/dsh-client-ui-primitives'
 import type { Context, SessionFace, TabComponentProps } from '../host/contracts.ts'
 import { useComposer, type Composer } from './composer.ts'
-import { clearPendingDraft, parseSideChatMeta, phaseOf } from './model.ts'
+import { appendDraftText, clearPendingDraft, parseSideChatMeta, phaseOf } from './model.ts'
 import { transcriptOf } from '../chat/transcript.ts'
 import { EmptyState, MessageList, StateScreen } from './rows.tsx'
 import { chatSourceOf, ensurePanelOpen, forkAndRegister, openSessionWindow, readModelName, updateTabMeta } from './lifecycle.ts'
+import { nativeSidebarHost, registerLiveSideChat } from './native.ts'
+import { dropClosedSideChat, recordClosedSideChat } from './recentClosed.ts'
 import { ToolCard } from '../chat/ToolCard.tsx'
 import { ComposerBar } from './ComposerBar.tsx'
 import { ReasoningRow } from '../chat/ReasoningRow.tsx'
@@ -187,6 +189,60 @@ export function SideChatPanel(props: TabComponentProps & { reflow: ReflowStore }
     // pendingDraft/相位变化时真正动作（清除后 pendingDraft 为 undefined，幂等）。
   }, [pendingDraft, phase, ctx, tab.id])
 
+  // Native right sidebar (better-sidebar >= 0.19): publish this panel so the
+  // programmatic entry points (/side, selection bridge) can reach its tab id and
+  // seed the draft — the layout snapshot cannot see native tabs (see native.ts).
+  // latest-ref：composer/meta/phase/title 每渲新引用，进 deps 会高频重注册。
+  const composerRef = useRef(composer)
+  composerRef.current = composer
+  const metaRef = useRef(tab.meta)
+  metaRef.current = tab.meta
+  const phaseRef = useRef(phase)
+  phaseRef.current = phase
+  const titleRef = useRef(tab.title)
+  titleRef.current = tab.title
+  useEffect(() => {
+    // 后悔药自愈（native）：重挂载说明上次卸载是切会话/HMR 而非关闭，清掉误记。
+    const metaNow = parseSideChatMeta(metaRef.current)
+    if (nativeSidebarHost(ctx) && metaNow.childId !== undefined) {
+      dropClosedSideChat(scope.sessionId, metaNow.childId)
+    }
+    const dispose = registerLiveSideChat(
+      scope.sessionId,
+      tab.id,
+      (text) => {
+        // 相位门：未到 chat（forking/loading）时 composer 还是本地草稿，机器
+        // 绑定后本地草稿被丢弃——改走 meta.pendingDraft，由既有 pendingDraft
+        // effect 在相位就绪后应用（与 legacy 路径同机制）。
+        if (phaseRef.current !== 'chat') {
+          updateTabMeta(ctx, tab.id, (m) => ({ ...m, pendingDraft: appendDraftText(m.pendingDraft ?? '', text) }))
+          return
+        }
+        composerRef.current.appendDraft(text)
+        requestAnimationFrame(() => { rootRef.current?.querySelector('textarea')?.focus() })
+      },
+      () => metaRef.current,
+      () => titleRef.current,
+    )
+    return () => {
+      dispose()
+      // 后悔药数据源（native）：用户 × 关 native tab 不经 descriptor.onClose
+      // （tab-adapter 卸载只 records.drop），以面板卸载补记；误记由挂载时的
+      // drop 自愈。legacy 由 descriptor.onClose 负责，不双写。
+      if (nativeSidebarHost(ctx)) {
+        const m = parseSideChatMeta(metaRef.current)
+        if (m.childId !== undefined && m.parentSessionId !== undefined) {
+          recordClosedSideChat(m.parentSessionId, {
+            childId: m.childId,
+            parentSessionId: m.parentSessionId,
+            title: titleRef.current,
+            closedAt: Date.now(),
+          })
+        }
+      }
+    }
+  }, [scope.sessionId, tab.id, ctx])
+
   // D3a 保存为正式会话：fork 子会话为独立主会话（无 unarchive API，
   // fork 即转正——内置侧边对话同款路径）→ 主视图打开 → 关本 Tab →
   // 全局 toast 确认去向（P4：Tab 关闭后面板树卸载，toast 挂在 body 级

package/src/client/sidechat/index.tsx

@@ -23,6 +23,7 @@ import { SideChatPanel } from './SideChatPanel.tsx'
 import { SIDE_TAB_TYPE, canForkFrom, collectSideTabs, mintSideTabId, sideTabTitle } from './model.ts'
 import { parseSideChatMeta } from './model.ts'
 import { recordClosedSideChat } from './recentClosed.ts'
+import { liveSideChatsOf, nativeSidebarHost } from './native.ts'
 import { openOrFocusSideChat, sideChatTargetTitle } from './open.ts'
 import { t } from '../locales.ts'
 import { registerHeaderEntry } from './header.tsx'
@@ -39,9 +40,18 @@ export function registerSideChat(ctx: Context, reflow: ReflowStore): void {
       icon: (size: number) => <IconNewChatOutline16 size={size} />,
       order: 60,
       available: (availableCtx, scope) => canForkFrom(availableCtx, scope.sessionId),
-      createTab: (state) => ({
-        tab: { id: mintSideTabId(), type: SIDE_TAB_TYPE, title: sideTabTitle(collectSideTabs(state).map(tab => tab.title)) },
-      }),
+      createTab: (state) => {
+        // 标题编号数据源：legacy 读布局快照；native 的 tab 不进快照，并入
+        // live registry（当前会话——openTab 的会话守卫保证 state 属在屏会话）。
+        const titles = collectSideTabs(state).map(tab => tab.title)
+        if (nativeSidebarHost(ctx)) {
+          const current = ctx.sessions.list.getSnapshot().current
+          if (current !== undefined) {
+            for (const live of liveSideChatsOf(current)) titles.push(live.readTitle())
+          }
+        }
+        return { tab: { id: mintSideTabId(), type: SIDE_TAB_TYPE, title: sideTabTitle(titles) } }
+      },
       // × 即焚观感 + 后悔药：关 Tab 时登记「最近关闭」（会话本体仍归档在盘）。
       onClose: (closedTab) => {
         const meta = parseSideChatMeta(closedTab.meta)

package/src/client/sidechat/lifecycle.ts

@@ -6,9 +6,10 @@
  * off-face 探测纪律：session.open()、store.update 均为运行时可达但契约不
  * 保证的面——就地 feature-check + 吞错降级，并登记进 host/probes.ts。
  */
-import type { Context, ConversationSnapshot, SessionBinding, SessionFace, SessionModelsResult, UiConversationLike } from '../host/contracts.ts'
+import type { Context, ConversationSnapshot, ModelSelection, RemoteSessionModelFace, SessionBinding, SessionFace, SessionModelsResult, UiConversationLike } from '../host/contracts.ts'
 import { parseSideChatMeta, type SideChatMeta } from './model.ts'
 import { readTab } from './open.ts'
+import { rootContext } from './native.ts'
 
 /**
  * 首开编排：fork（全量历史快照）→ 登记 meta（先行，绝不丢登记）→
@@ -34,6 +35,9 @@ export async function forkAndRegister(ctx: Context, parentSessionId: string, tab
     // 边界缺失不阻断 fork。
   }
   const forked = await ctx.sessions.fork({ sessionId: parentSessionId })
+  // The slot-provided context a panel receives has a narrower inject list than the
+  // plugin root context, so host calls go through the root context (see native.ts).
+  const owner = rootContext(ctx)
   // meta 先行：fork resolve 后立即登记 childId（会话切换导致组件卸载时
   // updateTab 找不到 tab 也只是 no-op——否则 Tab 永远停在 forking 且下次
   // 挂载重复 fork 出孤儿会话）。
@@ -45,22 +49,20 @@ export async function forkAndRegister(ctx: Context, parentSessionId: string, tab
   }))
   // 归档失败残留可见（无 unarchive API），不阻断面板。
   try {
-    await ctx.workspaces.archiveSession(forked)
+    await owner.workspaces.archiveSession(forked)
   } catch (error) {
     console.warn('[dsh-sidenote] 归档侧边会话失败（会话列表可能短暂可见）:', error)
   }
   // fork 继承 agent preset 但不继承模型选择——读主会话当前模型并同步到
   // 子会话（best-effort，失败则子会话用宿主默认模型，面板标签如实回退）。
+  // 双版本链：投影 + remote.session（0.1.5）优先，connection.api（<= 0.1.2
+  // client 面）回退——面迁移不弃旧档（chatSourceOf 先例）。
   try {
-    const parentModels = await ctx.connection.api.sessions.models({ sessionId: parentSessionId })
-    if (parentModels.result.ok) {
-      const current = parentModels.result.value.current
-      await ctx.connection.api.sessions.selectModel({
-        sessionId: forked,
-        provider: current.provider,
-        model: current.model,
-        ...(current.reasoningEffort !== undefined ? { reasoningEffort: current.reasoningEffort } : {}),
-      })
+    const selection = await readModelSelection(owner, parentSessionId)
+    if (selection === undefined) {
+      console.warn('[dsh-sidenote] 同步主会话模型跳过：主机模型 API 不可用')
+    } else if (!(await writeModelSelection(owner, forked, selection))) {
+      console.warn('[dsh-sidenote] 同步主会话模型失败（子会话用默认模型）')
     }
   } catch (error) {
     console.warn('[dsh-sidenote] 同步主会话模型失败（子会话用默认模型）:', error)
@@ -104,14 +106,100 @@ export function openSessionWindow(session: SessionFace | undefined): void {
   })
 }
 
-/** 读子会话当前模型名（composer 模型标签用）；任何失败回退 null（默认文案）。 */
-export async function readModelName(ctx: Context, sessionId: string): Promise<string | null> {
+/**
+ * Current model selection of a session, read from its `modelSelection`
+ * projection (dsh >= 0.1.2): the durable selection is projected state, so no RPC
+ * is needed and the read is safe for any session id. Snapshot shape authority:
+ * `@deepseek-ai/dsh-api-session-controller/lib/types/types.d.ts`
+ * (`ModelSelectionProjection = { lastUsed, next }`，两者均可为 null——
+ * `next` 缺省时按投影文档回落 `lastUsed`）。
+ */
+export function projectedModelSelection(ctx: Context, sessionId: string): ModelSelection | undefined {
+  try {
+    const session = ctx.sessions.binding(sessionId)?.session as
+      | { projections?: { faceOf?: (name: string) => { getSnapshot?: () => unknown } | undefined } }
+      | undefined
+    const snapshot = session?.projections?.faceOf?.('modelSelection')?.getSnapshot?.() as
+      | { next?: ModelSelection | null; lastUsed?: ModelSelection | null }
+      | undefined
+    return snapshot?.next ?? snapshot?.lastUsed ?? undefined
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Remote session face carrying `selectModel`/`modelCatalog`（dsh 0.1.5 删除
+ * `connection.api.sessions.*` client 面后的模型 RPC 面；事实上 0.1.2-rc.1
+ * 起存在——authority: dsh-api-session-controller lib/typert.remote-client.d.ts）。
+ * 探测走 `ctx.get`（cordis 的 get 不受 inject 门禁限制，本插件为兼容旧宿主
+ * 不声明 inject 'remote.session'；机制见 contracts.ts RemoteSessionModelFace）。
+ * `ctx.get('remote')` 返回命名空间容器时下钻其 `.session` 成员。
+ */
+export function remoteSessionFace(ctx: Context): RemoteSessionModelFace | undefined {
+  for (const name of ['remote.session', 'remote']) {
+    let candidate: unknown
+    try {
+      candidate = ctx.get(name)
+    } catch {
+      continue // service absent
+    }
+    const face = candidate as { selectModel?: unknown; session?: { selectModel?: unknown } } | undefined
+    if (typeof face?.selectModel === 'function') return face as RemoteSessionModelFace
+    if (typeof face?.session?.selectModel === 'function') return face.session as RemoteSessionModelFace
+  }
+  return undefined
+}
+
+/**
+ * 读会话当前模型选择：投影面（0.1.2+，同步无 RPC）优先；旧
+ * `connection.api.sessions.models` RPC（<= 0.1.2 的 client 面，0.1.5 已删）
+ * 回退（双版本链，同 chatSourceOf 先例）。永不抛错。
+ */
+export async function readModelSelection(ctx: Context, sessionId: string): Promise<ModelSelection | undefined> {
+  const projected = projectedModelSelection(ctx, sessionId)
+  if (projected !== undefined) return projected
   try {
     const res = await ctx.connection.api.sessions.models({ sessionId })
-    return res.result.ok ? res.result.value.current.model : null
+    if (res.result.ok) return res.result.value.current
   } catch {
-    return null
+    // 旧面缺席（0.1.5）→ undefined。
   }
+  return undefined
+}
+
+/**
+ * 写会话模型选择：`remote.session.selectModel`（新面）优先，旧
+ * `connection.api.sessions.selectModel` 回退。面在而调用失败（模型不可路由等）
+ * 属真实失败，不再落旧面重试。
+ */
+export async function writeModelSelection(ctx: Context, sessionId: string, selection: ModelSelection): Promise<boolean> {
+  const request = {
+    sessionId,
+    provider: selection.provider,
+    model: selection.model,
+    ...(selection.reasoningEffort !== undefined ? { reasoningEffort: selection.reasoningEffort } : {}),
+  }
+  const face = remoteSessionFace(ctx)
+  if (face !== undefined) {
+    try {
+      return (await face.selectModel(request)).ok
+    } catch {
+      return false
+    }
+  }
+  try {
+    const res = await ctx.connection.api.sessions.selectModel(request)
+    return res.result.ok
+  } catch {
+    return false
+  }
+}
+
+/** 读子会话当前模型名（composer 模型标签用）；任何失败回退 null（默认文案）。 */
+export async function readModelName(ctx: Context, sessionId: string): Promise<string | null> {
+  const selection = await readModelSelection(ctx, sessionId)
+  return selection?.model ?? null
 }
 
 /** 会话内容读取源（0.1.1/0.1.2 双兼容，feature-check 优先链）。 */
@@ -155,8 +243,30 @@ export function chatSourceOf(ctx: Context, binding: SessionBinding | undefined):
   return undefined
 }
 
-/** 拉会话模型目录（models RPC 容错；失败 null → 菜单保持只读标签态）。 */
+/**
+ * 拉会话模型目录：0.1.5 走 `remote.session.modelCatalog()`（目录是宿主级，
+ * 菜单选中项所需的 current 由投影/旧面补上）；旧面回退
+ * `connection.api.sessions.models`。失败 null → 菜单保持只读标签态。
+ */
 export async function listModels(ctx: Context, sessionId: string): Promise<SessionModelsResult | null> {
+  const face = remoteSessionFace(ctx)
+  if (typeof face?.modelCatalog === 'function') {
+    try {
+      const result = await face.modelCatalog()
+      if (result.ok) {
+        const catalog = result.value
+        const current = (await readModelSelection(ctx, sessionId)) ?? catalog.default
+        return {
+          current,
+          routable: catalog.routableProviders.length > 0,
+          groups: catalog.groups,
+          ...(catalog.failures !== undefined ? { failures: catalog.failures } : {}),
+        }
+      }
+    } catch {
+      // 落旧面。
+    }
+  }
   try {
     const res = await ctx.connection.api.sessions.models({ sessionId })
     return res.result.ok ? res.result.value : null
@@ -167,10 +277,6 @@ export async function listModels(ctx: Context, sessionId: string): Promise<Sessi
 
 /** 切换子会话模型；成功返回新模型展示名，失败 null（best-effort）。 */
 export async function switchModel(ctx: Context, sessionId: string, provider: string, model: string): Promise<string | null> {
-  try {
-    const res = await ctx.connection.api.sessions.selectModel({ sessionId, provider, model })
-    return res.result.ok ? model : null
-  } catch {
-    return null
-  }
+  const ok = await writeModelSelection(ctx, sessionId, { provider, model })
+  return ok ? model : null
 }