dsh-assist-chat 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dsh-assist-chat contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,98 @@
-# Temporary Holding Version
+# dsh-assist-chat
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+English | [中文](README.zh.md)
+
+Side chat for [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness).
+
+A right-dock seat that **branches the conversation you are in**: it carries the main thread history up to the moment you open it, so "that error above" and "the file we just edited" already make sense — then continues on its own branch without rewriting, interrupting, or derailing the main transcript.
+
+The panel does not reimplement chat. It mounts the product own Conversation surface, so streaming, markdown, tool cards, approvals, Stop and the composer behave exactly like the main conversation.
+
+Inspired by the side chat in ZCode (`zai-org/ZCode`): same shape — a tab in the right side pane backed by a real, parallel child conversation. Not a modal, and it never takes over the main area.
+
+## Why
+
+You are mid-task and want to ask something tangential: a design question, a sanity check, "what does this error actually mean". Opening a new conversation loses the context; typing in the main thread derails it and rewrites the transcript you were about to hand off.
+
+A side chat is the third option. It forks the current conversation, so it knows what the main thread knows, and it runs beside it.
+
+## Features
+
+- **Branch, not blank slate** — every opening forks the main conversation as it is *right now*.
+- **Isolated by construction** — its own Session, its own agent, its own transcript. Nothing you say here lands in the main thread.
+- **Native chat surface** — messages, streaming, tool calls, code blocks, Stop, composer: all inherited, none reimplemented.
+- **Per-conversation** — a branch of conversation A never surfaces while you are looking at B.
+- **Tab lifecycle = branch lifecycle** — one branch while the tab is open (survives tab switches and dock collapse), retired when you close the tab.
+- **No catalog noise** — the branch row is hidden from the left session list while alive, and archived once you close it.
+
+## Install
+
+### From the dsh market
+
+Search for `dsh-assist-chat` under **Plugins → Discover**, or add an index source and install from there.
+
+### From npm
+
+```sh
+dsh plugin --profile desktop add dsh-assist-chat
+```
+
+### From a local checkout
+
+Point the profile at this directory:
+
+```sh
+dsh plugin --profile desktop add link:/absolute/path/to/dsh-assist-chat
+```
+
+Either way the package ships its own `cordis.patch.yml`, so the loader entry is inserted by the package itself. **Restart DeepSeek Harness afterwards.**
+
+## Usage
+
+1. Open a conversation that already has some history.
+2. Click **Side chat** in the session header (the same entry is on the right sidebar guide page).
+3. The dock opens with a branch of that conversation. Ask away.
+4. Close the tab when done. Opening it again later forks a fresh copy of whatever the main thread looks like by then.
+
+## How it works
+
+| Piece | Registration |
+| --- | --- |
+| Tab type | `ctx.sidebarRightTabs.register({ id, kind: "assistchat", keepMounted: true, guide })` |
+| Tab body | `ctx.slots.register({ name: "sidebar.right.pane.tab", key: <id>, children })` |
+| Chat surface | `renderFactorySlot("conversation.content", { variant: "embedded", phase, hero }, { slots: { views: FixedChatView } })` |
+| Entry point | `conversation.session.header.actions` — a list seat; `.corner` is single and already taken |
+
+### Session lifecycle
+
+1. Resolve the conversation on screen: `ctx.get("uiWorkspace").mainReference.sessionId`.
+2. `ctx.get("sessions").fork({ sessionId, increaseTitle: true })` — the child inherits the full transcript. A blank parent falls back to `create({ workspaceId })`.
+3. `ctx.get("sessions").retain(id, { source, signal })` yields the SessionReference the provider needs.
+4. On unmount (tab closed): release the reference, then archive the branch.
+
+The parent id travels through the tab navigation params (`openTab(kind, { params: { parent } })`). The dock layout is stored per Session, so branch identity is keyed the same way.
+
+### Two things that will bite you
+
+**Never archive a branch that is still in use.** DSH ships an `archived-session-gate` that rejects every `agent/pre-step` of an archived Session. Messages are accepted into the queue and then silently vanish, with no error at all. Archiving is only safe *after* the tab closes.
+
+**Which forces hiding to be presentation-only.** The left catalog renders one row per Session with a stable `data-row-key="session:<id>"`, so a plugin can mark the rows it minted and hide them with `display: none`. That keeps the Session fully writable. Trade-offs: the "expand N more" counter still counts hidden rows, and the trick is tied to the row-key convention.
+
+## Compatibility
+
+- DeepSeek Harness `>= 0.2.0` (`engines.dsh`).
+- Client plugin API only — no host-side code, no patched DSH files.
+- A branch is visible in the catalog while its tab is open, and archived when the tab closes.
+
+## Development
+
+```sh
+npm test        # loads client.js in a mocked host and asserts every seat and render
+npm run check   # syntax only
+```
+
+`test/smoke.cjs` runs the shipped Client module in a `vm` sandbox with a mock React and a mock Cordis context. No GUI needed.
+
+## License
+
+MIT

package/README.zh.md

@@ -0,0 +1,96 @@
+# dsh-assist-chat
+
+[English](README.md) | 中文
+
+DeepSeek Harness 的**右侧栏辅助对话**。
+
+在右侧栏开一条**当前对话的分支**：它带着主对话到这一刻为止的完整历史（所以「上面那个报错」「刚才改的文件」它都懂），然后在自己的分支里继续跑，不改写、不打断主线。
+
+面板不自己画聊天框——它挂载产品自带的 Conversation 界面，所以流式输出、markdown、工具卡片、审批、Stop、composer 全部与主对话一致。
+
+对标 ZCode（`zai-org/ZCode`）的「辅助对话」：同样是右侧面板里的一个标签页，背后是与主任务并行的真实子会话。不是弹窗，也不占用主区域。
+
+## 为什么需要它
+
+干到一半想问点偏的：一个设计问题、一次 sanity check、一句「这报错到底什么意思」。单开一个窗口就丢了上下文；在主对话里问又会污染你正准备交付的 transcript。
+
+辅助对话是第三种选择：fork 当前对话，它知道主对话知道的一切，并且和它并排跑。
+
+## 特性
+
+- **是分支，不是空白会话**——每次打开都 fork 主对话**此刻**的状态。
+- **天然隔离**——独立 Session、独立 Agent、独立 transcript，这里说的一切都不会落进主线。
+- **原生聊天界面**——消息、流式、工具调用、代码块、Stop、composer 全部继承，不重画。
+- **按对话隔离**——A 的分支不会在你看 B 的时候冒出来。
+- **标签生命周期 = 分支生命周期**——标签开着就是同一条分支（切标签、收起面板都不重建），关掉即结束。
+- **不污染目录**——分支存活期间在左侧列表里被隐藏，关闭时归档。
+
+## 安装
+
+### 从插件市场
+
+在**插件 → 发现**里搜 `dsh-assist-chat`，或添加索引源后安装。
+
+### 从 npm
+
+```sh
+dsh plugin --profile desktop add dsh-assist-chat
+```
+
+### 从本地目录
+
+```sh
+dsh plugin --profile desktop add link:/本地绝对路径/dsh-assist-chat
+```
+
+包自带 `cordis.patch.yml`，loader 条目由包自己 insert，不用改 profile 的 patch 层。**装完重启 DeepSeek Harness。**
+
+## 用法
+
+1. 打开一个已有内容的会话；
+2. 点会话 header 里的**辅助对话**（右侧栏引导页里也有同一个入口）；
+3. 右栏出现该对话的分支，直接提问；
+4. 用完关掉标签；下次再打开会重新 fork 当时最新的主对话。
+
+## 实现要点
+
+| 部件 | 注册方式 |
+| --- | --- |
+| 标签类型 | `ctx.sidebarRightTabs.register({ id, kind: "assistchat", keepMounted: true, guide })` |
+| 标签正文 | `ctx.slots.register({ name: "sidebar.right.pane.tab", key: <id>, children })` |
+| 聊天界面 | `renderFactorySlot("conversation.content", { variant: "embedded", phase, hero }, { slots: { views: FixedChatView } })` |
+| 入口 | `conversation.session.header.actions` —— 是 list 槽；`.corner` 是 single 且已被占用 |
+
+### 会话生命周期
+
+1. 取屏幕上的会话：`ctx.get("uiWorkspace").mainReference.sessionId`；
+2. `ctx.get("sessions").fork({ sessionId, increaseTitle: true })` —— 子会话继承完整历史；父会话为空时回退 `create({ workspaceId })`；
+3. `ctx.get("sessions").retain(id, { source, signal })` 拿 SessionReference；
+4. 组件卸载（标签关闭）时先 release，再归档。
+
+父会话 id 通过标签的导航参数传进去（`openTab(kind, { params: { parent } })`）。dock 布局本来就按 Session 存，分支身份也按同样的键存。
+
+### 两个会咬人的地方
+
+**别归档还在用的分支。** DSH 的 `archived-session-gate` 会 reject 归档会话的每一个 `agent/pre-step`：消息进了队列然后静默消失，一点报错都没有。只能在标签关闭**之后**归档。
+
+**所以隐藏只能是显示层的。** 左侧目录每行都有稳定的 `data-row-key="session:<id>"`，插件可以给自己造的行走 `display: none`，会话本身完全可写。代价：「展开其余 N 个会话」的计数仍包含隐藏行；这个做法依赖 row-key 约定。
+
+## 兼容性
+
+- DeepSeek Harness `>= 0.2.0`（`engines.dsh`）。
+- 纯 Client 插件 API——没有 host 侧代码，也不修改 DSH 文件。
+- 分支在标签打开期间会出现在会话目录里，关闭后归档。
+
+## 开发
+
+```sh
+npm test        # 在 mock 宿主里加载 client.js，断言每个 seat 与渲染
+npm run check   # 只查语法
+```
+
+`test/smoke.cjs` 用 `vm` + mock React + mock Cordis context 跑真实的 Client 模块，不需要开 GUI。
+
+## 许可
+
+MIT

package/client.js

@@ -0,0 +1,661 @@
+// Assist chat — Client half.
+//
+// A right-dock seat that opens a *separate* Session: the side conversation has
+// its own transcript, its own agent and its own context, so asking it something
+// never disturbs the main thread. The panel reuses the product's own
+// Conversation surface ("conversation.content") instead of redrawing a chat, so
+// markdown, tool calls, approvals and streaming all behave exactly like the main
+// conversation.
+window.__ModuleLoader__.load({
+  id: 'dsh-assist-chat',
+  factory(require) {
+    const React = require('react');
+    const h = React.createElement;
+    const Fragment = React.Fragment;
+
+    const NS = 'dsh-assist-chat';
+    const IMPL_ID = 'dsh-assist-chat';
+    const KIND = 'assistchat';
+    const CONV_SLOT = 'sidebar.assist.conversation';
+    const DEBUG = false;
+
+    function log() {
+      if (!DEBUG) return;
+      try { console.log.apply(console, ['[assist-chat]'].concat([].slice.call(arguments))); } catch (e) {}
+    }
+    function warn() {
+      try { console.warn.apply(console, ['[assist-chat]'].concat([].slice.call(arguments))); } catch (e) {}
+    }
+
+    const ZH = {
+      'tab.title': '辅助对话',
+      'guide.title': '辅助对话',
+      'guide.description': '开一个与主对话隔离的旁支会话，随时追问而不打断主线',
+      'header.button': '辅助对话',
+      'header.buttonTitle': '在右侧栏开启辅助对话',
+      'status.creating': '正在准备辅助对话…',
+      'status.error': '无法开启辅助对话',
+      'retry': '重试'
+    };
+    const EN = {
+      'tab.title': 'Side chat',
+      'guide.title': 'Side chat',
+      'guide.description': 'Open a side conversation isolated from the main thread',
+      'header.button': 'Side chat',
+      'header.buttonTitle': 'Open side chat in the right sidebar',
+      'status.creating': 'Preparing side chat…',
+      'status.error': 'Could not open side chat',
+      'retry': 'Retry'
+    };
+
+    let rootCtx = null;
+    let localeSvc = null;
+    let registryState = null;
+
+    function t(key, vars) {
+      let value;
+      try {
+        if (localeSvc && typeof localeSvc.t === 'function') value = localeSvc.t(NS, key, vars);
+      } catch (e) {}
+      if (value === undefined || value === null) value = ZH[key] || EN[key] || key;
+      if (vars) {
+        value = String(value).replace(/\{(\w+)\}/g, function (m, k) {
+          return vars[k] === undefined ? m : String(vars[k]);
+        });
+      }
+      return String(value);
+    }
+
+    /* ---------------- session plumbing ---------------- */
+
+    // Branches that must not show up in the left catalog. Hidden at the DOM level
+    // rather than archived: an archived Session cannot run a model step, so
+    // hiding through data would silently make the side chat read-only.
+    const hiddenBranchIds = new Set();
+
+    // Lifecycle of a branch is the lifecycle of its tab, deliberately:
+    //   open the seat  -> fork the main conversation *as it is right now*
+    //   keep it open   -> the same branch (keepMounted keeps it mounted)
+    //   close the tab  -> retire that branch (archive it, so the catalog stays clean)
+    // Caching per parent across openings would serve a stale snapshot forever,
+    // which is exactly what a side chat must not do.
+
+    function getService(name) {
+      try { return rootCtx ? rootCtx.get(name) : undefined; } catch (e) { return undefined; }
+    }
+
+    function sessionsService() {
+      return getService('sessions') || null;
+    }
+
+    function pickCwd(sessions) {
+      try {
+        const snapshot = sessions.list.getSnapshot();
+        const ids = (snapshot && snapshot.ids) || [];
+        let best;
+        for (let i = 0; i < ids.length; i += 1) {
+          const row = snapshot.byId[ids[i]];
+          if (!row || !row.cwd) continue;
+          if (!best || (row.updatedAt || 0) > (best.updatedAt || 0)) best = row;
+        }
+        return best ? best.cwd : undefined;
+      } catch (e) {
+        return undefined;
+      }
+    }
+
+    /** The Workspace a side conversation should be filed under. */
+    function pickWorkspaceId() {
+      try {
+        const uiWorkspace = getService('uiWorkspace');
+        if (!uiWorkspace) return undefined;
+        const list = uiWorkspace.workspaces && uiWorkspace.workspaces.list;
+        const items = (list && list.getSnapshot && list.getSnapshot().items) || [];
+        if (!items.length) return undefined;
+        const mainReference = uiWorkspace.mainReference;
+        const currentId = mainReference && mainReference.sessionId;
+        if (currentId) {
+          const holder = items.find(function (item) {
+            return item && item.sessionIds && item.sessionIds.indexOf(currentId) >= 0;
+          });
+          if (holder) return holder.workspaceId;
+        }
+        const sessions = sessionsService();
+        const snapshot = sessions && sessions.list.getSnapshot();
+        const byId = (snapshot && snapshot.byId) || {};
+        let bestId;
+        let bestAt = -1;
+        for (let i = 0; i < items.length; i += 1) {
+          const item = items[i];
+          if (!item || !item.workspaceId) continue;
+          const ids = item.sessionIds || [];
+          let latest = 0;
+          for (let j = 0; j < ids.length; j += 1) {
+            const row = byId[ids[j]];
+            if (row && (row.updatedAt || 0) > latest) latest = row.updatedAt || 0;
+          }
+          if (latest > bestAt) { bestAt = latest; bestId = item.workspaceId; }
+        }
+        return bestId || items[0].workspaceId;
+      } catch (e) {
+        return undefined;
+      }
+    }
+
+    /**
+     * An archived Session cannot run a model step: DSH's archived-session gate
+     * rejects every pre-step. Earlier builds archived side conversations to keep
+     * the catalog clean, which silently ate every message, so restore any branch
+     * that is still archived before it is used.
+     */
+    function ensureWritable(sessionId) {
+      try {
+        const uiWorkspace = getService('uiWorkspace');
+        if (!uiWorkspace || typeof uiWorkspace.unarchiveSession !== 'function') return;
+        const archived = uiWorkspace.workspaces
+          && uiWorkspace.workspaces.list.getSnapshot().archivedSessionIds;
+        if (!archived || archived.indexOf(sessionId) < 0) return;
+        const pending = uiWorkspace.unarchiveSession(sessionId);
+        if (pending && typeof pending.catch === 'function') pending.catch(function (error) {
+          warn('unarchive side session failed', error);
+        });
+      } catch (e) {
+        warn('unarchive check failed', e);
+      }
+    }
+
+    /**
+     * Keep our branches out of the left catalog without archiving them.
+     *
+     * The catalog renders one row per Session carrying a stable
+     * data-row-key="session:<id>", so hiding is a matter of marking the rows
+     * whose id we minted. Presentation only: the Session keeps running, keeps
+     * accepting prompts, and stays reachable through its dock tab.
+     */
+    function installCatalogHiding() {
+      if (typeof document === 'undefined' || typeof MutationObserver !== 'function') {
+        return function () {};
+      }
+      const ATTR = 'data-assist-hidden';
+      let raf = 0;
+      let styleEl = null;
+      let observer = null;
+
+      const mark = function () {
+        raf = 0;
+        try {
+          const rows = document.querySelectorAll('[data-row-key^="session:"]');
+          for (let i = 0; i < rows.length; i += 1) {
+            const row = rows[i];
+            const key = row.getAttribute('data-row-key') || '';
+            const id = key.slice('session:'.length);
+            const hide = hiddenBranchIds.has(id);
+            if (hide && !row.hasAttribute(ATTR)) row.setAttribute(ATTR, '1');
+            else if (!hide && row.hasAttribute(ATTR)) row.removeAttribute(ATTR);
+          }
+        } catch (e) {
+          warn('catalog hide failed', e);
+        }
+      };
+
+      const schedule = function () {
+        if (raf) return;
+        try {
+          raf = window.requestAnimationFrame(mark);
+        } catch (e) {
+          mark();
+        }
+      };
+
+      styleEl = document.createElement('style');
+      styleEl.setAttribute('data-plugin', IMPL_ID + '/catalog-hide');
+      styleEl.textContent = '[data-assist-hidden]{display:none !important}';
+      document.head.appendChild(styleEl);
+
+      observer = new MutationObserver(schedule);
+      try {
+        observer.observe(document.body, { childList: true, subtree: true });
+      } catch (e) {
+        warn('catalog observer failed', e);
+      }
+      mark();
+
+      return function () {
+        try { observer.disconnect(); } catch (e) {}
+        if (styleEl) { try { styleEl.remove(); } catch (e) {} }
+        if (raf) { try { window.cancelAnimationFrame(raf); } catch (e) {} }
+      };
+    }
+
+    /** Give the side conversation a recognisable title in the session catalog. */
+    let sideCounter = 0;
+
+    function labelSideSession(sessions, sessionId) {
+      sideCounter += 1;
+      const title = t('tab.title') + ' ' + sideCounter;
+      try {
+        const renamed = sessions.rename(sessionId, title);
+        if (renamed && typeof renamed.catch === 'function') renamed.catch(function () {});
+        return title;
+      } catch (e) {
+        return undefined;
+      }
+    }
+
+    /** The Session occupying the main column: the context a side chat must share. */
+    function currentMainSessionId() {
+      try {
+        const uiWorkspace = getService('uiWorkspace');
+        const reference = uiWorkspace && uiWorkspace.mainReference;
+        const id = reference && reference.sessionId;
+        return typeof id === 'string' && id !== '' ? id : undefined;
+      } catch (e) {
+        return undefined;
+      }
+    }
+
+    /** Pull a Session id out of every shape the client contract has used. */
+    function idOf(result) {
+      if (typeof result === 'string' && result !== '') return result;
+      if (result && typeof result.sessionId === 'string' && result.sessionId !== '') return result.sessionId;
+      if (result && result.ok === true) {
+        const value = result.value;
+        if (value && typeof value.sessionId === 'string' && value.sessionId !== '') return value.sessionId;
+        if (typeof value === 'string' && value !== '') return value;
+      }
+      const error = result && result.error;
+      const details = error && (error.details || error.data);
+      if (error && error.code === 'session/workspace-attach-failed' && details && details.sessionId) {
+        return details.sessionId;
+      }
+      return undefined;
+    }
+
+    /** True when the Session has no turns yet, so forking it would inherit nothing. */
+    function isBlankSession(sessions, sessionId) {
+      try {
+        const snapshot = sessions.list.getSnapshot();
+        const row = snapshot && snapshot.byId && snapshot.byId[sessionId];
+        if (!row) return false;
+        return row.blank === true;
+      } catch (e) {
+        return false;
+      }
+    }
+
+    /**
+     * Fork the main conversation. The child carries the parent's whole transcript
+     * up to this instant, which is exactly the point of a side chat: it already
+     * knows what "this" and "that error above" refer to, and it can continue on
+     * its own without touching the main thread.
+     */
+    function forkSideSession(sessions, parentSessionId) {
+      return Promise.resolve()
+        .then(function () {
+          return sessions.fork({ sessionId: parentSessionId, increaseTitle: true });
+        })
+        .then(function (result) {
+          const id = idOf(result);
+          if (!id) throw new Error('assist-chat: fork returned no Session id');
+          return id;
+        });
+    }
+
+    /** Last resort: a brand-new Session in the current Workspace. */
+    function createFreshSession(sessions) {
+      const workspaceId = pickWorkspaceId();
+      const cwd = workspaceId === undefined ? pickCwd(sessions) : undefined;
+      const request = workspaceId !== undefined ? { workspaceId: workspaceId } : (cwd === undefined ? {} : { cwd: cwd });
+      return Promise.resolve()
+        .then(function () { return sessions.create(request); })
+        .then(function (result) {
+          const id = idOf(result);
+          if (id) return id;
+          let detail;
+          try { detail = JSON.stringify(result); } catch (e) { detail = String(result); }
+          const error = result && result.error;
+          if (error) detail = '[' + [error.code, error.message].filter(Boolean).join(' / ') + '] ' + detail;
+          throw new Error('assist-chat: create failed ' + (detail || 'unknown error').slice(0, 300));
+        });
+    }
+
+    function isAlive(sessions, sessionId) {
+      try {
+        const snapshot = sessions.list.getSnapshot();
+        return !!(snapshot && snapshot.byId && snapshot.byId[sessionId]);
+      } catch (e) {
+        return true;
+      }
+    }
+
+    function createSideSession(parentSessionId) {
+      const sessions = sessionsService();
+      if (!sessions) return Promise.reject(new Error('assist-chat: sessions service is unavailable'));
+      const canFork = parentSessionId !== undefined && parentSessionId !== '' && !isBlankSession(sessions, parentSessionId);
+      return Promise.resolve()
+        .then(function () {
+          if (!canFork) return undefined;
+          return forkSideSession(sessions, parentSessionId).catch(function (error) {
+            warn('fork failed, falling back to a fresh Session', error);
+            return undefined;
+          });
+        })
+        .then(function (forked) {
+          if (forked !== undefined) return forked;
+          return createFreshSession(sessions);
+        })
+        .then(function (sessionId) {
+          if (!sessionId) throw new Error('assist-chat: no Session was produced for the side chat');
+          hiddenBranchIds.add(sessionId);
+          ensureWritable(sessionId);
+          labelSideSession(sessions, sessionId);
+          return sessionId;
+        });
+    }
+
+    /**
+     * Retire a branch whose tab was closed: archive it so the left catalog does
+     * not grow one entry per visit. Safe here only because the branch is idle —
+     * the archived-session gate rejects model steps, and we never step it again.
+     */
+    function retireSideSession(sessionId) {
+      if (!sessionId) return;
+      try {
+        const uiWorkspace = getService('uiWorkspace');
+        if (!uiWorkspace || typeof uiWorkspace.archiveSession !== 'function') return;
+        const pending = uiWorkspace.archiveSession(sessionId);
+        if (pending && typeof pending.catch === 'function') pending.catch(function () {});
+      } catch (e) {
+        warn('retire side session failed', e);
+      }
+    }
+
+    /* ---------------- components ---------------- */
+
+    function FixedChatView(props) {
+      return h(Fragment, null, props.renderSlot('conversation.session', { view: 'chat' }));
+    }
+
+    function AssistConversation(props) {
+      const parts = props || {};
+      const session = parts.useSession(function (value) { return value; });
+      const conversation = parts.useConversation(function (value) { return value; });
+      const summaryBlank = parts.useSessions
+        ? parts.useSessions(function (state) { return state.byId[parts.sessionId] && state.byId[parts.sessionId].blank; })
+        : undefined;
+      const activeTargets = conversation && conversation.activeTargets ? conversation.activeTargets.size : 0;
+      const shellPhase = activeTargets > 0 || (!session.blank && !session.awaitingFirstTurn) || session.running
+        ? 'active'
+        : (session.promptAttempted ? 'engaging' : 'blank');
+      const settling = shellPhase === 'blank' && session.openState === 'loading' && summaryBlank !== true;
+      const hero = shellPhase === 'blank' && (session.openState === 'open' || summaryBlank === true);
+      if (typeof parts.renderFactorySlot !== 'function') {
+        return h('div', { className: 'dac-status' },
+          h('div', { className: 'dac-status-text' }, t('status.error')));
+      }
+      return parts.renderFactorySlot('conversation.content', {
+        variant: 'embedded',
+        phase: settling ? 'settling' : (hero ? 'hero' : 'active'),
+        hero: hero
+      }, { slots: { views: FixedChatView } });
+    }
+
+    function useSideSession(parentSessionId) {
+      const statePair = React.useState({ phase: 'creating' });
+      const setState = statePair[1];
+      const attemptPair = React.useState(0);
+      const setAttempt = attemptPair[1];
+      const liveRef = React.useRef(null);
+
+      React.useEffect(function () {
+        let cancelled = false;
+        let live = null;
+        const controller = new AbortController();
+        const sessions = sessionsService();
+        setState({ phase: 'creating' });
+        if (!sessions) {
+          setState({ phase: 'error', error: new Error('assist-chat: sessions service is unavailable') });
+          return undefined;
+        }
+        (async function () {
+          try {
+            // Always a fresh fork: the seat shows the main conversation as it is
+            // at the moment you open it, never a snapshot from an earlier visit.
+            const sessionId = await createSideSession(parentSessionId);
+            if (cancelled) { retireSideSession(sessionId); return; }
+            const reference = sessions.retain(sessionId, { source: IMPL_ID + '/sidebar', signal: controller.signal });
+            live = { sessionId: sessionId, reference: reference };
+            liveRef.current = live;
+            if (cancelled) return;
+            setState({ phase: 'ready', sessionId: sessionId, reference: reference });
+          } catch (error) {
+            if (!cancelled) setState({ phase: 'error', error: error });
+          }
+        })();
+        return function () {
+          cancelled = true;
+          try { controller.abort(); } catch (e) {}
+          const current = liveRef.current || live;
+          liveRef.current = null;
+          if (current) {
+            try { current.reference.release(); } catch (e) {}
+            retireSideSession(current.sessionId);
+          }
+        };
+      }, [attemptPair[0], parentSessionId]);
+
+      const retry = React.useCallback(function () {
+        setAttempt(function (n) { return n + 1; });
+      }, []);
+
+      return [statePair[0], retry];
+    }
+
+    function AssistTab(props) {
+      const parts = props || {};
+      // The dock's layout is per-Session, so the seat knows which main
+      // conversation it belongs to through its own tab navigation params.
+      // The guide-page entry has no params, so fall back to whatever the main
+      // column is showing right now.
+      const useTabInfo = parts.useTabInfo;
+      const tabInfo = typeof useTabInfo === 'function' ? useTabInfo() : null;
+      const navigation = tabInfo && tabInfo.tab ? tabInfo.tab.navigation : null;
+      const params = navigation ? navigation.params : null;
+      const parentParam = params && typeof params.parent === 'string' ? params.parent : '';
+      const scopeSessionId = typeof parts.sessionId === 'string' ? parts.sessionId : '';
+      const parentSessionId = parentParam !== '' ? parentParam : (scopeSessionId !== '' ? scopeSessionId : currentMainSessionId());
+      const sideState = useSideSession(parentSessionId);
+      const state = sideState[0];
+      const retry = sideState[1];
+
+      if (state.phase !== 'ready') {
+        const failed = state.phase === 'error';
+        const detail = failed && state.error ? String((state.error && state.error.message) || state.error) : '';
+        return h('div', { className: 'dac-status' },
+          h('div', { className: 'dac-status-text' }, failed ? t('status.error') : t('status.creating')),
+          detail ? h('div', { className: 'dac-status-detail' }, detail) : null,
+          failed ? h('button', { type: 'button', className: 'dac-btn', onClick: retry }, t('retry')) : null
+        );
+      }
+      if (typeof parts.renderSlot !== 'function' || !parts.SessionProvider) {
+        return h('div', { className: 'dac-status' },
+          h('div', { className: 'dac-status-text' }, t('status.error')));
+      }
+      return h('div', { className: 'dac-root', 'data-assist-chat': '' },
+        h(parts.SessionProvider, { session: state.reference }, parts.renderSlot(CONV_SLOT, {}))
+      );
+    }
+
+    function AssistGlyph() {
+      return h('svg', {
+        width: 16, height: 16, viewBox: '0 0 24 24', fill: 'none',
+        stroke: 'currentColor', strokeWidth: 1.7, strokeLinecap: 'round', strokeLinejoin: 'round',
+        'aria-hidden': 'true'
+      },
+        h('path', { d: 'M21 11.5a8.38 8.38 0 0 1-.9 3.8 8.5 8.5 0 0 1-7.6 4.7 8.38 8.38 0 0 1-3.8-.9L3 21l1.9-5.7a8.38 8.38 0 0 1-.9-3.8 8.5 8.5 0 0 1 4.7-7.6 8.38 8.38 0 0 1 3.8-.9h.5a8.48 8.48 0 0 1 8 8v.5z' }),
+        h('path', { d: 'M12 8v6M9 11h6' }));
+    }
+
+    function AssistHeaderButton() {
+      return h('button', {
+        type: 'button',
+        className: 'dac-header-btn',
+        title: t('header.buttonTitle'),
+        'aria-label': t('header.buttonTitle'),
+        onClick: function (event) {
+          try {
+            if (event) { event.preventDefault(); event.stopPropagation(); }
+          } catch (e) {}
+          openSideChat();
+        }
+      }, h(AssistGlyph, null), h('span', { className: 'dac-header-btn-text' }, t('header.button')));
+    }
+
+    /** Open (or focus) the side-chat seat for the conversation on screen. */
+    function openSideChat() {
+      const sidebarRight = getService('sidebarRight');
+      if (!sidebarRight || typeof sidebarRight.openTab !== 'function') {
+        warn('sidebarRight service is unavailable');
+        return;
+      }
+      const parentSessionId = currentMainSessionId();
+      try {
+        // The parent id rides the tab's navigation params so this seat always
+        // renders the branch belonging to the conversation that owns it.
+        if (parentSessionId) sidebarRight.openTab(KIND, { params: { parent: parentSessionId } });
+        else sidebarRight.openTab(KIND);
+        return;
+      } catch (error) {
+        warn('openTab failed', error);
+      }
+      // Fall back to just revealing the dock; the seat renders its own state.
+      const layout = getService('layout');
+      try {
+        if (layout && typeof layout.openRightbar === 'function') layout.openRightbar();
+      } catch (e) {
+        warn('openRightbar failed', e);
+      }
+    }
+
+    function newSideChat() {
+      const sidebarRight = getService('sidebarRight');
+      if (!sidebarRight) return;
+      // Closing unmounts the seat, which retires the old branch; reopening then
+      // forks the main conversation again at its current state.
+      try {
+        if (typeof sidebarRight.close === 'function') sidebarRight.close(KIND);
+      } catch (e) {
+        warn('close failed', e);
+      }
+      setTimeout(function () { openSideChat(); }, 30);
+    }
+
+    /* ---------------- styles ---------------- */
+
+    const CSS = [
+      '.dac-root{display:flex;flex-direction:column;min-height:0;height:100%;width:100%;background:var(--dsw-alias-bg-base,transparent);color:var(--dsw-alias-label-primary,#111)}',
+      '.dac-status{display:flex;flex-direction:column;align-items:center;justify-content:center;gap:10px;height:100%;padding:24px;font-size:13px;color:var(--dsw-alias-label-secondary,#6b7280)}',
+      '.dac-status-text{text-align:center;line-height:1.6}',
+      '.dac-status-detail{max-width:320px;text-align:center;line-height:1.5;font-size:11px;font-family:ui-monospace,SFMono-Regular,Menlo,monospace;color:var(--dsw-alias-label-tertiary,#9aa3ad);word-break:break-word}',
+      '.dac-btn{font:inherit;font-size:12px;padding:5px 12px;border-radius:8px;cursor:pointer;border:1px solid var(--dsw-alias-border-l1,#dcdfe4);background:var(--dsw-alias-bg-layer-2,#f3f4f6);color:var(--dsw-alias-label-primary,#111)}',
+      '.dac-btn:hover{filter:brightness(.97)}',
+      '.dac-header-btn{display:inline-flex;align-items:center;gap:6px;height:28px;padding:0 9px;border:none;border-radius:8px;background:transparent;color:var(--dsw-alias-label-secondary,#6b7280);font:inherit;font-size:12px;line-height:1;cursor:pointer}',
+      '.dac-header-btn:hover{background:var(--dsw-alias-bg-layer-2,rgba(0,0,0,.05));color:var(--dsw-alias-label-primary,#111)}',
+      '.dac-header-btn:active{transform:translateY(.5px)}',
+      '.dac-header-btn svg{flex:none;opacity:.9}',
+      '.dac-header-btn-text{white-space:nowrap}'
+    ].join('\n');
+
+    /* ---------------- plugin ---------------- */
+
+    return {
+      inject: ['slots', 'layout', 'sessions', 'sidebarRight', 'sidebarRightTabs'],
+      apply: function (ctx) {
+        rootCtx = ctx;
+
+        try {
+          const service = ctx.get('locale');
+          if (service && typeof service.register === 'function') {
+            localeSvc = service;
+            try { service.register(NS, 'zh', ZH); } catch (e) { warn('locale zh', e); }
+            try { service.register(NS, 'en', EN); } catch (e) { warn('locale en', e); }
+          }
+        } catch (e) { warn('locale service', e); }
+
+        ctx.effect(function () {
+          const el = document.createElement('style');
+          el.setAttribute('data-plugin', IMPL_ID);
+          el.textContent = CSS;
+          document.head.appendChild(el);
+          return function () { try { el.remove(); } catch (e) {} };
+        });
+
+        ctx.effect(function () { return installCatalogHiding(); });
+
+        ctx.effect(function () {
+          const registry = getService('sidebarRightTabs');
+          if (!registry || typeof registry.register !== 'function') {
+            registryState = { registered: false, error: 'sidebarRightTabs service is unavailable' };
+            warn(registryState.error);
+            return function () {};
+          }
+          const state = { registered: true, error: null };
+          registryState = state;
+          return withRegistry(registry, state);
+        });
+
+        function withRegistry(registry, state) {
+          try {
+            return registry.register({
+              id: IMPL_ID,
+              kind: KIND,
+              priority: 'extension',
+              // Kept mounted across tab switches and dock collapse so the branch
+              // and its transcript survive until the tab itself is closed.
+              keepMounted: true,
+              title: function () { return t('tab.title'); },
+              guide: [{
+                id: 'assist',
+                order: 30,
+                title: function () { return t('guide.title'); },
+                description: function () { return t('guide.description'); },
+                icon: AssistGlyph
+              }]
+            });
+          } catch (error) {
+            state.registered = false;
+            state.error = String((error && error.message) || error);
+            warn('tab type registration failed', error);
+            return function () {};
+          }
+        }
+
+        ctx.effect(function () {
+          return ctx.slots.inject('sidebar.right.pane.tab', function () {
+            return ctx.slots.register({
+              name: 'sidebar.right.pane.tab',
+              key: IMPL_ID,
+              children: { 'sidebar.assist.conversation': { kind: 'single', scope: 'session' } }
+            }, AssistTab);
+          });
+        });
+
+        ctx.effect(function () {
+          return ctx.slots.inject(CONV_SLOT, function () {
+            return ctx.slots.register({ name: CONV_SLOT }, AssistConversation);
+          });
+        });
+
+        ctx.effect(function () {
+          return ctx.slots.inject('conversation.session.header.actions', function () {
+            return ctx.slots.register({
+              name: 'conversation.session.header.actions',
+              id: 'assist-chat-open',
+              order: 60
+            }, AssistHeaderButton);
+          });
+        });
+      }
+    };
+  }
+});

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: assist-chat
+      name: 'dsh-assist-chat'

package/icon.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round">
+  <path d="M21 11.5a8.38 8.38 0 0 1-.9 3.8 8.5 8.5 0 0 1-7.6 4.7 8.38 8.38 0 0 1-3.8-.9L3 21l1.9-5.7a8.38 8.38 0 0 1-.9-3.8 8.5 8.5 0 0 1 4.7-7.6 8.38 8.38 0 0 1 3.8-.9h.5a8.48 8.48 0 0 1 8 8v.5z"/>
+  <path d="M12 8v6M9 11h6"/>
+</svg>

package/index.js

@@ -0,0 +1,2 @@
+/** Host half of the assist-chat bundle; the Client module owns everything visible. */
+export function apply() {}

package/locale/en.json

@@ -0,0 +1,15 @@
+{
+  "tab.title": "Side chat",
+  "guide.title": "Side chat",
+  "guide.description": "Open a side conversation isolated from the main thread",
+  "action.open": "Side chat",
+  "action.openTitle": "Open side chat",
+  "action.new": "New side chat",
+  "action.newTitle": "Start a fresh side conversation",
+  "header.button": "Side chat",
+  "header.buttonTitle": "Open side chat in the right sidebar",
+  "status.creating": "Preparing side chat…",
+  "status.error": "Could not open side chat",
+  "retry": "Retry",
+  "empty.hint": "Ask anything — the main thread stays untouched."
+}

package/locale/zh.json

@@ -0,0 +1,15 @@
+{
+  "tab.title": "辅助对话",
+  "guide.title": "辅助对话",
+  "guide.description": "开一个与主对话隔离的旁支会话，随时追问而不打断主线",
+  "action.open": "辅助对话",
+  "action.openTitle": "打开辅助对话",
+  "action.new": "新建辅助对话",
+  "action.newTitle": "开一个全新的旁支会话",
+  "header.button": "辅助对话",
+  "header.buttonTitle": "在右侧栏开启辅助对话",
+  "status.creating": "正在准备辅助对话…",
+  "status.error": "无法开启辅助对话",
+  "retry": "重试",
+  "empty.hint": "问点什么吧，这里不会打断主对话。"
+}

package/package.json

@@ -1,6 +1,67 @@
 {
   "name": "dsh-assist-chat",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Side chat for DeepSeek Harness: a right-dock seat that branches the current conversation, so you can ask follow-ups without derailing the main thread. 右侧栏辅助对话：从当前会话 fork 一条旁支，追问不打断主线。",
+  "type": "module",
+  "license": "MIT",
+  "icon": "./icon.svg",
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "side-chat",
+    "assist",
+    "sidebar",
+    "fork",
+    "conversation"
+  ],
+  "engines": {
+    "node": ">=20",
+    "dsh": ">=0.2.0"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "icon.svg",
+    "README.md",
+    "README.zh.md",
+    "LICENSE",
+    "test/*.cjs"
+  ],
+  "dsh": {
+    "manifestVersion": 1,
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": []
+    }
+  },
+  "scripts": {
+    "test": "node test/smoke.cjs",
+    "check": "node --check client.js",
+    "prepublishOnly": "node --check client.js && node test/smoke.cjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "author": "sleep123937 <1347351715@qq.com> (https://github.com/sleep123937)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sleep123937/dsh-assist-chat.git"
+  },
+  "homepage": "https://github.com/sleep123937/dsh-assist-chat#readme",
+  "bugs": {
+    "url": "https://github.com/sleep123937/dsh-assist-chat/issues"
+  }
+}

package/test/smoke.cjs

@@ -0,0 +1,190 @@
+// Smoke test: load the assist-chat Client module in a mocked host and prove that
+// apply() wires the right seats and that every component renders safely.
+const fs = require('fs');
+const vm = require('vm');
+const path = require('path');
+
+const SRC = path.join(__dirname, '..', 'client.js');
+const code = fs.readFileSync(SRC, 'utf8');
+
+let failures = 0;
+function ok(name, cond, detail) {
+  if (cond) { console.log('ok   ' + name); return; }
+  failures += 1;
+  console.log('FAIL ' + name + (detail ? ' :: ' + detail : ''));
+}
+
+let captured = null;
+const React = {
+  createElement: (type, props, ...children) => ({ type, props: props || {}, children }),
+  useState: (initial) => [typeof initial === 'function' ? initial() : initial, () => {}],
+  useEffect: () => {},
+  useRef: (initial) => ({ current: initial }),
+  useCallback: (fn) => fn,
+  Fragment: Symbol('Fragment'),
+};
+
+const createdStyles = [];
+const sandbox = {
+  console,
+  AbortController,
+  setTimeout, clearTimeout,
+  Promise,
+  navigator: { language: 'zh-CN' },
+  document: {
+    addEventListener: () => {},
+    removeEventListener: () => {},
+    querySelector: () => null,
+    querySelectorAll: () => [],
+    createElement: () => {
+      const el = { attrs: {}, textContent: '', setAttribute(k, v) { this.attrs[k] = v; }, remove() {} };
+      createdStyles.push(el);
+      return el;
+    },
+    head: { appendChild: () => {} },
+    body: { addEventListener: () => {}, removeEventListener: () => {} },
+  },
+  localStorage: { getItem: () => null, setItem: () => {}, removeItem: () => {} },
+};
+sandbox.window = {
+  __ModuleLoader__: { load(def) { captured = def; } },
+  localStorage: sandbox.localStorage,
+  innerWidth: 1400, innerHeight: 900,
+  addEventListener: () => {}, removeEventListener: () => {},
+};
+vm.createContext(sandbox);
+
+try {
+  vm.runInContext(code, sandbox, { filename: 'client.js' });
+} catch (e) {
+  console.log('FAIL module load :: ' + e.message);
+  process.exit(1);
+}
+
+ok('module registers through __ModuleLoader__', !!captured);
+ok('factory id is the package name', captured && captured.id === 'dsh-assist-chat', captured && captured.id);
+
+const plugin = captured.factory((name) => {
+  if (name === 'react') return React;
+  throw new Error('unexpected require: ' + name);
+});
+
+ok('factory returns a plugin object', !!plugin && typeof plugin.apply === 'function');
+ok('plugin injects slots', Array.isArray(plugin.inject) && plugin.inject[0] === 'slots', JSON.stringify(plugin.inject));
+
+/* ---------- host mocks ---------- */
+const registered = [];
+const tabTypes = [];
+const createdSessions = [];
+const retained = [];
+const released = [];
+
+const sessions = {
+  list: { getSnapshot: () => ({ ids: ['s1'], byId: { s1: { sessionId: 's1', cwd: 'D:/work', updatedAt: 5 } } }) },
+  create: async (opts) => { createdSessions.push(opts); return { ok: true, value: { sessionId: 'side-1' } }; },
+  retain: (id, options) => {
+    const ref = { sessionId: id, options, release: () => released.push(id) };
+    retained.push(ref);
+    return ref;
+  },
+};
+
+const services = {
+  locale: { register() {}, t: (ns, key) => undefined },
+  sessions,
+  sidebarRightTabs: { register(def) { tabTypes.push(def); return () => {}; } },
+  sidebarRight: { openTab: (kind) => { services.sidebarRight.opened = kind; }, close: () => {} },
+  layout: { openRightbar() {}, closeRightbar() {} },
+};
+
+const effectDisposers = [];
+const ctx = {
+  get(key) { return services[key]; },
+  effect(fn) { const d = fn(); effectDisposers.push(d); return () => { if (typeof d === 'function') d(); }; },
+  slots: {
+    inject(slot, cb) { cb(); },
+    register(options, Component) { registered.push({ options, Component }); return () => {}; },
+  },
+};
+
+try {
+  plugin.apply(ctx);
+  ok('apply() completes without throwing', true);
+} catch (e) {
+  ok('apply() completes without throwing', false, e.message + '\n' + e.stack);
+}
+
+const slotIds = registered.map((r) => r.options.name + ':' + (r.options.key || r.options.id || ''));
+console.log('     registered slots: ' + JSON.stringify(slotIds));
+console.log('     tab types: ' + JSON.stringify(tabTypes.map((d) => d.id + '/' + d.kind + '/' + d.priority)));
+
+ok('registers the sidebar tab body keyed by impl id', slotIds.indexOf('sidebar.right.pane.tab:dsh-assist-chat') >= 0);
+ok('registers the sidebar conversation surface', slotIds.indexOf('sidebar.assist.conversation:') >= 0);
+ok('registers the session-header entry', slotIds.indexOf('conversation.session.header.actions:assist-chat-open') >= 0);
+ok('registers exactly one sidebar tab type', tabTypes.length === 1, String(tabTypes.length));
+ok('tab type kind is assistchat', tabTypes[0] && tabTypes[0].kind === 'assistchat', tabTypes[0] && tabTypes[0].kind);
+ok('tab type id is the package name', tabTypes[0] && tabTypes[0].id === 'dsh-assist-chat');
+ok('tab type title is a function', tabTypes[0] && typeof tabTypes[0].title === 'function');
+ok('tab type ships a guide card', !!(tabTypes[0] && Array.isArray(tabTypes[0].guide) && tabTypes[0].guide.length === 1), JSON.stringify(tabTypes[0] && tabTypes[0].guide));
+ok('guide card title is a function', !!(tabTypes[0] && tabTypes[0].guide && typeof tabTypes[0].guide[0].title === 'function'));
+ok('guide card has an icon component', !!(tabTypes[0] && tabTypes[0].guide && typeof tabTypes[0].guide[0].icon === 'function'));
+ok('injects one style element', createdStyles.length === 1, String(createdStyles.length));
+
+/* ---------- components render ---------- */
+function renderEntry(name) {
+  const entry = registered.find((r) => r.options.name === name);
+  if (!entry) return { error: 'not registered' };
+  try {
+    return { tree: entry.Component({}) };
+  } catch (e) {
+    return { error: e.message + '\n' + e.stack };
+  }
+}
+
+const header = renderEntry('conversation.session.header.actions');
+ok('header entry renders', !header.error, header.error);
+ok('header entry is a button', header.tree && header.tree.type === 'button', header.tree && String(header.tree.type));
+
+const tab = renderEntry('sidebar.right.pane.tab');
+ok('tab body renders in the creating phase', !tab.error, tab.error);
+ok('tab body shows a status shell before ready', tab.tree && tab.tree.props && tab.tree.props.className === 'dac-status',
+  tab.tree && JSON.stringify(tab.tree.props));
+
+const convEntry = registered.find((r) => r.options.name === 'sidebar.assist.conversation');
+const conversationProps = {
+  sessionId: 'side-1',
+  useSession: (sel) => sel({ blank: true, running: false, awaitingFirstTurn: false, openState: 'open', promptAttempted: false }),
+  useConversation: (sel) => sel({ activeTargets: new Set() }),
+  useSessions: (sel) => sel({ byId: { 'side-1': { blank: true } } }),
+  renderFactorySlot: (factory, props, extra) => ({ type: 'factory', factory, props, extra }),
+};
+let convTree = null;
+let convError = null;
+try {
+  convTree = convEntry.Component(conversationProps);
+} catch (e) {
+  convError = e.message + '\n' + e.stack;
+}
+ok('conversation surface renders', !convError, convError);
+ok('conversation surface renders the conversation.content factory',
+  convTree && convTree.type === 'factory' && convTree.factory === 'conversation.content',
+  convTree && JSON.stringify({ type: convTree.type, factory: convTree.factory }));
+ok('conversation surface asks for the embedded variant', convTree && convTree.props && convTree.props.variant === 'embedded');
+ok('conversation surface pins the chat view', convTree && convTree.extra && convTree.extra.slots && typeof convTree.extra.slots.views === 'function');
+
+/* ---------- disposal ---------- */
+let disposeError = null;
+try {
+  effectDisposers.forEach((d) => { if (typeof d === 'function') d(); });
+} catch (e) {
+  disposeError = e.message;
+}
+ok('disposal is clean', !disposeError, disposeError);
+
+console.log('');
+if (failures === 0) {
+  console.log('ALL PASS');
+} else {
+  console.log(failures + ' FAILURE(S)');
+  process.exitCode = 1;
+}