@ahggg/dsh-side-chat 0.7.3 → 1.0.0

package/README.md

@@ -8,10 +8,10 @@ Ask a focused follow-up about selected text without leaving your current DeepSee
 
 ## Install
 
-Install DSH 0.1.2-rc.1 if it is not already available. Refresh only this package's registry metadata before adding it, so pnpm cannot reuse an older `latest` value immediately after a release:
+Install DSH 0.2.0-rc.1 if it is not already available. This release is on npm's `next` tag, not `latest`. Refresh only this package's registry metadata before adding it, so pnpm cannot reuse an older `latest` value immediately after a release:
 
 ```powershell
-npm install --global @deepseek-ai/dsh@0.1.2-rc.1
+npm install --global @deepseek-ai/dsh@0.2.0-rc.1
 pnpm cache delete "@ahggg/dsh-side-chat"
 dsh plugin --profile web add @ahggg/dsh-side-chat@latest
 ```
@@ -43,7 +43,7 @@ On phones and tablets, long-press text in a completed message to select it. The
 3. Click `Add to chat` to add an optional comment before attaching the passage to the main composer, `More details` to send an explanation request immediately, or `Ask in side chat` to write a focused question.
 4. When writing your own message or question, press `Enter` to send it.
 5. After a Side Chat reply settles, click `Add to conversation` to attach that focused discussion to the main composer as one conversation reference.
-6. Press `Esc` or click `×` when you are done.
+6. Click `×`, or press `Esc` while focused inside the Side Chat panel, when you are done. Escape in another composer or menu does not close Side Chat.
 
 Useful details:
 
@@ -53,27 +53,30 @@ Useful details:
 - `Add to chat` keeps any existing draft text and can collect multiple numbered passages, each with its own optional comment, in one annotation capsule.
 - `Add to conversation` captures the Side Chat's user/assistant history, preserves the main draft, and refreshes the existing reference instead of duplicating it when clicked again.
 - The input grows with its content and becomes scrollable at its maximum height.
-- While a reply is running, the send icon becomes a stop button.
+- While a reply is running, use Stop to interrupt it; send a follow-up after it finishes or stops. Text entered while a send is pending stays in the composer.
 - Assistant replies use DSH's native Markdown rendering.
 - Hover over `N annotations` to preview every selected passage and its comment.
 - Before sending, hover over the annotation capsule and click `×` to remove it; after sending, the same capsule appears above the user message.
-- The main conversation stays visible and is never switched to the child Session.
+- Your first Side Chat message displays the selected passage as one annotation and your question as plain text, not internal XML.
+- The main conversation stays visible. No child Session is created.
 
 ## What happens to the conversation
 
-The first send creates a real DSH Session fork at the selected message. The child inherits the complete event prefix, presets, and workspace. Its initial model choice uses the last accepted Side Chat choice when one is saved, otherwise it snapshots the parent configuration; later model or reasoning-effort changes apply to subsequent child steps without changing or following the parent conversation. Keeping the prefix unchanged is friendly to provider prompt caching, although a cache hit is never guaranteed.
+`Ask in side chat` and `More details` use direct, streaming model calls through DSH's configured provider. On the first send, the plugin captures a **read-only text snapshot** of the parent conversation through the selected message's completed turn. Later parent prompts are excluded, and this context stays fixed for follow-ups. Opening the draft alone makes no model call.
 
-Closing Side Chat stops active work, archives the child Session, and releases its Agent. It does not delete the child's history from disk. The child and copied prefix therefore consume normal DSH Session storage.
+Side Chat keeps its own temporary message history in memory. It does **not** fork, copy, create, or archive a DSH Session, run an Agent, or write a Session event log. It has **no tools, command execution, or file-editing capability**. Parent reasoning and image/file attachment bytes are omitted; historical tool text is only reference material. The initial model uses the saved Side Chat choice, or the selected parent turn's configuration. Changing it affects only subsequent Side Chat replies.
 
-The parent and child share the same workspace. File changes, commands, and other tool side effects made in Side Chat are real and are not reverted when the panel closes.
+Closing the panel, reloading/disconnecting the client, or unloading the plugin cancels active work and discards the temporary discussion. Host records also expire after 30 minutes idle. To keep a discussion, use **Add to conversation**, then **send the parent draft** to store the reference in the parent history. Adding a reference alone does not send it. References already added to the parent draft are separate from the temporary panel and survive its closure.
+
+The text snapshot and Side Chat history are sent to the model on each request, so normal provider token usage still applies; avoiding Session copies does not eliminate context tokens or guarantee cache reuse. Archived Sessions created by older plugin versions are not automatically deleted.
 
 ## Current limitations
 
 - A selection must stay inside one completed message.
-- Attachments and `/side` are not supported yet.
-- Closed Side Chats cannot be reopened from the panel.
-- There is no automatic history cleanup or “keep as normal chat” action.
-- An archived child may briefly appear in normal Session lists.
+- This is a text-only, read-only discussion, not a second Agent. Attachments, tools, Steer, and `/side` are not supported.
+- Closed or expired discussions cannot be reopened. There is no “keep as normal Session” action.
+- Context is limited to 2,097,152 characters and rejected rather than silently truncated. Each question is limited to 65,536 characters; each reply (including reasoning) to 262,144 characters. A discussion permits at most 64 questions and 2,097,152 question/reply/reasoning characters. Output limits produce an explicit error and keep only the displayed partial reply.
+- Model requests time out after two minutes. Provider-specific context/output limits may be lower.
 
 ## Upgrade or remove
 

package/README.zh-CN.md

@@ -8,10 +8,10 @@
 
 ## 安装
 
-如果尚未安装 DSH 0.1.2-rc.1，先安装它。添加插件前只刷新这个包的 registry metadata，避免刚发布新版本时 pnpm 仍复用旧的 `latest`：
+如果尚未安装 DSH 0.2.0-rc.1，先安装它。该版本对应 npm 的 `next` 标签，而非 `latest`。添加插件前只刷新这个包的 registry metadata，避免刚发布新版本时 pnpm 仍复用旧的 `latest`：
 
 ```powershell
-npm install --global @deepseek-ai/dsh@0.1.2-rc.1
+npm install --global @deepseek-ai/dsh@0.2.0-rc.1
 pnpm cache delete "@ahggg/dsh-side-chat"
 dsh plugin --profile web add @ahggg/dsh-side-chat@latest
 ```
@@ -43,7 +43,7 @@ pnpm build
 3. 点击 `Add to chat` 可以先填写一条可选批注，再把引用加入主会话输入框；点击 `More details` 可以立即发送详细解释请求；点击 `Ask in side chat` 可以自己输入聚焦问题。
 4. 自己输入消息或问题时，按 `Enter` 发送。
 5. Side Chat 回复完成后，点击 `Add to conversation`，即可把这段聚焦讨论作为一个会话引用加入主会话输入框。
-6. 完成后按 `Esc`，或者点击 `×` 关闭。
+6. 完成后点击 `×` 关闭，或者在 Side Chat 面板内聚焦时按 `Esc`。在其他输入框或菜单中按 Escape 不会关闭 Side Chat。
 
 常用操作：
 
@@ -53,27 +53,30 @@ pnpm build
 - `Add to chat` 会保留输入框中已有的草稿，并可把多段带序号的文本及各自的可选批注汇总到同一个 annotation 胶囊中。
 - `Add to conversation` 会捕获 Side Chat 中的用户/助手历史、保留主会话草稿；再次点击时会刷新已有引用，而不是重复添加。
 - 输入框会随内容自动增高，达到最大高度后在内部滚动。
-- 回复生成期间，发送图标会替换为停止按钮。
+- 回复生成期间，可使用 Stop 中断；等回复结束或停止后再发送追问。等待发送结果时新输入的文字会保留在输入框中。
 - Assistant 回复使用 DSH 原生 Markdown 渲染。
 - hover `N annotations` 可以预览每一段所选文本及对应批注。
 - 发送前可以 hover annotation 胶囊并点击 `×` 移除；发送后，同一个胶囊会显示在用户消息上方。
-- 主会话会一直保留在页面中，不会自动切换到 child Session。
+- Side Chat 的首条消息会把选区显示为一个 annotation，问题正文保持纯文本，不显示内部 XML。
+- 主会话会一直保留在页面中，插件不会创建 child Session。
 
 ## 会话和数据如何处理
 
-第一次发送时，插件会在所选消息处创建一个真实的 DSH Session fork。child 会继承完整事件前缀、preset 和 workspace；初始模型优先使用最近一次被接受的 Side Chat 选择，没有已保存选择时才快照主会话配置。之后修改模型或推理等级只会作用于 child 的后续 step，既不会修改主会话，也不会继续跟随主会话切换。保持前缀不变有利于供应商的 prompt cache 复用，但不保证一定命中缓存。
+`Ask in side chat` 和 `More details` 直接通过 DSH 配置的 provider 发起流式模型调用。第一次发送时，插件读取主会话截至所选消息所在轮次结束的**只读文本快照**，不包含后续主会话问题。此后追问一直使用这份固定上下文。仅打开草稿不会调用模型。
 
-关闭 Side Chat 时，插件会停止正在运行的任务、归档 child Session，并释放其 Agent；不会删除 child 的磁盘历史。因此，child 和复制的完整前缀会占用正常的 DSH Session 存储空间。
+Side Chat 只在内存中保留独立的临时讨论历史，**不会 fork、复制、创建或归档 DSH Session，也不会启动 Agent 或写入 Session 事件日志**。它**没有工具调用、命令执行和文件修改能力**。主会话的推理内容以及图片、文件附件的字节不会传入；过去的工具文本仅作为参考资料。初始模型优先使用已保存的 Side Chat 选择，否则使用所选父会话轮次的配置；之后切换模型只影响 Side Chat 的后续回复。
 
-父会话与 child 共享同一个 workspace。Side Chat 中产生的文件修改、命令执行及其他工具副作用都是真实的，关闭面板不会撤销它们。
+关闭面板、刷新或断开客户端、卸载插件时，会取消正在运行的请求并丢弃临时讨论。Host 记录闲置 30 分钟后也会过期。如果希望保留讨论，请点击 **Add to conversation**，然后**发送主会话草稿**，将引用存入主会话历史。只添加引用不会自动发送；已经添加到主会话草稿的引用独立于临时面板，不会随面板关闭而删除。
+
+每次调用模型仍会发送文本快照和 Side Chat 历史，因此仍产生正常的 provider token 用量；不复制 Session 不代表不消耗上下文 token，也不保证缓存复用。旧版插件创建的归档 Session 不会自动删除。
 
 ## 当前限制
 
 - 选区必须位于同一条已完成消息内。
-- 暂不支持附件和 `/side`。
-- 关闭后不能从面板重新打开原 Side Chat。
-- 暂无自动历史清理或“保留为普通会话”操作。
-- 已归档的 child 可能短暂出现在普通会话列表中。
+- 这是纯文本只读讨论，不是另一个 Agent；不支持附件、工具、Steer 和 `/side`。
+- 关闭或过期后不能重新打开，也没有“保留为普通 Session”操作。
+- 父上下文上限为 2,097,152 个字符，超过时明确拒绝而不会静默截断。每条问题上限为 65,536 个字符，每次回复（含推理）上限为 262,144 个字符；每次讨论最多 64 条问题，问题、回复和推理合计最多 2,097,152 个字符。达到输出上限会明确报错，仅保留已经显示的部分回复。
+- 单次模型请求两分钟后超时；provider 自身的上下文或输出限制可能更低。
 
 ## 升级或卸载
 

package/lib/client/apply.js

@@ -4,40 +4,56 @@ import { selectionReferenceSource } from './parent-composer/add-to-conversation.
 import { mountParentConversationAnnotations } from './parent-composer/ParentConversationAnnotations.js';
 import { sideChatConversationReferenceSource } from './parent-composer/referenced-conversation.js';
 import { SideChatController } from './side-chat-controller.js';
-import { mountArchivedRemote } from './rc6/remote-adapter.js';
-import { Rc6SideChatOverlay } from './rc6/Rc6SideChatOverlay.js';
-import { Rc6SideChatSessions } from './rc6/sessions-adapter.js';
+import { mountSideChatRemote } from './dsh/remote-adapter.js';
+import { SideChatOverlay } from './dsh/SideChatOverlay.js';
+import { DshSideChatSessions } from './dsh/sessions-adapter.js';
 export const name = 'side-chat-client';
-export const inject = ['conversation', 'inputTriggers', 'modelDirectories', 'remote', 'sessions', 'slots'];
+export const inject = ['conversation', 'inputTriggers', 'modelDirectories', 'remote', 'sessions', 'slots', 'uiConversation', 'uiWorkspace'];
 export async function apply(ctx) {
-    const stylesheet = document.createElement('style');
-    stylesheet.textContent = sideChatCss;
-    stylesheet.dataset.plugin = 'dsh-side-chat';
-    stylesheet.dataset['dshSideChat'] = 'styles';
-    document.head.append(stylesheet);
-    const clientCtx = ctx;
-    const mounted = await mountArchivedRemote(clientCtx);
-    const removeSelectionReferenceSource = clientCtx.inputTriggers.registerSource(selectionReferenceSource);
-    const removeConversationReferenceSource = clientCtx.inputTriggers.registerSource(sideChatConversationReferenceSource);
-    const sessions = new Rc6SideChatSessions(clientCtx);
-    const removeParentAnnotations = mountParentConversationAnnotations(clientCtx, () => { sessions.removeConversationAnnotations(); });
-    const controller = new SideChatController(mounted.remote, sessions);
-    const removeOverlay = clientCtx.slots.inject('shell.overlay', () => clientCtx.slots.register({
-        name: 'shell.overlay',
-        id: 'dsh-side-chat',
-        order: 90,
-    }, () => createElement(Rc6SideChatOverlay, { controller, sessions })));
-    ctx.effect(() => async () => {
-        try {
-            await controller.dispose();
-        }
-        finally {
-            removeParentAnnotations();
-            removeConversationReferenceSource();
-            removeSelectionReferenceSource();
-            removeOverlay();
+    const cleanups = [];
+    let disposed = false;
+    let cleanupOperation;
+    const cleanup = () => {
+        disposed = true;
+        cleanupOperation ??= (async () => {
+            for (const dispose of cleanups.splice(0).reverse()) {
+                try {
+                    await dispose();
+                }
+                catch (error) {
+                    console.warn('[dsh-side-chat] Cleanup failed', error);
+                }
+            }
+        })();
+        return cleanupOperation;
+    };
+    ctx.effect(() => cleanup, 'dsh-side-chat.clientLifecycle');
+    try {
+        const stylesheet = document.createElement('style');
+        stylesheet.textContent = sideChatCss;
+        stylesheet.dataset.plugin = 'dsh-side-chat';
+        stylesheet.dataset['dshSideChat'] = 'styles';
+        document.head.append(stylesheet);
+        cleanups.push(() => { stylesheet.remove(); });
+        const clientCtx = ctx;
+        const mounted = await mountSideChatRemote(clientCtx);
+        if (disposed) {
             await mounted.dispose();
-            stylesheet.remove();
+            return;
         }
-    }, 'dsh-side-chat.clientLifecycle');
+        cleanups.push(mounted.dispose);
+        cleanups.push(clientCtx.inputTriggers.registerSource(selectionReferenceSource));
+        cleanups.push(clientCtx.inputTriggers.registerSource(sideChatConversationReferenceSource));
+        const sessions = new DshSideChatSessions(clientCtx);
+        cleanups.push(mountParentConversationAnnotations(clientCtx, sessionId => { sessions.removeConversationAnnotations(sessionId); }));
+        const controller = new SideChatController(mounted.remote, sessions);
+        cleanups.push(() => controller.dispose());
+        cleanups.push(clientCtx.slots.inject('shell.overlay', () => clientCtx.slots.register({
+            name: 'shell.overlay', id: 'dsh-side-chat', order: 90,
+        }, () => createElement(SideChatOverlay, { controller, sessions }))));
+    }
+    catch (error) {
+        await cleanup();
+        throw error;
+    }
 }

package/lib/client/contracts.d.ts

@@ -1,67 +1,12 @@
-import type { ConversationSelection, SessionId, SideChatModelSelection, SideChatPromptPart, SideChatWireError } from '../shared/contracts.js';
-import type { HostObservable } from '../shared/observable.js';
-export interface SideChatSessionSnapshot {
-    readonly status: 'idle' | 'running' | 'needs-input' | 'needs-approval' | 'failed' | 'interrupted';
-}
-export interface SideChatQuestionAnswer {
-    readonly answers: readonly {
-        readonly id: string;
-        readonly selected: readonly string[];
-        readonly custom?: string;
-    }[];
-}
-export interface SideChatSessionBinding extends HostObservable<SideChatSessionSnapshot> {
-    readonly sessionId: SessionId;
-    prompt(content: readonly SideChatPromptPart[], mode: 'queue' | 'steer'): Promise<{
-        readonly ok: true;
-    } | {
-        readonly ok: false;
-        readonly error: SideChatWireError;
-    }>;
-    updateQueue(itemId: string, action: {
-        readonly kind: 'edit';
-        readonly content: readonly SideChatPromptPart[];
-    } | {
-        readonly kind: 'remove';
-    } | {
-        readonly kind: 'steer';
-    }): Promise<{
-        readonly ok: true;
-    } | {
-        readonly ok: false;
-        readonly error: SideChatWireError;
-    }>;
-    cancel(): Promise<{
-        readonly ok: true;
-    } | {
-        readonly ok: false;
-        readonly error: SideChatWireError;
-    }>;
-    respondApproval(interactionId: string, decision: 'approve' | 'decline'): Promise<{
-        readonly ok: true;
-    } | {
-        readonly ok: false;
-        readonly error: SideChatWireError;
-    }>;
-    respondQuestion(interactionId: string, answer: SideChatQuestionAnswer | null): Promise<{
-        readonly ok: true;
-    } | {
-        readonly ok: false;
-        readonly error: SideChatWireError;
-    }>;
-}
-export interface SideChatSessionLease {
-    readonly sessionId: SessionId;
-    readonly binding: SideChatSessionBinding;
-    release(): void;
-}
+import type { ConversationSelection, SessionId, SideChatModelSelection, SideChatWireError } from '../shared/contracts.js';
+/** Parent-only DSH integration. Side discussions never retain a child Session. */
 export interface SideChatClientSessions {
     currentSessionId(): SessionId | undefined;
     lastCompletedSeq(parentSessionId: SessionId): number | undefined;
     selectionIsCurrent(selection: ConversationSelection): boolean;
     sideChatModelPreference(): SideChatModelSelection | undefined;
     rememberSideChatModelPreference(selection: SideChatModelSelection): void;
-    retain(sessionId: SessionId): Promise<SideChatSessionLease>;
+    retainParent(sessionId: SessionId): () => void;
     openSession(sessionId: SessionId): Promise<void>;
     notify(message: {
         readonly kind: 'status' | 'warning';

package/lib/client/dsh/ReadOnlyConversation.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from 'react';
+import type { SideChatState } from '../../shared/contracts.js';
+import type { SideChatController } from '../side-chat-controller.js';
+/** The UI renders structured plugin messages, never model-facing prompt serialization. */
+export declare function ReadOnlyConversation({ state, controller, modelControl, locale }: {
+    readonly state: SideChatState;
+    readonly controller: SideChatController;
+    readonly modelControl?: ReactNode;
+    readonly locale?: 'en' | 'zh-CN';
+}): import("react/jsx-runtime").JSX.Element;

package/lib/client/dsh/ReadOnlyConversation.js

@@ -0,0 +1,91 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { DisclosureRow, IconThinkOutlineRegular, MarkdownText } from '@deepseek-ai/dsh-client-ui-primitives';
+import { SelectionQuote } from '../panel/SelectionQuote.js';
+import { SIDE_CHAT_MESSAGES } from '../panel/messages.js';
+import { SendIcon } from '../panel/SendIcon.js';
+import { StopIcon } from '../panel/StopIcon.js';
+import { useAutoGrowingTextarea } from '../panel/use-auto-growing-textarea.js';
+import { MARKDOWN_LABELS } from './primitive-labels.js';
+function Reasoning({ text, running }) {
+    const [expanded, setExpanded] = useState(false);
+    const lines = text.trimEnd().split('\n');
+    return _jsx("div", { className: "dsh-side-chat-reasoning", "data-variant": "think", "data-state": running ? 'running' : 'ok', children: _jsx(DisclosureRow, { rowClassName: "dsh-side-chat-reasoning-row", leadingClassName: "dsh-side-chat-reasoning-leading", titleClassName: "dsh-side-chat-reasoning-title", chevronClassName: "dsh-side-chat-reasoning-chevron", icon: _jsx(IconThinkOutlineRegular, { size: 14 }), title: "Think", open: expanded, expandable: true, expandOnRowClick: true, onToggle: () => { setExpanded(value => !value); }, collapsedContent: _jsx("span", { className: "dsh-side-chat-reasoning-summary", children: running ? lines.at(-1) : lines[0] }), children: _jsx("div", { className: "dsh-side-chat-reasoning-body", children: text }) }) });
+}
+function Message({ message, locale }) {
+    const bubble = _jsxs("article", { className: "dsh-side-chat-message", "data-role": message.role, children: [_jsx("span", { className: "dsh-side-chat-message-role", children: message.role === 'user' ? 'You' : 'Assistant' }), message.role === 'user'
+                ? _jsx("div", { className: "dsh-side-chat-message-text", children: message.text })
+                : _jsxs(_Fragment, { children: [message.reasoning && _jsx(Reasoning, { text: message.reasoning, running: message.status === 'streaming' }), _jsx(MarkdownText, { text: message.text, streaming: message.status === 'streaming', labels: MARKDOWN_LABELS }), message.status === 'streaming' && message.text === '' && !message.reasoning && _jsx("span", { children: "Thinking\u2026" }), message.status === 'stopped' && _jsx("span", { className: "dsh-side-chat-message-note", children: "Stopped" }), message.status === 'error' && _jsx("span", { className: "dsh-side-chat-message-note", children: "Reply failed" })] })] });
+    return message.selectedText === undefined ? bubble : _jsxs("div", { className: "dsh-side-chat-annotated-user-message", children: [_jsx(SelectionQuote, { selections: [{ text: message.selectedText }], messages: SIDE_CHAT_MESSAGES[locale] }), bubble] });
+}
+/** The UI renders structured plugin messages, never model-facing prompt serialization. */
+export function ReadOnlyConversation({ state, controller, modelControl, locale = 'en' }) {
+    const [draft, setDraft] = useState('');
+    const [sending, setSending] = useState(false);
+    const [stopping, setStopping] = useState(false);
+    const [actionError, setActionError] = useState();
+    const sendingRef = useRef(false);
+    const stoppingRef = useRef(false);
+    const revision = useRef(0);
+    const follow = useRef(true);
+    const scrollRef = useRef(null);
+    const inputRef = useAutoGrowingTextarea(draft);
+    const running = state.phase === 'running';
+    const interactive = ['ready', 'running'].includes(state.phase);
+    useEffect(() => {
+        const element = scrollRef.current;
+        if (element !== null && follow.current)
+            element.scrollTop = element.scrollHeight;
+    }, [state.messages]);
+    const submit = async (event) => {
+        event.preventDefault();
+        if (draft.trim().length === 0 || !interactive || running || sendingRef.current || stoppingRef.current)
+            return;
+        const before = revision.current;
+        sendingRef.current = true;
+        setSending(true);
+        setActionError(undefined);
+        try {
+            const result = await controller.send(draft);
+            if (result.ok && before === revision.current)
+                setDraft('');
+            else if (!result.ok && controller.getSnapshot().error?.message !== result.error.message)
+                setActionError(result.error.message);
+        }
+        catch {
+            setActionError('The message could not be sent. Your draft has been kept.');
+        }
+        finally {
+            sendingRef.current = false;
+            setSending(false);
+        }
+    };
+    const stop = async () => {
+        if (stoppingRef.current)
+            return;
+        stoppingRef.current = true;
+        setStopping(true);
+        setActionError(undefined);
+        try {
+            const result = await controller.cancel();
+            if (!result.ok)
+                setActionError(result.error.message);
+        }
+        catch {
+            setActionError('The request could not be stopped. Try closing Side Chat.');
+        }
+        finally {
+            stoppingRef.current = false;
+            setStopping(false);
+        }
+    };
+    return _jsxs("div", { className: "dsh-side-chat-conversation", children: [_jsxs("div", { ref: scrollRef, className: "dsh-side-chat-transcript", "aria-live": "polite", onScroll: event => {
+                    const element = event.currentTarget;
+                    follow.current = element.scrollHeight - element.scrollTop - element.clientHeight < 48;
+                }, children: [state.messages.map(message => _jsx(Message, { message: message, locale: locale }, message.id)), actionError !== undefined && _jsx("div", { className: "dsh-side-chat-turn-notice", role: "alert", children: actionError })] }), _jsxs("form", { className: "dsh-side-chat-composer", "data-composer-card": "", onSubmit: event => { void submit(event); }, children: [_jsx("textarea", { ref: inputRef, rows: 1, value: draft, disabled: !interactive, placeholder: "Reply in Side Chat", onChange: event => { ++revision.current; setDraft(event.target.value); }, onKeyDown: event => {
+                            if (event.key === 'Enter' && !event.shiftKey && !event.nativeEvent.isComposing && event.keyCode !== 229) {
+                                event.preventDefault();
+                                event.currentTarget.form?.requestSubmit();
+                            }
+                        } }), _jsxs("div", { className: "dsh-side-chat-composer-actions", children: [modelControl, running && _jsx("button", { type: "button", className: "dsh-side-chat-stop-button", "aria-label": "Stop generating", disabled: !interactive || stopping, onClick: () => { void stop(); }, children: _jsx(StopIcon, {}) }), _jsx("button", { type: "submit", className: "dsh-side-chat-send-button", "aria-label": "Send", disabled: !interactive || running || sending || stopping || draft.trim().length === 0, children: _jsx(SendIcon, {}) })] })] })] });
+}

package/lib/client/dsh/SideChatOverlay.d.ts

@@ -0,0 +1,7 @@
+import type { SideChatController } from '../side-chat-controller.js';
+import { DshSideChatSessions } from './sessions-adapter.js';
+/** Selection toolbar and plugin-owned read-only discussion panel. */
+export declare function SideChatOverlay({ controller, sessions, }: {
+    readonly controller: SideChatController;
+    readonly sessions: DshSideChatSessions;
+}): import("react/jsx-runtime").JSX.Element;

package/lib/client/{rc6/Rc6SideChatOverlay.js → dsh/SideChatOverlay.js}

@@ -7,8 +7,9 @@ import { SideChatPanel } from '../panel/SideChatPanel.js';
 import { ConversationAnnotationMarkers } from '../selection/ConversationAnnotationMarkers.js';
 import { captureDomConversationSelection } from '../selection/selection-controller.js';
 import { SelectionActions } from '../selection/SelectionActions.js';
-import { ArchivedConversation } from './ArchivedConversation.js';
-import { Rc6SideChatSessions, selectionDescriptor } from './sessions-adapter.js';
+import { conversationChatRoot, focusConversationComposer } from '../selection/conversation-dom.js';
+import { ReadOnlyConversation } from './ReadOnlyConversation.js';
+import { DshSideChatSessions, selectionDescriptor } from './sessions-adapter.js';
 const MORE_DETAILS_PROMPT = 'Please explain the selected passage in more detail.';
 const TOUCH_SELECTION_SETTLE_MS = 300;
 const TOUCH_ACTIVATION_SUPPRESS_MS = 750;
@@ -24,28 +25,8 @@ function captureEvent(event) {
             '.dsh-side-chat-annotation-marker',
         ].join(', ')) !== null);
 }
-function focusParentComposer() {
-    const input = document.querySelector([
-        '[data-composer-seat] textarea',
-        '[data-composer-seat] [role="textbox"]',
-        '[data-composer-seat] [contenteditable="true"]',
-    ].join(', '));
-    if (input === null)
-        return;
-    input.focus();
-    if (input instanceof HTMLTextAreaElement) {
-        input.setSelectionRange(input.value.length, input.value.length);
-        return;
-    }
-    const range = document.createRange();
-    range.selectNodeContents(input);
-    range.collapse(false);
-    const selection = window.getSelection();
-    selection?.removeAllRanges();
-    selection?.addRange(range);
-}
-/** rc.6 compatibility surface: selection toolbar plus a non-current child conversation panel. */
-export function Rc6SideChatOverlay({ controller, sessions, }) {
+/** Selection toolbar and plugin-owned read-only discussion panel. */
+export function SideChatOverlay({ controller, sessions, }) {
     const state = useSyncExternalStore(controller.subscribe, controller.getSnapshot, controller.getSnapshot);
     const currentSessionId = useSyncExternalStore(sessions.subscribeList, () => sessions.currentSessionId(), () => sessions.currentSessionId());
     const composerInput = useSyncExternalStore(sessions.subscribeConversationInput, sessions.currentConversationInputSnapshot, sessions.currentConversationInputSnapshot);
@@ -62,11 +43,11 @@ export function Rc6SideChatOverlay({ controller, sessions, }) {
         const generation = ++captureGeneration.current;
         const parentSessionId = sessions.currentSessionId();
         const face = parentSessionId === undefined ? undefined : sessions.face(parentSessionId);
-        const conversationRoot = document.querySelector('[data-chat-flow]');
+        const conversationRoot = parentSessionId === undefined ? undefined : conversationChatRoot(parentSessionId);
         const browserSelection = window.getSelection();
         if (parentSessionId === undefined
             || face === undefined
-            || conversationRoot === null
+            || conversationRoot === undefined
             || browserSelection === null
             || browserSelection.isCollapsed) {
             if (generation === captureGeneration.current)
@@ -86,7 +67,7 @@ export function Rc6SideChatOverlay({ controller, sessions, }) {
                     },
                 },
             });
-            if (generation === captureGeneration.current) {
+            if (generation === captureGeneration.current && sessions.currentSessionId() === parentSessionId) {
                 setActiveSelection({ value: captured, touch });
             }
         }
@@ -193,11 +174,13 @@ export function Rc6SideChatOverlay({ controller, sessions, }) {
             touchInteraction.current = false;
             cancelScheduledCapture();
             if (event.key === 'Escape') {
+                // Escape in a menu, annotation editor, or main composer belongs to
+                // that control. Closing discards the temporary discussion, so it must
+                // not fire from every keyup in the document.
                 ++captureGeneration.current;
                 annotationEditing.current = false;
                 setActiveSelection(null);
                 setEditingAnnotation(null);
-                void controller.close();
                 return;
             }
             if (captureEvent(event))
@@ -253,34 +236,25 @@ export function Rc6SideChatOverlay({ controller, sessions, }) {
     const askDisabledReason = state.phase === 'closed'
         ? undefined
         : 'Close the current Side Chat before starting another one.';
-    const childFace = state.childSessionId === undefined ? undefined : sessions.face(state.childSessionId);
-    const childCwd = state.childSessionId === undefined ? undefined : sessions.cwd(state.childSessionId);
-    const inheritedThroughSeq = state.inheritedThroughSeq;
     const locale = navigator.language.toLowerCase().startsWith('zh') ? 'zh-CN' : 'en';
     const modelDirectory = state.parentSessionId === undefined
         ? undefined
         : sessions.modelDirectory?.(state.parentSessionId);
-    const addToConversationDisabled = childFace === undefined
-        || inheritedThroughSeq === undefined
-        || state.parentSessionId === undefined
-        || state.childSessionId === undefined
-        || state.phase !== 'ready';
+    const addToConversationDisabled = state.parentSessionId === undefined
+        || state.chatId === undefined || state.phase !== 'ready'
+        || !state.messages.some(message => message.role === 'assistant' && message.text.trim().length > 0);
     const addToConversation = () => {
         const parentSessionId = state.parentSessionId;
-        const childSessionId = state.childSessionId;
-        const face = childSessionId === undefined ? undefined : sessions.face(childSessionId);
-        if (parentSessionId === undefined
-            || childSessionId === undefined
-            || inheritedThroughSeq === undefined
-            || face === undefined) {
+        const chatId = state.chatId;
+        if (parentSessionId === undefined || chatId === undefined || state.phase !== 'ready') {
             sessions.notify({ kind: 'warning', text: 'The Side Chat conversation is not ready to add yet.' });
             return;
         }
+        const parentTitle = sessions.title(parentSessionId);
         const reference = referencedSideChatConversation({
-            conversationId: childSessionId,
-            title: sessions.title(childSessionId) ?? (locale === 'zh-CN' ? '侧边对话' : 'Side Chat'),
-            nodes: face.getSnapshot().nodes,
-            inheritedThroughSeq,
+            conversationId: chatId,
+            title: [locale === 'zh-CN' ? '侧边对话' : 'Side Chat', parentTitle].filter(Boolean).join(' · '),
+            messages: state.messages,
         });
         if (reference.conversation.length === 0) {
             sessions.notify({ kind: 'warning', text: 'The Side Chat does not have any conversation history to add yet.' });
@@ -291,7 +265,7 @@ export function Rc6SideChatOverlay({ controller, sessions, }) {
                 sessions.notify({ kind: 'warning', text: 'Could not add the Side Chat to the main conversation.' });
                 return;
             }
-            void sessions.openSession(parentSessionId).then(focusParentComposer, () => {
+            void sessions.openSession(parentSessionId).then(() => focusConversationComposer(parentSessionId), () => {
                 sessions.notify({ kind: 'warning', text: 'The Side Chat was added, but its parent conversation could not be opened.' });
             });
         }
@@ -301,12 +275,12 @@ export function Rc6SideChatOverlay({ controller, sessions, }) {
     };
     const modelControl = modelDirectory === undefined
         ? undefined
-        : (_jsx(SideChatModelSelect, { directory: modelDirectory, selection: state.modelSelection, locked: ['creating', 'opening', 'closing'].includes(state.phase) || state.error?.operation === 'close', validateInitialSelection: state.childSessionId === undefined, locale: locale, onInitialize: (selection, options) => {
+        : (_jsx(SideChatModelSelect, { directory: modelDirectory, selection: state.modelSelection, locked: ['creating', 'running', 'closing'].includes(state.phase) || state.error?.operation === 'close', validateInitialSelection: state.chatId === undefined, locale: locale, onInitialize: (selection, options) => {
                 if (options.remember)
                     void controller.selectModel(selection);
                 else
                     controller.initializeModel(selection);
-            }, onSelect: (selection) => controller.selectModel(selection) }, `${state.parentSessionId}:${state.childSessionId ?? 'draft'}`));
+            }, onSelect: (selection) => controller.selectModel(selection) }, `${state.parentSessionId}:${state.chatId ?? 'draft'}`));
     return (_jsxs("div", { className: "dsh-side-chat-overlay", children: [_jsx(ConversationAnnotationMarkers, { annotations: annotations, ...editingAnnotation === null
                     ? {}
                     : { activeAnnotationIndex: editingAnnotation.annotationIndex }, onEdit: (annotation, restoredSelection) => {
@@ -318,7 +292,7 @@ export function Rc6SideChatOverlay({ controller, sessions, }) {
                 } }), activeSelection !== null && (_jsx(SelectionActions, { selection: activeSelection.value, touchInteraction: activeSelection.touch, annotationNumber: sessions.nextConversationAnnotationNumber(), ...askDisabledReason === undefined ? {} : { askDisabledReason }, onAddToChat: (captured, comment) => {
                     try {
                         if (sessions.addSelectionToConversation(captured, comment))
-                            focusParentComposer();
+                            focusConversationComposer(captured.parentSessionId);
                         else
                             sessions.notify({ kind: 'warning', text: 'Could not add the selection to the current chat.' });
                     }
@@ -373,12 +347,8 @@ export function Rc6SideChatOverlay({ controller, sessions, }) {
                 }, onMoreDetails: () => { }, onAskInSideChat: () => { }, onDismiss: () => {
                     annotationEditing.current = false;
                     setEditingAnnotation(null);
-                } }, `annotation:${String(editingAnnotation.annotationIndex)}`)), state.phase !== 'closed' && (_jsx(SideChatPanel, { state: state, locale: locale, ...childFace === undefined || inheritedThroughSeq === undefined
-                    ? {}
-                    : {
-                        embeddedConversation: (_jsx(ArchivedConversation, { face: childFace, inheritedThroughSeq: inheritedThroughSeq, controller: controller, cwd: childCwd, ...state.selection === undefined ? {} : { selection: state.selection }, locale: locale, modelControl: modelControl })),
-                    }, modelControl: modelControl, onDraftChange: (draft) => { controller.setDraft(draft); }, onFirstSend: (question) => controller.sendFirst(question), onClose: () => controller.close(), onRetry: () => controller.retry(), onFocusParent: () => {
+                } }, `annotation:${String(editingAnnotation.annotationIndex)}`)), state.phase !== 'closed' && (_jsx(SideChatPanel, { state: state, locale: locale, embeddedConversation: _jsx(ReadOnlyConversation, { state: state, controller: controller, locale: locale, modelControl: modelControl }, state.chatId), modelControl: modelControl, onDraftChange: (draft) => { controller.setDraft(draft); }, onFirstSend: (question) => controller.sendFirst(question), onClose: () => controller.close(), onRetry: () => controller.retry(), onFocusParent: () => {
                     if (state.parentSessionId !== undefined)
                         void sessions.openSession(state.parentSessionId);
-                }, onAddToConversation: addToConversation, addToConversationDisabled: addToConversationDisabled, onRemoveSelection: () => { controller.clearSelection(); } }))] }));
+                }, onAddToConversation: addToConversation, addToConversationDisabled: addToConversationDisabled, ...state.chatId === undefined ? { onRemoveSelection: () => { controller.clearSelection(); } } : {} }))] }));
 }

package/lib/client/{rc6 → dsh}/context.d.ts

@@ -4,10 +4,10 @@ import type { ISessions } from '@deepseek-ai/dsh-api-session-controller/client';
 import type { UiConversation } from '@deepseek-ai/dsh-client-ui-conversation/client';
 import type { ModelDirectoryResolver } from '@deepseek-ai/dsh-client-ui-model-selection/client';
 import type { SlotRegistry } from '@deepseek-ai/dsh-client-ui-renderer/client';
-import type { UiSession } from '@deepseek-ai/dsh-client-ui-session/client';
+import type { UiWorkspace } from '@deepseek-ai/dsh-client-ui-workspace/client';
 import type { ParentConversationService, SelectionReferenceSource } from '../parent-composer/add-to-conversation.js';
 /** Browser-only Cordis view for a package that also compiles the Host half. */
-export type Rc6ClientContext = Omit<Context, 'conversation' | 'inputTriggers' | 'modelDirectories' | 'remote' | 'sessions' | 'slots' | 'uiConversation' | 'uiSession'> & {
+export type DshClientContext = Omit<Context, 'conversation' | 'inputTriggers' | 'modelDirectories' | 'remote' | 'sessions' | 'slots' | 'uiConversation' | 'uiWorkspace'> & {
     readonly conversation: ParentConversationService;
     readonly inputTriggers: {
         registerSource(source: SelectionReferenceSource): () => void;
@@ -16,8 +16,6 @@ export type Rc6ClientContext = Omit<Context, 'conversation' | 'inputTriggers' |
     readonly remote: ClientRemote;
     readonly sessions: ISessions;
     readonly slots: SlotRegistry;
-    /** Added by DSH 0.1.2; absent on the monolithic 0.1.0/0.1.1 runtime. */
-    readonly uiConversation?: Pick<UiConversation, 'binding'>;
-    /** Added by DSH 0.1.2; absent on the monolithic 0.1.0/0.1.1 runtime. */
-    readonly uiSession?: Pick<UiSession, 'pendingInteractions'>;
+    readonly uiWorkspace: UiWorkspace;
+    readonly uiConversation: Pick<UiConversation, 'binding'>;
 };