@deepseek-ai/dsh-client-ui-sidebar-right 0.1.5-rc.2 → 0.1.6-alpha.1

package/README.i18n.yaml

@@ -2,5 +2,5 @@
 # side as of the last confirmed-consistent state. Both languages carry equal authority;
 # after editing either side, bring the other along and re-record with:
 #   pnpm run verify-translation-pairing --write packages/client/ui-sidebar-right/README.md
-README.md: c947b5411f51aff54f480949af203d192662adbf
-README.zh.md: 51a5fd9e3193ff1d7be019d14380a6a124ba477a
+README.md: e5d6e1bef68296e77c6986137bba83ad3f888f8d
+README.zh.md: 75cd092b5cc8602975340b1e434ade2abf7fb442

package/README.md

@@ -67,7 +67,7 @@ After every action the kit's settle planner keeps the expanded surface populated
 
 The docked surface's last tab carries one more rule, decided in the store's `closeTab` and mirrored to the kit through `canCloseTab`: the guide standing as the only docked tab draws no close control and no menu close item — its chip sits quiet, and with no extension item contributed a secondary press opens no menu — and a programmatic close of it records nothing; any other tab standing alone closes together with the column in one entry — the layout stays empty until the next expansion seeds its current default page. Floating panels take no part in the rule: they render whether or not the column is expanded, and their tabs close freely.
 
-State is memory-only. A reload returns every session to the collapsed default; switching sessions keeps each surface where it was.
+Layout, open tabs, navigation parameters and selection are memory-only. A reload constructs the collapsed default; content plugins can then reopen their own live content, as [terminal recovery](../ui-sidebar-terminal/README.md#use-this-package) does. Switching sessions keeps each surface where it was.
 
 <a id="extension-seats"></a>
 ## Extension seats
@@ -84,7 +84,7 @@ Two more seats extend what is already there: `sidebar.right.tab.guide` (chain) r
 <a id="ctxsidebarright"></a>
 ## `ctx.sidebarRight`
 
-`openResource(address, options?)` and `openTab(kind, options?)` are the navigation controller, and every way into the column calls one of them: the conversation's file links and a tool row's line reference (`openResource(fileAddress, { params: { line } })`), the strip's add control and a guide entry box (`openTab`), a file tree's rows (`tab.actions.openResource`). A resource address is a `dsh-resource://<type>/…` URI; without `options.kind` the registry claims it (globs and `canOpen`, best band wins), with it that kind's type in force opens it. A page is named by kind; the tab is recorded under an address this package composes and nobody else spells (`contract/seed.ts`). Both run the same steps as one history entry: a resource tab already showing the same (kind, contentId) is focused wherever it sits unless `revealIfOpened: false`; page tabs always deduplicate within the target pane, regardless of that option; otherwise a new tab lands in `options.replaceTab`'s pane and slot (closing that tab), else `options.paneId`, else the active docked pane; the panel expands, because content the user cannot see is not opened. Then the Tab domain records the navigation — `params` reach the body as `navigation.params`, with `revision` stepped — outside the layout history. `params` is typed by what is opened: a viewer for a resource type merges its entry into `SidebarRightResourceParamsMap` (the text preview declares `{ line?: number }`); a page type that takes parameters merges into `SidebarRightTabParamsMap` under its kind; values are JSON-shaped by convention, unchecked at run time. An address outside `dsh-resource://`, one no type claims, or a kind nothing registered throws: that is a wiring mistake, not a user error.
+`openResource(address, options?)` and `openTab(kind, options?)` are the navigation controller, and every way into the column calls one of them: the conversation's file links and a tool row's line reference (`openResource(fileAddress, { params: { line } })`), the strip's add control and a guide entry box (`openTab`), a file tree's rows (`tab.actions.openResource`). A resource address is a `dsh-resource://<type>/…` URI; without `options.kind` the registry claims it (globs and `canOpen`, best band wins), with it that kind's type in force opens it. A page is named by kind; the tab is recorded under an address this package composes and nobody else spells (`contract/seed.ts`). Both run the same steps as one history entry: a resource tab already showing the same (kind, contentId) is focused wherever it sits unless `revealIfOpened: false`; ordinary page tabs always deduplicate within the target pane, regardless of that option; otherwise a new tab lands in `options.replaceTab`'s pane and slot (closing that tab), else `options.paneId`, else the active docked pane; the panel expands, because content the user cannot see is not opened. Then the Tab domain records the navigation — `params` reach the body as `navigation.params`, with `revision` stepped — outside the layout history. `params` is typed by what is opened: a viewer for a resource type merges its entry into `SidebarRightResourceParamsMap` (the text preview declares `{ line?: number }`); a page type that takes parameters merges into `SidebarRightTabParamsMap` under its kind; values are JSON-shaped by convention, unchecked at run time. An address outside `dsh-resource://`, one no type claims, or a kind nothing registered throws: that is a wiring mistake, not a user error.
 
 `close(tabId)` closes a tab; `active()` reads the active tab. `isExpanded()` and `toggleExpanded()` read and drive the column's expansion; the presentation switch is the panel's own control and not part of this face. Layout operations, for callers that arrange the column programmatically, each recorded like the gesture it stands in for: `focus(tabId)` focuses a tab and its pane; `split(paneId?)` splits a docked pane (the active one by default) under the same pane budget and room rule as the strip's control and returns the new pane's id, or `undefined` — recording nothing — when it cannot; `float(tabId, rect?)` takes a docked tab out into a panel; `dock(paneId)` returns a floating panel to the active docked pane. A tab or pane that does not exist, or already is where the call would put it, is left alone. The face exposes operations only: no layout snapshot, no operation log, no lookup by address. `_undo()` / `_redo()` step the mounted surface's history; they are `@internal` — the sequence has no user-facing control, and these exist for tests. Commands need a mounted session surface; with none, they throw rather than write into a surface nobody draws.
 
@@ -93,12 +93,18 @@ Two more seats extend what is already there: `sidebar.right.tab.guide` (chain) r
 
 The Tab domain retains navigation, an abort signal, and bound actions per (Session, tab id). A private assembly callback adopts each Session's store and reconciles records on its commits. Only record removal or plugin unload aborts the signal; closing the sidebar and switching Sessions retain records, while undo restores a new occurrence. `useTabInfo()` composes framework-bound store and navigation hooks without manual component subscriptions or render-time record creation. `tab.actions` always target their own Session; `tab.visible` distinguishes bodies from titles, and floating tabs remain visible when the sidebar closes. `adopt` is absent from the public controller.
 
+Tab owners register `registerCloseHandler(kind, handler)` through an effect. A handler synchronously retains any background cleanup before allowing explicit close or replacement. The resource owner tracks completion and retry; the sidebar does not wait. A thrown handler preserves the tab. Collapse, presentation changes and plugin disposal do not invoke close handlers; the tab abort signal identifies occurrence disposal, not an explicit close.
+
 <a id="the-guide"></a>
 ## The guide
 
-Default pages depend on the number of registered guide entries, not the number of tab types or open tabs. Exactly one entry opens its page directly (Files in the shipped composition); zero or multiple entries open the guide. Explicitly adding a guide still opens the guide, even with one entry. The sole docked guide is the only tab that cannot close; closing any other sole tab also collapses the column. The chip, context menu, and `close` API apply the same rule.
+Each `guide` entry has an `id` unique within its provider. The guide renders `sidebar.right.tab.guide.entry` by the active definition id, forwarding the entry id, resolved title and optional description, plus the framework `useTabInfo` hook. A provider can register a custom card under its definition id; otherwise the standard icon/title button renders. The sidebar owns width and placement, while custom components own their markup and interaction. Entry identity remains stable across sorting and unrelated registrations.
+
+A tab type can declare `multiple: true` for independent instances such as terminals. Each open receives a distinct content address, so placement and docking preserve those instances; ordinary pages retain per-pane uniqueness.
+
+Default pages depend on the number of registered guide entries, not the number of tab types or open tabs. Exactly one entry opens its page directly; zero or multiple entries open the guide. Explicitly adding a guide still opens the guide, even with one entry. The sole docked guide is the only tab that cannot close; closing any other sole tab also collapses the column. The chip, context menu, and `close` API apply the same rule.
 
-The guide tab is a muted compass over one entry capsule per `guide` entry the registered types contributed, in `order`, centred in the body; the guide has no words of its own. A capsule shows the entry's glyph — or the guide's quieter cube placeholder when the entry registered none — and its title; while at most four entries are listed, an entry that registered a `description` shows it under the title, and a longer list drops every description. Picking a capsule calls `tab.actions.openTab(entry.kind, { replaceTab: true })`, so the guide gives way to the page it opened. A pane holds at most one guide tab. The strip's add control is drawn only while its pane holds none and opens one there with `openTab('guide', { paneId, revealIfOpened: false })`, so a guide in another pane does not capture the click; opening the guide into a pane that already has one focuses it instead; a guide dragged, dropped, or docked into such a pane merges into it — the arriving guide closes and the pane's own is focused; `duplicateTab` on the guide records nothing. A split, an expanded empty root pane, and the pane a sole tab vacates by dropping on its own edge use the same default-page rule, one tab per new pane; the self-edge drop leaves the dragged tab focused. A plain `openTab('guide')` opens or focuses the guide only within the active or named pane. Splitting an empty pane does nothing and returns no new pane. The product allows two horizontal panes, initially equal, with divider ratios limited to 20%–80%. Insufficient width blocks a new split; with two panes already present, a body drop moves the tab between panes instead of creating a third. At the two-pane limit, split controls are hidden; closing back to one pane restores them.
+The guide tab is a muted compass over one entry capsule per `guide` entry the registered types contributed, in `order`, centred in the body; the guide has no words of its own. A capsule shows the entry's glyph — or the guide's quieter cube placeholder when the entry registered none — and its title; while at most four entries are listed, an entry that registered a `description` shows it under the title, and a longer list drops every description. Picking a default capsule calls `tab.actions.openTab(entry.kind, { replaceTab: true })`, so the guide gives way to the page it opened. A pane holds at most one guide tab. The strip's add control is drawn only while its pane holds none and opens one there with `openTab('guide', { paneId, revealIfOpened: false })`, so a guide in another pane does not capture the click; opening the guide into a pane that already has one focuses it instead; a guide dragged, dropped, or docked into such a pane merges into it — the arriving guide closes and the pane's own is focused; `duplicateTab` on the guide records nothing. A split, an expanded empty root pane, and the pane a sole tab vacates by dropping on its own edge use the same default-page rule, one tab per new pane; the self-edge drop leaves the dragged tab focused. A plain `openTab('guide')` opens or focuses the guide only within the active or named pane. Splitting an empty pane does nothing and returns no new pane. The product allows two horizontal panes, initially equal, with divider ratios limited to 20%–80%. Insufficient width blocks a new split; with two panes already present, a body drop moves the tab between panes instead of creating a third. At the two-pane limit, split controls are hidden; closing back to one pane restores them.
 
 <a id="copy"></a>
 ## Copy
@@ -118,7 +124,7 @@ None; this package neither assembles nor sends a provider request.
 
 <a id="known-limitations-and-deferred-work"></a>
 
-- **Memory-only.** Nothing is persisted; a reload starts every session collapsed.
+- **Memory-only layout.** Sidebar state is not persisted; content-specific recovery cannot reproduce the previous layout or selection.
 - **No surface without a session.** State is keyed by session id, so the hero screen shows nothing on the right.
 - **Hard-coded stacking.** The panel and the float host use fixed z-index values because the client has no z-index token layer yet.
 - **Undo is not exposed.** The recorded sequence is stepped only through the `@internal` service methods; product controls are deliberately absent.

package/README.zh.md

@@ -67,7 +67,7 @@ kind: "package-reference"
 
 停靠面的最后一个 tab 还多带一条规则，由 store 的 `closeTab` 决定并经 `canCloseTab` 镜像给套件：作为唯一停靠 tab 的引导页不画关闭控件也不画菜单里的关闭项——它的 chip 呈安静样式，在没有扩展条目时次键按下也不弹出菜单——对它的编程式关闭什么都不记录；任何其它 tab 独自留下时，点击关闭会连同整列一起收起，记为一条历史，布局保持为空，直到下次展开时创建当时的默认页。浮动面板不参与这条规则：它们无论列是否展开都会渲染，其 tab 照常关闭。
 
-状态只在内存中。刷新会让每个会话回到折叠的默认态；切换会话则让每个停靠面留在原处。
+布局、打开的标签页、导航参数和选中项只在内存中。刷新会构造折叠的默认态；内容插件随后可重新打开自己仍存活的内容，例如[终端恢复](../ui-sidebar-terminal/README.zh.md#use-this-package)。切换会话则让每个停靠面留在原处。
 
 <a id="extension-seats"></a>
 ## 扩展席位
@@ -93,12 +93,18 @@ tab 类型分两阶段注册，随包发布的引导类型走的正是别的包
 
 Tab域按（Session，Tab id）保留导航、中止信号与绑定动作；私有装配回调收养各会话的store，并在每次提交时对齐记录。记录消失或插件卸载才中止signal，收起和切会话不销毁记录；undo恢复的是新occurrence。`useTabInfo()` 组合框架绑定的store与导航hook，不在组件中手写订阅或在渲染时创建记录。`tab.actions` 始终作用于自己的会话；`tab.visible` 区分正文与标题，浮窗不受整栏收起影响。`adopt` 不在公开控制器上。
 
+标签页所有者通过 effect 注册 `registerCloseHandler(kind, handler)`。handler 在允许显式关闭或替换前同步保存后台清理任务。资源所有者跟踪完成和重试，侧栏不等待清理。handler 抛错时保留标签页。折叠、展示方式改变和插件卸载不调用关闭 handler；tab abort signal 标识 occurrence 卸载，不代表显式关闭。
+
 <a id="the-guide"></a>
 ## 引导页
 
-默认页取决于已注册的引导入口数，不取决于 tab 类型数或已打开的 tab 数。恰好一个入口时直接打开对应页面（随包组合中为 Files）；没有入口或有多个入口时打开引导页。即使只有一个入口，显式添加引导页仍会打开引导页。只有作为唯一停靠 tab 的引导页不可关闭；关闭其它任何唯一 tab 时会同时收起整列。chip、上下文菜单与 `close` API 使用同一规则。
+每个 `guide` 入口具有 provider 内唯一的 `id`。开始页按当前生效的定义 id 渲染 `sidebar.right.tab.guide.entry`，传入入口 id、解析后的标题、可选描述，以及框架提供的 `useTabInfo` hook。provider 可按自己的定义 id 注册自定义卡片；未注册时使用默认图标与标题按钮。侧栏负责宽度和排列，自定义组件负责内部结构和交互。排序或其他注册变化不会改变入口身份。
+
+终端等需要独立实例的 tab 类型可声明 `multiple: true`。每次打开都会获得独立内容地址，因此移动和停靠会保留这些实例；普通页面仍在每个格内去重。
+
+默认页取决于已注册的引导入口数，不取决于 tab 类型数或已打开的 tab 数。恰好一个入口时直接打开对应页面；没有入口或有多个入口时打开引导页。即使只有一个入口，显式添加引导页仍会打开引导页。只有作为唯一停靠 tab 的引导页不可关闭；关闭其它任何唯一 tab 时会同时收起整列。chip、上下文菜单与 `close` API 使用同一规则。
 
-引导 tab 是一枚弱化的罗盘，下方是各已注册类型贡献的每个 `guide` 条目一个入口胶囊，按 `order` 排列并在正文中居中；引导页自己没有文字。胶囊显示条目的图标——条目没注册图标时用引导页自己更浅的立方体占位符——和标题；列出的条目不超过四个时，注册了 `description` 的条目在标题下显示它，更长的列表则去掉所有描述。选中一个胶囊会调用 `tab.actions.openTab(entry.kind, { replaceTab: true })`，于是引导页让位给它打开的页。一个格最多持有一个引导 tab。tab 条的添加控件只在该格没有引导 tab 时绘制，并以 `openTab('guide', { paneId, revealIfOpened: false })` 在该格打开一个，这样别的格里的引导页不会截走这次点击；把引导页开进已有引导页的格则改为聚焦它；把引导页拖入、放入或收回到这样的格会合并进去——来者关闭，该格自己的被聚焦；对引导页 `duplicateTab` 不记录任何东西。分栏、展开且为空的根格、以及唯一 tab 拖到本格边缘分屏后腾出的格使用相同的默认页规则，每个新格一个 tab；这种本格边缘拖放让被拖的 tab 保持聚焦。普通的 `openTab('guide')` 只在活跃或指定分栏内打开或聚焦引导页。对空分栏执行 split 不产生变化，也不返回新分栏。产品最多保留左右两格，默认均分，分隔条限定20%～80%。宽度不足以容纳两格时不允许新分栏；已有两格时，正文拖放用于跨格移动，不再创建第三格。达到两格上限时隐藏分栏控件；关闭回单格后恢复。
+引导 tab 是一枚弱化的罗盘，下方是各已注册类型贡献的每个 `guide` 条目一个入口胶囊，按 `order` 排列并在正文中居中；引导页自己没有文字。胶囊显示条目的图标——条目没注册图标时用引导页自己更浅的立方体占位符——和标题；列出的条目不超过四个时，注册了 `description` 的条目在标题下显示它，更长的列表则去掉所有描述。点击默认胶囊会调用 `tab.actions.openTab(entry.kind, { replaceTab: true })`，于是引导页让位给它打开的页。一个格最多持有一个引导 tab。tab 条的添加控件只在该格没有引导 tab 时绘制，并以 `openTab('guide', { paneId, revealIfOpened: false })` 在该格打开一个，这样别的格里的引导页不会截走这次点击；把引导页开进已有引导页的格则改为聚焦它；把引导页拖入、放入或收回到这样的格会合并进去——来者关闭，该格自己的被聚焦；对引导页 `duplicateTab` 不记录任何东西。分栏、展开且为空的根格、以及唯一 tab 拖到本格边缘分屏后腾出的格使用相同的默认页规则，每个新格一个 tab；这种本格边缘拖放让被拖的 tab 保持聚焦。普通的 `openTab('guide')` 只在活跃或指定分栏内打开或聚焦引导页。对空分栏执行 split 不产生变化，也不返回新分栏。产品最多保留左右两格，默认均分，分隔条限定在 20%～80%。宽度不足以容纳两格时不允许新分栏；已有两格时，正文拖放用于跨格移动，不再创建第三格。达到两格上限时隐藏分栏控件；关闭回单格后恢复。
 
 <a id="copy"></a>
 ## 文案
@@ -108,17 +114,17 @@ Tab域按（Session，Tab id）保留导航、中止信号与绑定动作；私
 <a id="model-experience"></a>
 ## 模型体验
 
-None, as the package is a browser-side UI plugin layer that registers nothing model-facing.
+无，因为本包是浏览器侧 UI 插件层，不注册任何面向模型的内容。
 
-#### KV Cache effect
+#### KV Cache 影响
 
-None; this package neither assembles nor sends a provider request.
+无；本包既不组装也不发送提供方请求。
 
 ## 已知限制与延期工作
 
 <a id="known-limitations-and-deferred-work"></a>
 
-- **只在内存中。** 不持久化任何东西；刷新让每个会话从折叠态开始。
+- **布局只在内存中。** 侧栏状态不持久化；内容自身的恢复无法还原此前的布局或选中项。
 - **没有会话就没有停靠面。** 状态按会话 id 键控，因此 hero 画面右侧什么都不显示。
 - **硬编码的层叠。** 面板与浮窗宿主使用固定的 z-index 值，因为客户端还没有 z-index token 层。
 - **未暴露撤销。** 记录的序列只能通过 `@internal` 服务方法步进；产品控件是有意缺席的。

package/lib/client.js

@@ -34,7 +34,7 @@ window.__ModuleLoader__.load({
 		let _deepseek_ai_dsh_client_ui_dockkit = require("@deepseek-ai/dsh-client-ui-dockkit");
 		let _deepseek_ai_dsh_client_store = require("@deepseek-ai/dsh-client-store");
 		//#region \0dsh-css:/home/runner/work/deepseek-harness/deepseek-harness/packages/client/ui-sidebar-right/src/client/tabs/guide/GuideBody.module.css.mjs
-		const css$2 = ".geFEbW_guide{box-sizing:border-box;flex-direction:column;justify-content:center;align-items:center;gap:14px;min-height:100%;padding:0 24px;display:flex}.geFEbW_guide:after{content:\"\";flex:0 10%}.geFEbW_hero{color:var(--dsw-static-neutral-200);margin-bottom:16px;display:flex}body[data-ds-dark-theme] .geFEbW_hero{color:var(--dsw-static-neutral-700)}.geFEbW_entry{box-sizing:border-box;width:380px;max-width:100%;min-height:56px;color:var(--dsw-alias-label-primary);font:inherit;text-align:left;background:var(--dsw-alias-bg-layer-1);border:.5px solid var(--dsw-alias-border-l4);cursor:pointer;border-radius:24px;align-items:center;gap:14px;padding:14px 20px;display:flex}.geFEbW_entry:hover{background:var(--dsw-alias-interactive-bg-hover)}.geFEbW_entryIcon{width:26px;height:26px;color:var(--dsw-alias-label-secondary);flex:none;justify-content:center;align-items:center;display:flex}.geFEbW_placeholderInk{color:var(--dsw-alias-label-tertiary)}.geFEbW_entryText{flex-direction:column;gap:3px;min-width:0;display:flex}.geFEbW_entryTitle{white-space:nowrap;text-overflow:ellipsis;font-size:15px;line-height:1.4;overflow:hidden}.geFEbW_entryDescription{color:var(--dsw-alias-label-caption);white-space:nowrap;text-overflow:ellipsis;font-size:13px;line-height:1.4;overflow:hidden}.geFEbW_titleIcon{color:var(--dsw-alias-label-tertiary);flex:none}";
+		const css$2 = ".geFEbW_guide{box-sizing:border-box;flex-direction:column;justify-content:center;align-items:center;gap:14px;min-height:100%;padding:0 24px;display:flex}.geFEbW_guide:after{content:\"\";flex:0 10%}.geFEbW_hero{color:var(--dsw-static-neutral-200);margin-bottom:16px;display:flex}body[data-ds-dark-theme] .geFEbW_hero{color:var(--dsw-static-neutral-700)}.geFEbW_entry{box-sizing:border-box;width:380px;max-width:100%;min-height:56px;color:var(--dsw-alias-label-primary);font:inherit;text-align:left;background:var(--dsw-alias-bg-layer-1);border:.5px solid var(--dsw-alias-border-l4);cursor:pointer;border-radius:24px;align-items:center;gap:14px;padding:14px 20px;display:flex}.geFEbW_entry:hover{background:var(--dsw-alias-interactive-bg-hover)}.geFEbW_entryIcon{width:26px;height:26px;color:var(--dsw-alias-label-secondary);flex:none;justify-content:center;align-items:center;display:flex}.geFEbW_placeholderInk{color:var(--dsw-alias-label-tertiary)}.geFEbW_entryText{flex-direction:column;gap:3px;min-width:0;display:flex}.geFEbW_entryTitle{white-space:nowrap;text-overflow:ellipsis;font-size:15px;line-height:1.4;overflow:hidden}.geFEbW_entryDescription{color:var(--dsw-alias-label-caption);white-space:nowrap;text-overflow:ellipsis;font-size:13px;line-height:1.4;overflow:hidden}.geFEbW_titleIcon{color:var(--dsw-alias-label-tertiary);flex:none}.geFEbW_entryCell{width:380px;max-width:100%}";
 		const tagId$2 = "@deepseek-ai/dsh-client-ui-sidebar-right/GuideBody.module.css";
 		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId$2) + "]") === null) {
 			const tag = document.createElement("style");
@@ -45,6 +45,7 @@ window.__ModuleLoader__.load({
 		}
 		var GuideBody_module_css_default = {
 			"entry": "geFEbW_entry",
+			"entryCell": "geFEbW_entryCell",
 			"entryDescription": "geFEbW_entryDescription",
 			"entryIcon": "geFEbW_entryIcon",
 			"entryText": "geFEbW_entryText",
@@ -155,7 +156,7 @@ window.__ModuleLoader__.load({
 			});
 		}
 		/** The shipped guide: the tab's own compass over the doors out of the column. */
-		function ShippedGuide({ entries, onPick }) {
+		function ShippedGuide({ children }) {
 			return (0, react_jsx_runtime.jsxs)("div", {
 				className: GuideBody_module_css_default.guide,
 				"data-sidebar-right-guide": true,
@@ -163,24 +164,38 @@ window.__ModuleLoader__.load({
 					className: GuideBody_module_css_default.hero,
 					"aria-hidden": "true",
 					children: (0, react_jsx_runtime.jsx)(CompassGlyph, { size: 56 })
-				}), entries.map((entry, index) => (0, react_jsx_runtime.jsx)(EntryBox, {
-					entry,
-					described: entries.length <= MAX_DESCRIBED_ENTRIES,
-					onPick
-				}, `${entry.kind}:${index}`))]
+				}), children]
 			});
 		}
 		/** The guide tab's body, replaceable through its chain child. */
-		function GuideBody({ useTabInfo, useGuideEntries, renderSlotChain }) {
+		function GuideBody({ useTabInfo, useGuideEntries, renderSlot, renderSlotChain }) {
 			const { tab } = useTabInfo();
+			const entries = useGuideEntries((entries) => entries);
 			return renderSlotChain("sidebar.right.tab.guide", {}, {
 				hookContext: useTabInfo,
-				fallback: (0, react_jsx_runtime.jsx)(ShippedGuide, {
-					entries: useGuideEntries((entries) => entries),
-					onPick: (entry) => {
-						tab.actions.openTab(entry.kind, { replaceTab: true });
-					}
-				})
+				fallback: (0, react_jsx_runtime.jsx)(ShippedGuide, { children: entries.map((entry) => {
+					const described = entries.length <= MAX_DESCRIBED_ENTRIES;
+					const description = described ? entry.description?.() : void 0;
+					return (0, react_jsx_runtime.jsx)("div", {
+						className: GuideBody_module_css_default.entryCell,
+						children: renderSlot("sidebar.right.tab.guide.entry", {
+							entryId: entry.id,
+							kind: entry.kind,
+							title: entry.title(),
+							...description === void 0 ? {} : { description }
+						}, {
+							entryKey: entry.providerId,
+							hookContext: useTabInfo,
+							fallback: (0, react_jsx_runtime.jsx)(EntryBox, {
+								entry,
+								described,
+								onPick: (selected) => {
+									tab.actions.openTab(selected.kind, { replaceTab: true });
+								}
+							})
+						})
+					}, JSON.stringify([entry.providerId, entry.id]));
+				}) })
 			});
 		}
 		//#endregion
@@ -664,7 +679,7 @@ window.__ModuleLoader__.load({
 		* @param openTab - the navigation face's `openTab`, which the strip's add control asks for a guide through.
 		* @returns the intents the kit reports gestures to.
 		*/
-		function intentsFor(sessionId, actions, openTab) {
+		function intentsFor(sessionId, actions, openTab, closeTab) {
 			return {
 				focusTab: (tabId) => {
 					actions.focusTab(sessionId, tabId);
@@ -681,9 +696,9 @@ window.__ModuleLoader__.load({
 						revealIfOpened: false
 					});
 				},
-				closeTab: (tabId) => {
+				closeTab: closeTab ?? ((tabId) => {
 					actions.closeTab(sessionId, tabId);
-				},
+				}),
 				duplicateTab: (tabId) => {
 					actions.duplicateTab(sessionId, tabId);
 				},
@@ -866,7 +881,7 @@ window.__ModuleLoader__.load({
 						minPaneFraction: .2,
 						canAddTab: (paneId) => guideIn(surface.layout, paneId) === void 0,
 						canCloseTab: (tabId) => canCloseTab(surface, tabId),
-						intents: intentsFor(sessionId, actions, openTab),
+						intents: intentsFor(sessionId, actions, openTab, panel.closeTab),
 						labels: dockLabels(t),
 						renderTab: bodiesFor(panel),
 						renderTabTitle: titlesFor(panel),
@@ -896,7 +911,7 @@ window.__ModuleLoader__.load({
 				children: (0, react_jsx_runtime.jsx)(_deepseek_ai_dsh_client_ui_dockkit.FloatLayer, {
 					state: surface.layout,
 					canCloseTab: (tabId) => canCloseTab(surface, tabId),
-					intents: intentsFor(sessionId, actions, openTab),
+					intents: intentsFor(sessionId, actions, openTab, panel.closeTab),
 					labels: dockLabels(t),
 					renderTab: bodiesFor(panel),
 					renderTabTitle: titlesFor(panel)
@@ -909,7 +924,7 @@ window.__ModuleLoader__.load({
 		* frame learns the panel's presentation, and where `ctx.sidebarRight` learns
 		* which session it is acting on, because this is the seat that knows both.
 		*/
-		function RightbarSeat({ sessionId, width, viewportWidth, canShow, useStore, actions, t, renderSlot, syncPresentation, bindService, openTab, useTabTypes, useTabNavigation, occurrence }) {
+		function RightbarSeat({ sessionId, width, viewportWidth, canShow, useStore, actions, t, renderSlot, syncPresentation, bindService, openTab, closeTab, useTabTypes, useTabNavigation, occurrence }) {
 			const surfaces = useStore((state) => state.bySession);
 			const surface = surfaces[sessionId];
 			const shown = surface !== void 0 && surface.layout.expanded;
@@ -989,6 +1004,7 @@ window.__ModuleLoader__.load({
 				renderSlot,
 				surface,
 				openTab,
+				closeTab,
 				useTabTypes,
 				useTabNavigation,
 				useStore,
@@ -1019,6 +1035,19 @@ window.__ModuleLoader__.load({
 			}) });
 		}
 		//#endregion
+		//#region ../../util/crypto/src/index.ts
+		/**
+		* Random v4 UUID, minted from `crypto.getRandomValues`.
+		* @returns the UUID string.
+		*/
+		function randomUUID() {
+			const bytes = globalThis.crypto.getRandomValues(new Uint8Array(16));
+			const hex = Array.from(bytes, (byte, index) => {
+				return (index === 6 ? byte & 15 | 64 : index === 8 ? byte & 63 | 128 : byte).toString(16).padStart(2, "0");
+			}).join("");
+			return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+		}
+		//#endregion
 		//#region lib/types/client/tab-domain.js
 		/** Every session's occurrences. */
 		var TabDomain = class {
@@ -1150,6 +1179,35 @@ window.__ModuleLoader__.load({
 		//#endregion
 		//#region lib/types/client/service.js
 		/**
+		* `ctx.sidebarRight`: what other plugins may ask of this column.
+		*
+		* The surface is per session and its state lives in that session's store
+		* instance, which the slot runtime mints per session and a root service cannot
+		* reach on its own. Two paths lead in. The mounted seat publishes its binding —
+		* session id, bound actions, its surface — for exactly as long as it is mounted,
+		* and every command on the public face goes through that binding; a command
+		* arriving with no seat mounted has no session to act on and fails loudly rather
+		* than writing into a surface nobody is drawing. And the plugin adopts each
+		* session's store instance as the runtime mints it, so the controller reaches
+		* any session's store by id and syncs the Tab domain from that store's commits.
+		*
+		* A tab's own actions (`tabActions`) aim at the session the tab is in, not at
+		* the mounted one: they run through that session's adopted store, so a callback
+		* fired after the user switched sessions still lands where its tab is, and they
+		* do nothing for a session whose store was never minted.
+		*
+		* `openResource` and `openTab` are the navigation controller, and every way
+		* into the column is a call to one of them: the conversation's file links, a
+		* tool row's line reference, the strip's add control, a guide entry box, a file
+		* tree's rows. A resource is claimed through the registry by address; a page is
+		* named by kind and recorded at the address this package composes for it. Both
+		* hand the store one settled intent and record the navigation in the Tab
+		* domain. Placement is the caller's option, never a type's property.
+		*
+		* The registration adopts Session stores and injects the mounted seat binding;
+		* callers use the service's navigation methods.
+		*/
+		/**
 		* Create the public controller and the plugin-private store adoption callback.
 		* Adoption subscribes without reconciling; the first store commit creates occurrences.
 		* @param tabs - registered tab types.
@@ -1186,6 +1244,20 @@ window.__ModuleLoader__.load({
 			tabs;
 			adopted;
 			binding;
+			closeHandlers = /* @__PURE__ */ new Map();
+			/**
+			* Register resource cleanup before explicit removal. Failure preserves the tab.
+			* @param kind - tab kind owned by the registering plugin.
+			* @param handler - saves any background cleanup before returning and allowing removal.
+			* @returns an effect-scoped unregister callback.
+			*/
+			registerCloseHandler(kind, handler) {
+				if (this.closeHandlers.has(kind)) throw new Error(`sidebarRight: close handler already registered for ${kind}`);
+				this.closeHandlers.set(kind, handler);
+				return () => {
+					if (this.closeHandlers.get(kind) === handler) this.closeHandlers.delete(kind);
+				};
+			}
 			/**
 			* The Tab domain this controller navigates into; synced from each adopted
 			* store's commits, read by the seat for each body's owner share.
@@ -1265,7 +1337,17 @@ window.__ModuleLoader__.load({
 			*/
 			closeIn(sessionId, tabId) {
 				const actions = this.actionsFor(sessionId);
-				if (actions !== void 0) actions.closeTab(sessionId, tabId);
+				const surface = this.adopted.get(sessionId)?.store.getSnapshot().bySession[sessionId];
+				if (actions === void 0 || surface === void 0) return;
+				const tab = surface.layout.tabs[tabId];
+				if (tab === void 0 || !canCloseTab(surface, tabId)) return;
+				this.removeAfterCleanup(sessionId, tab, () => {
+					actions.closeTab(sessionId, tabId);
+				});
+			}
+			removeAfterCleanup(sessionId, tab, commit) {
+				this.closeHandlers.get(tab.kind)?.(sessionId, tab);
+				commit();
 			}
 			/** Claim a resource and place it in one session; an address outside the scheme or one no type claims throws. */
 			placeResource(sessionId, actions, address, options) {
@@ -1276,7 +1358,7 @@ window.__ModuleLoader__.load({
 			placeTab(sessionId, actions, kind, options) {
 				const definition = this.tabs.get(kind);
 				if (definition === void 0) throw new Error(`sidebarRight: no tab type is registered as "${kind}"`);
-				const address = pageAddress(kind);
+				const address = definition.multiple === true ? `${pageAddress(kind)}/${randomUUID()}` : pageAddress(kind);
 				this.place(sessionId, actions, {
 					kind,
 					contentId: address,
@@ -1285,19 +1367,29 @@ window.__ModuleLoader__.load({
 			}
 			/** The steps both opens share: one store intent, and the navigation record for the tab it settles on. */
 			place(sessionId, actions, claim, address, placement, params) {
-				actions.openContent(sessionId, {
-					kind: claim.kind,
-					contentId: claim.contentId,
-					title: claim.title,
-					...placement.paneId === void 0 ? {} : { paneId: placement.paneId },
-					...placement.replaceTab === void 0 ? {} : { replaceTab: placement.replaceTab },
-					...placement.revealIfOpened === void 0 ? {} : { revealIfOpened: placement.revealIfOpened }
-				}, (tabId) => {
-					this.tabDomain.navigate(sessionId, tabId, {
-						address,
-						params
+				const commit = () => {
+					actions.openContent(sessionId, {
+						kind: claim.kind,
+						contentId: claim.contentId,
+						title: claim.title,
+						...placement.paneId === void 0 ? {} : { paneId: placement.paneId },
+						...placement.replaceTab === void 0 ? {} : { replaceTab: placement.replaceTab },
+						...placement.revealIfOpened === void 0 ? {} : { revealIfOpened: placement.revealIfOpened }
+					}, (tabId) => {
+						this.tabDomain.navigate(sessionId, tabId, {
+							address,
+							params
+						});
 					});
-				});
+				};
+				const layout = this.adopted.get(sessionId)?.store.getSnapshot().bySession[sessionId]?.layout;
+				const replaced = placement.replaceTab === void 0 ? void 0 : layout?.tabs[placement.replaceTab];
+				const revealed = layout === void 0 || placement.revealIfOpened === false ? void 0 : (0, _deepseek_ai_dsh_client_ui_dockkit.findContentTab)(layout, claim.contentId, claim.kind);
+				if (replaced === void 0 || replaced.id === revealed) {
+					commit();
+					return;
+				}
+				this.removeAfterCleanup(sessionId, replaced, commit);
 			}
 			/**
 			* Close one tab of the mounted session; the sole docked guide remains open.
@@ -1305,6 +1397,10 @@ window.__ModuleLoader__.load({
 			*/
 			close(tabId) {
 				const { sessionId, actions } = this.require();
+				if (this.adopted.has(sessionId)) {
+					this.closeIn(sessionId, tabId);
+					return;
+				}
 				actions.closeTab(sessionId, tabId);
 			}
 			/**
@@ -3354,6 +3450,8 @@ window.__ModuleLoader__.load({
 			*/
 			register(definition) {
 				const { id, kind } = definition;
+				const entries = definition.guide ?? [];
+				if (new Set(entries.map((entry) => entry.id)).size !== entries.length) throw new Error(`sidebarRight: duplicate guide entry id in "${id}"`);
 				const band = definition.priority ?? DEFAULT_BAND;
 				if (this.ids.has(id)) throw new Error(`sidebarRight: tab type id "${id}" is already registered`);
 				const held = this.kinds.get(kind);
@@ -3506,7 +3604,8 @@ window.__ModuleLoader__.load({
 				this.cached = this.active().map((entry) => entry.definition);
 				this.guideEntries = this.cached.flatMap((definition) => (definition.guide ?? []).map((entry) => ({
 					...entry,
-					kind: definition.kind
+					kind: definition.kind,
+					providerId: definition.id
 				}))).sort((left, right) => left.order - right.order);
 				(0, _deepseek_ai_dsh_client_store.notifySubscribers)(this.listeners, "[ui-sidebar-right] tab registry");
 			}
@@ -3634,7 +3733,7 @@ window.__ModuleLoader__.load({
 			};
 		};
 		/**
-		* Forward the framework-bound tab hook to a guide replacement.
+		* Forward the framework-bound tab hook to guide content.
 		* @param _standard - the guide's framework standard props.
 		* @param useTabInfo - the enclosing tab's framework-bound reader.
 		* @returns the same reader for the replacement.
@@ -3732,6 +3831,13 @@ window.__ModuleLoader__.load({
 						store,
 						inject: (sessionId) => ({
 							...injected,
+							closeTab: (tabId) => {
+								try {
+									controller.closeIn(sessionId, tabId);
+								} catch (error) {
+									console.error("Sidebar tab close failed:", error);
+								}
+							},
 							keyedHooks: { tabNavigation: (key) => controller.tabDomain.occurrence(sessionId, { id: key }).navigation },
 							occurrence: (tab) => controller.tabDomain.occurrence(sessionId, tab)
 						})
@@ -3749,11 +3855,18 @@ window.__ModuleLoader__.load({
 				const disposeGuide = ctx.slots.inject("sidebar.right.pane.tab", () => ctx.slots.register({
 					name: "sidebar.right.pane.tab",
 					key: GUIDE_ID,
-					children: { "sidebar.right.tab.guide": {
-						kind: "chain",
-						scope: "session",
-						inject: { hooks: { tabInfo: guideTabInfoFactory } }
-					} },
+					children: {
+						"sidebar.right.tab.guide.entry": {
+							kind: "keyed",
+							scope: "session",
+							inject: { hooks: { tabInfo: guideTabInfoFactory } }
+						},
+						"sidebar.right.tab.guide": {
+							kind: "chain",
+							scope: "session",
+							inject: { hooks: { tabInfo: guideTabInfoFactory } }
+						}
+					},
 					inject: () => guideInjected
 				}, GuideBody));
 				const disposeGuideTitle = ctx.slots.inject("sidebar.right.pane.tab.title", () => ctx.slots.register({

package/lib/types/client/contract/slots.d.ts

@@ -58,6 +58,18 @@ declare module '@deepseek-ai/dsh-client-ui-slots' {
                 };
             };
         };
+        /** One provider's guide card, with the standard card as the owner's fallback. */
+        'sidebar.right.tab.guide.entry': {
+            kind: 'keyed';
+            scope: 'session';
+            owner: SidebarRightGuideEntryOwnerProps;
+            hookContext: UseSidebarRightTabInfo;
+            inject: {
+                hooks: {
+                    tabInfo: SlotHookFactory<'sidebar.right.tab.guide.entry', UseSidebarRightTabInfo>;
+                };
+            };
+        };
         /**
          * Extra items at the end of one tab's actions menu, in registration order.
          * Entries decide their own visibility from the tab they are given. Without a
@@ -156,4 +168,11 @@ export interface SidebarRightTabMenuOwnerProps {
      */
     dismiss: () => void;
 }
+/** Resolved guide copy and entry identity supplied to a provider's card renderer. */
+export interface SidebarRightGuideEntryOwnerProps {
+    readonly entryId: string;
+    readonly kind: string;
+    readonly title: string;
+    readonly description?: string;
+}
 //# sourceMappingURL=slots.d.ts.map

package/lib/types/client/index.d.ts

@@ -27,9 +27,9 @@ export type { RightbarSeatProps, SidebarRightInjected, SidebarRightPresentation
 export type { GuideBodyProps, GuideInjected } from './tabs/guide/GuideBody.tsx';
 export type { ExpandButtonProps } from './shell/ExpandButton.tsx';
 export type { SidebarRightState, SurfaceState } from './stores.ts';
-export type { ISidebarRight, SidebarRightBinding, SidebarRightOpenResourceOptions, SidebarRightOpenTabOptions, SidebarRightPlacement, SurfaceActions, } from './service.ts';
+export type { ISidebarRight, SidebarRightBinding, SidebarRightOpenResourceOptions, SidebarRightOpenTabOptions, SidebarRightPlacement, SidebarRightCloseHandler, SurfaceActions, } from './service.ts';
 export type { SidebarRightGuideBox, SidebarRightGuideEntry, SidebarRightTabClaim, SidebarRightTabDefinition, SidebarRightTabPriority, } from './tab-registry.ts';
-export type { SidebarRightTabInfo, SidebarRightTabInjected, UseSidebarRightTabInfo, SidebarRightTabActions, SidebarRightTabMenuOwnerProps, SidebarRightTabNavigation, SidebarRightTabPlacement, } from './contract/slots.ts';
+export type { SidebarRightTabInfo, SidebarRightTabInjected, UseSidebarRightTabInfo, SidebarRightTabActions, SidebarRightTabMenuOwnerProps, SidebarRightTabNavigation, SidebarRightTabPlacement, SidebarRightGuideEntryOwnerProps, } from './contract/slots.ts';
 export type { SidebarRightNavigationParams, SidebarRightResourceParams, SidebarRightResourceParamsMap, SidebarRightTabParams, SidebarRightTabParamsFor, SidebarRightTabParamsMap, } from './contract/params.ts';
 export type { FloatRect, PaneId, TabId, TabRecord } from '@deepseek-ai/dsh-client-ui-dockkit';
 export type { PinResource, SidebarRightNavigator, TabOccurrence } from './tab-domain.ts';

package/lib/types/client/service.d.ts

@@ -1,38 +1,9 @@
-/**
- * `ctx.sidebarRight`: what other plugins may ask of this column.
- *
- * The surface is per session and its state lives in that session's store
- * instance, which the slot runtime mints per session and a root service cannot
- * reach on its own. Two paths lead in. The mounted seat publishes its binding —
- * session id, bound actions, its surface — for exactly as long as it is mounted,
- * and every command on the public face goes through that binding; a command
- * arriving with no seat mounted has no session to act on and fails loudly rather
- * than writing into a surface nobody is drawing. And the plugin adopts each
- * session's store instance as the runtime mints it, so the controller reaches
- * any session's store by id and syncs the Tab domain from that store's commits.
- *
- * A tab's own actions (`tabActions`) aim at the session the tab is in, not at
- * the mounted one: they run through that session's adopted store, so a callback
- * fired after the user switched sessions still lands where its tab is, and they
- * do nothing for a session whose store was never minted.
- *
- * `openResource` and `openTab` are the navigation controller, and every way
- * into the column is a call to one of them: the conversation's file links, a
- * tool row's line reference, the strip's add control, a guide entry box, a file
- * tree's rows. A resource is claimed through the registry by address; a page is
- * named by kind and recorded at the address this package composes for it. Both
- * hand the store one settled intent and record the navigation in the Tab
- * domain. Placement is the caller's option, never a type's property.
- *
- * The registration adopts Session stores and injects the mounted seat binding;
- * callers use the service's navigation methods.
- */
 import type { FloatRect, PaneId, TabId, TabRecord } from '@deepseek-ai/dsh-client-ui-dockkit';
 import type { BoundActions } from '@deepseek-ai/dsh-client-ui-slots';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { SidebarRightResourceParams, SidebarRightTabParamsFor } from './contract/params.ts';
 import type { SidebarRightTabRegistry } from './tab-registry.ts';
-import type { SidebarRightState, SurfaceState } from './stores.ts';
+import { type SidebarRightState, type SurfaceState } from './stores.ts';
 import type { createSidebarRightStore } from './stores.ts';
 import { TabDomain, type PinResource } from './tab-domain.ts';
 /** The seat's bound action set. */
@@ -101,6 +72,8 @@ export interface SidebarRightOpenTabOptions<K extends string = string> extends S
     /** That kind's navigation parameters, typed by kind; delivered as `navigation.params`. */
     readonly params?: SidebarRightTabParamsFor<K>;
 }
+/** Synchronous close/replacement hook; resource owners retain any background cleanup. */
+export type SidebarRightCloseHandler = (sessionId: SessionId, tab: TabRecord) => void;
 /** The outward right-Sidebar face (`ctx.sidebarRight`). */
 export interface ISidebarRight {
     /**
@@ -171,6 +144,14 @@ export declare class SidebarRightController implements ISidebarRight {
     private readonly tabs;
     private readonly adopted;
     private binding;
+    private readonly closeHandlers;
+    /**
+     * Register resource cleanup before explicit removal. Failure preserves the tab.
+     * @param kind - tab kind owned by the registering plugin.
+     * @param handler - saves any background cleanup before returning and allowing removal.
+     * @returns an effect-scoped unregister callback.
+     */
+    registerCloseHandler(kind: string, handler: SidebarRightCloseHandler): () => void;
     /**
      * The Tab domain this controller navigates into; synced from each adopted
      * store's commits, read by the seat for each body's owner share.
@@ -228,6 +209,7 @@ export declare class SidebarRightController implements ISidebarRight {
      * @param tabId - the tab to close.
      */
     closeIn(sessionId: SessionId, tabId: TabId): void;
+    private removeAfterCleanup;
     /** Claim a resource and place it in one session; an address outside the scheme or one no type claims throws. */
     private placeResource;
     /** Place a page type in one session at the address pages are recorded under; an unregistered kind throws. */

package/lib/types/client/shell/SidebarRight.d.ts

@@ -1,6 +1,6 @@
 import type { ReactNode } from 'react';
 import type { HostObservable, InjectFace, PropsLocale, PropsRenderSlots, PropsRuntime, PropsStore } from '@deepseek-ai/dsh-client-ui-slots';
-import type { DockIntents, TabRecord } from '@deepseek-ai/dsh-client-ui-dockkit';
+import type { DockIntents, TabId, TabRecord } from '@deepseek-ai/dsh-client-ui-dockkit';
 import type { HalvesFit, PaneId } from '@deepseek-ai/dsh-client-ui-dockkit';
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { SidebarRightOpenTabOptions } from '../service.ts';
@@ -52,6 +52,8 @@ export interface SidebarRightInjected {
      * the guide opened by kind, through the same path as every other open.
      */
     readonly openTab: (kind: string, options?: SidebarRightOpenTabOptions) => void;
+    /** Close through the resource owner's cleanup handler. */
+    readonly closeTab: (tabId: TabId) => void;
     readonly hooks: {
         readonly tabTypes: HostObservable<readonly SidebarRightTabDefinition[]>;
     };
@@ -71,6 +73,7 @@ interface PanelProps {
     readonly t: RightbarSeatProps['t'];
     readonly renderSlot: Children['renderSlot'];
     readonly openTab: SidebarRightInjected['openTab'];
+    readonly closeTab: SidebarRightInjected['closeTab'];
     readonly useTabTypes: RightbarSeatProps['useTabTypes'];
     readonly useTabNavigation: RightbarSeatProps['useTabNavigation'];
     readonly useStore: Store['useStore'];
@@ -87,13 +90,13 @@ interface PanelProps {
  * @param openTab - the navigation face's `openTab`, which the strip's add control asks for a guide through.
  * @returns the intents the kit reports gestures to.
  */
-export declare function intentsFor(sessionId: SessionId, actions: Store['actions'], openTab: PanelProps['openTab']): DockIntents;
+export declare function intentsFor(sessionId: SessionId, actions: Store['actions'], openTab: PanelProps['openTab'], closeTab?: PanelProps['closeTab']): DockIntents;
 /**
  * The right column's occupant: the panel, anchored to the column's edge and
  * shown or hidden by sliding, plus the floating layer. It is also where the
  * frame learns the panel's presentation, and where `ctx.sidebarRight` learns
  * which session it is acting on, because this is the seat that knows both.
  */
-export declare function RightbarSeat({ sessionId, width, viewportWidth, canShow, useStore, actions, t, renderSlot, syncPresentation, bindService, openTab, useTabTypes, useTabNavigation, occurrence, }: RightbarSeatProps): ReactNode;
+export declare function RightbarSeat({ sessionId, width, viewportWidth, canShow, useStore, actions, t, renderSlot, syncPresentation, bindService, openTab, closeTab, useTabTypes, useTabNavigation, occurrence, }: RightbarSeatProps): ReactNode;
 export {};
 //# sourceMappingURL=SidebarRight.d.ts.map

package/lib/types/client/tab-info.d.ts

@@ -20,10 +20,10 @@ export interface TabHookContext {
  */
 export declare const tabInfoFactory: SlotHookFactory<'sidebar.right.pane.tab', UseSidebarRightTabInfo>;
 /**
- * Forward the framework-bound tab hook to a guide replacement.
+ * Forward the framework-bound tab hook to guide content.
  * @param _standard - the guide's framework standard props.
  * @param useTabInfo - the enclosing tab's framework-bound reader.
  * @returns the same reader for the replacement.
  */
-export declare const guideTabInfoFactory: SlotHookFactory<'sidebar.right.tab.guide', UseSidebarRightTabInfo>;
+export declare const guideTabInfoFactory: (_standard: unknown, useTabInfo: UseSidebarRightTabInfo) => UseSidebarRightTabInfo;
 //# sourceMappingURL=tab-info.d.ts.map

package/lib/types/client/tab-registry.d.ts

@@ -43,6 +43,8 @@ import type { IconProps } from '@deepseek-ai/dsh-client-ui-primitives';
 export type SidebarRightTabPriority = 'extension' | 'builtin' | 'fallback';
 /** One entry capsule the guide page offers, contributed by the type it opens (picking it opens that type as a page). */
 export interface SidebarRightGuideEntry {
+    /** Stable entry identity within its provider. */
+    readonly id: string;
     /** Ascending position among every registered type's entries. */
     readonly order: number;
     /**
@@ -62,6 +64,8 @@ export interface SidebarRightGuideEntry {
 }
 /** A guide entry as the registry lists it: with the kind of the type that contributed it, which is what picking it opens. */
 export interface SidebarRightGuideBox extends SidebarRightGuideEntry {
+    /** Active implementation identity used to dispatch the entry renderer. */
+    readonly providerId: string;
     readonly kind: string;
 }
 /** One registered tab type: its static face, and nothing else. */
@@ -76,6 +80,8 @@ export interface SidebarRightTabDefinition {
     readonly id: string;
     /** Type discriminator: what the tabs of this type are, and what `openTab` names. */
     readonly kind: string;
+    /** Each open by kind creates independent content; omission keeps one page per kind in each pane. */
+    readonly multiple?: boolean;
     /**
      * Resource-address globs this type recognizes; omit for a page type, which is
      * opened by kind and recognizes no address.

package/lib/types/client/tabs/guide/GuideBody.d.ts

@@ -29,7 +29,7 @@ export interface GuideInjected {
     };
 }
 /** The guide body's composed props: the tab it draws, its chain child, and the entries. */
-export type GuideBodyProps = PropsRuntime<'sidebar.right.pane.tab'> & PropsRenderSlots<'sidebar.right.tab.guide'> & InjectFace<GuideInjected>;
+export type GuideBodyProps = PropsRuntime<'sidebar.right.pane.tab'> & PropsRenderSlots<'sidebar.right.tab.guide' | 'sidebar.right.tab.guide.entry'> & InjectFace<GuideInjected>;
 /** The guide tab's body, replaceable through its chain child. */
-export declare function GuideBody({ useTabInfo, useGuideEntries, renderSlotChain }: GuideBodyProps): ReactNode;
+export declare function GuideBody({ useTabInfo, useGuideEntries, renderSlot, renderSlotChain }: GuideBodyProps): ReactNode;
 //# sourceMappingURL=GuideBody.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@deepseek-ai/dsh-client-ui-sidebar-right",
   "description": "Right Sidebar: the docking surface's session-bound state, its panel and header expand control, and the navigation service over it",
-  "version": "0.1.5-rc.2",
+  "version": "0.1.6-alpha.1",
   "publishConfig": {
     "access": "public"
   },
@@ -50,20 +50,21 @@
     "react-dom": "^18.2.0",
     "picomatch": "^4.0.4",
     "clsx": "^2.0.0",
-    "@deepseek-ai/dsh-api-session-controller": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-locale": "^0.1.5-rc.2",
+    "@deepseek-ai/dsh-api-session-controller": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-locale": "^0.1.6-alpha.1",
     "@deepseek-ai/cordis": "^4.0.2",
-    "@deepseek-ai/dsh-client-resources": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-store": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-test-runtime": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-layout": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-slots": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-session": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-session": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.5-rc.2",
-    "@deepseek-ai/dsh-client-ui-dockkit": "^0.1.5-rc.2"
+    "@deepseek-ai/dsh-client-resources": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-test-runtime": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-store": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-ui-dockkit": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-ui-layout": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-ui-renderer": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-ui-session": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-session": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-util-crypto": "^0.1.6-alpha.1",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.6-alpha.1"
   },
   "files": [
     "lib/index.js",