@qilin-agent/client-ui-sidechat 0.0.0-stage → 3.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kkutysllb
+
+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.i18n.yaml

@@ -0,0 +1,34 @@
+# Bilingual-pair consistency record for README.md (docs/i18n/README.md): per heading
+# section, a hash of its English and Chinese blocks outside code blocks and generated regions.
+# After editing either side, bring the other along and re-record with:
+#   pnpm run verify-translation-pairing --write packages/client/ui-sidechat/README.md
+/:
+  en: 13b9891fdae386a6
+  zh: 29b2b488971ae2d6
+/qilin-client-ui-sidechat:
+  en: cecb3667f224db3e
+  zh: a13ad6f7b8d5a793
+/qilin-client-ui-sidechat/summary:
+  en: be7936e38dba9d2a
+  zh: b1c5bf1865ae8e46
+/qilin-client-ui-sidechat/table-of-contents:
+  en: a7b1bcef44d01a5e
+  zh: ca90e1fd026996cb
+/qilin-client-ui-sidechat/what-it-registers:
+  en: 2c7f87227236d463
+  zh: ac7e2b8894279298
+/qilin-client-ui-sidechat/the-panel:
+  en: b488b91003dc65f8
+  zh: ddc092565e682419
+/qilin-client-ui-sidechat/model-experience:
+  en: 4eb476dcc206f704
+  zh: 56eb09607ced8476
+/qilin-client-ui-sidechat/model-experience/kv-cache-effect:
+  en: 21a0d6e4e39c5f40
+  zh: 870dfff007e94c1b
+/qilin-client-ui-sidechat/known-limitations-and-deferred-work:
+  en: 26b497ace8ab3846
+  zh: 10f28c06762c5f86
+/qilin-client-ui-sidechat/known-limitations-and-deferred-work/dev-note:
+  en: 4b7fde33e0cea000
+  zh: 84f5a8341b6b7311

package/README.md

@@ -1,3 +1,67 @@
-# Temporary Holding Version
+---
+description: "The right Sidebar's sidechat page for the qilin web client: the session's side threads, each thread's own transcript, and the composer that drives them, read back over the thread follow streams."
+kind: "package-reference"
+---
 
-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.
+# @qilin-agent/client-ui-sidechat
+
+English | [中文](README.zh.md)
+
+## Summary
+
+The right Sidebar's sidechat page: one column listing the current Session's side threads and one pane showing the open thread's own transcript with a composer. It is a page type that claims no address, opened by kind alone. The roster and transcripts are the panel's own reads — the six Session Controller `sidechat*` remotes plus `session.follow` on each thread's subagent address — and every action travels through those remotes. Nothing in `ui-sidebar-right` knows this package.
+
+## Table of Contents
+
+- [What it registers](#what-it-registers)
+- [The panel](#the-panel)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+<a id="what-it-registers"></a>
+## What it registers
+
+- **The type** — `ctx.sidebarRightTabs.register(...)` with kind `sidechat`, id `@qilin-agent/client-ui-sidechat`, band `builtin`, `single`, and no patterns; `ctx.sidebarRight.openTab('sidechat')` opens it.
+- **The body** — the keyed `sidebar.right.pane.tab` seat under that id, injecting the panel's state source through the `hooks` compartment and the actions through the inject face.
+
+Nine source files under `src/client/`: `definition.tsx` (the type), `sidechat-model.ts` (the pure view model: the follow address and the transcript fold), `sidechat-source.ts` (the object-layer state source), `face.ts` (the actions and their Remote binding), `SidechatBody.tsx` and `SidechatBody.module.css` (what is drawn), `locales.ts` (what it says), and `index.ts` (the wiring).
+
+<a id="the-panel"></a>
+## The panel
+
+**The roster** reads `session/sidechatThreads` for the Session the pane is open on, oldest first. Each row shows the thread's durable label and its live or running state; a row click opens that thread's transcript.
+
+**The transcript** follows the open thread through `session.follow` on its subagent address (`continuable` child of the current Session). The opening snapshot replays the thread's own events — user messages, the inheritance boundary, and assistant replies — and committed frames append as they arrive. The inherited parent prefix never appears: it is reference context on the Host, not part of the thread's own log slice.
+
+**The composer** sends its draft as a sidechat prompt (`session/sidechatPrompt`), Enter to send. A running thread offers cancel (`session/sidechatCancel`); a live idle thread offers release (`session/sidechatRelease`); the rail's button forks a new thread (`session/sidechatStart`), optionally naming it from a first question.
+
+<a id="model-experience"></a>
+## Model Experience
+
+None, as this package draws Session-side threads in the browser and registers nothing model-facing. The thread's model requests belong to the thread's own Session on the Host.
+
+#### KV Cache effect
+
+None; the panel issues no model request and adds no tokens to any prompt. Its reads are durable-event folds over follow streams the Session Remote already serves.
+
+## Known Limitations and Deferred Work
+
+<a id="known-limitations-and-deferred-work"></a>
+
+- **One tab per surface.** The page carries one in-panel thread list where the upstream coding-sidebar SideChat seats one tab per thread: switching threads replaces the open transcript, and two threads cannot be read side by side.
+- **Host-owned thread identity.** Threads are identified by the Host's sidechat descriptor (provider `sidechat`, mode `continuable`), not an upstream title-prefix convention, so labels follow the Host's `Side: …` labeling rather than any client-side prefix rule.
+- **Durable events only.** The follow requests the assistant stream baseline, but the panel draws no stream frames — assistant text appears when its durable `assistant/message` event commits.
+- **Current Session only.** The panel attaches to the Session it is open on and cannot browse a sidechat workspace attachment, because sidechat threads carry none.
+
+<a id="dev-note"></a>
+### Dev Note
+
+<details>
+<summary>Working context for maintainers — click to expand</summary>
+
+The state source is registration-scoped object layer (`sidechat-source.ts`): the roster, the open transcript, and the in-flight flags outlive the body's unmounts, and the face is its only writer. The panel declares no store — there is no cross-entry viewing state to share.
+
+</details>

package/README.zh.md

@@ -0,0 +1,67 @@
+---
+description: "qilin Web 客户端右侧边栏的侧聊页：当前会话的侧聊线程、打开线程的自有转录，以及驱动它们的输入框，经由线程 follow 流回读。"
+kind: "package-reference"
+---
+
+# @qilin-agent/client-ui-sidechat
+
+[English](README.md) | 中文
+
+## 概述
+
+右侧边栏的侧聊页：一列列出当前会话的侧聊线程，一格显示打开线程的自有转录与输入框。它是按类型打开、不声明地址的页面。列表与转录是面板自己的读取——会话控制器的六个 `sidechat*` 远程加上每个线程子代理地址上的 `session.follow`——所有操作都经由这些远程。`ui-sidebar-right` 对本包一无所知。
+
+## 目录
+
+- [注册了什么](#what-it-registers)
+- [面板](#the-panel)
+- [Model Experience](#model-experience)
+- [Known Limitations and Deferred Work](#known-limitations-and-deferred-work)
+- [Dev Note](#dev-note)
+
+-----
+
+<a id="what-it-registers"></a>
+## 注册内容
+
+- **类型** —— `ctx.sidebarRightTabs.register(...)`：kind `sidechat`、id `@qilin-agent/client-ui-sidechat`、band `builtin`、`single`、无 patterns；`ctx.sidebarRight.openTab('sidechat')` 打开它。
+- **面板体** —— 该 id 下带键的 `sidebar.right.pane.tab` 座位，经 `hooks` 舱注入面板的状态源，经 inject 面注入操作。
+
+`src/client/` 下九个源文件：`definition.tsx`（类型）、`sidechat-model.ts`（纯视图模型：follow 地址与转录折叠）、`sidechat-source.ts`（对象层状态源）、`face.ts`（操作及其远程绑定）、`SidechatBody.tsx` 与 `SidechatBody.module.css`（绘制内容）、`locales.ts`（文案），以及 `index.ts`（装配）。
+
+<a id="the-panel"></a>
+## 面板
+
+**线程列表** 读取面板所在会话的 `session/sidechatThreads`，按创建先后排序。每行显示线程的持久标签与活跃/运行状态；点击一行打开该线程的转录。
+
+**转录** 通过 `session.follow` 在线程的子代理地址（当前会话的 `continuable` 子级）上跟随打开的线程。开场快照回放线程自有事件——用户消息、继承边界与助手回复——提交帧到达时追加。继承的父前缀不会出现：它是宿主侧的参考上下文，不属于线程自有日志切片。
+
+**输入框** 将草稿作为侧聊 prompt 发送（`session/sidechatPrompt`），Enter 发送。运行中的线程提供取消（`session/sidechatCancel`）；活跃空闲的线程提供释放（`session/sidechatRelease`）；侧栏按钮从当前会话分叉新线程（`session/sidechatStart`），可用第一个问题命名。
+
+<a id="model-experience"></a>
+## 模型体验
+
+无，本包在浏览器中绘制会话侧的线程，不注册任何面向模型的内容。线程自身的模型请求属于宿主上线程自己的会话。
+
+#### KV Cache 效应
+
+无；面板不发起模型请求，也不向任何提示词增加 token。它的读取是会话远程已提供的 follow 流之上的持久事件折叠。
+
+## 已知限制与推迟的工作
+
+<a id="known-limitations-and-deferred-work"></a>
+
+- **每个表面一个页签。** 页面使用页内线程列表，而上游 coding-sidebar 的 SideChat 为每个线程安排一个页签：切换线程会替换当前打开的转录，无法并排阅读两个线程。
+- **线程身份由宿主所有。** 线程以宿主的侧聊描述符识别（provider `sidechat`、mode `continuable`），而非上游的标题前缀约定，标签遵循宿主的 `Side: …` 命名而非任何客户端前缀规则。
+- **只绘持久事件。** follow 请求会请求助手流基线，但面板不绘制流帧——助手文本在其持久 `assistant/message` 事件提交后出现。
+- **仅当前会话。** 面板只附着于打开它的会话，无法浏览侧聊工作区附件，因为侧聊线程不携带任何附件。
+
+<a id="dev-note"></a>
+### 开发备注
+
+<details>
+<summary>维护者的工作背景——点击展开</summary>
+
+状态源是注册作用域的对象层（`sidechat-source.ts`）：线程列表、打开的转录与进行中标志在面板体卸载后仍然存活，face 是它唯一的写入者。面板不声明 store——没有需要跨条目共享的查看状态。
+
+</details>

package/lib/client.js

@@ -0,0 +1,569 @@
+window.__ModuleLoader__.load({
+	id: "@qilin-agent/client-ui-sidechat",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let _qilin_agent_client_ui_primitives = require("@qilin-agent/client-ui-primitives");
+		let react_jsx_runtime = require("react/jsx-runtime");
+		let react = require("react");
+		//#region lib/types/client/definition.js
+		/** The tab kind this package owns; `ctx.sidebarRight.openTab` names it. */
+		const SIDECHAT_KIND = "sidechat";
+		/** This implementation's identity in the tab system, and the key its body registers under. */
+		const SIDECHAT_ID = "@qilin-agent/client-ui-sidechat";
+		/**
+		* The sidechat type's registry definition.
+		* @param t - namespace-bound translate, read fresh on every label call.
+		* @returns the definition to register.
+		*/
+		function sidechatDefinition(t) {
+			return {
+				id: SIDECHAT_ID,
+				kind: SIDECHAT_KIND,
+				priority: "builtin",
+				label: () => t("type.label"),
+				icon: _qilin_agent_client_ui_primitives.IconNewChatOutline16,
+				single: true,
+				title: () => t("type.label")
+			};
+		}
+		//#endregion
+		//#region lib/types/client/sidechat-model.js
+		/**
+		* The subagent history address of one sidechat thread: every thread is a
+		* `continuable` child of its parent Session.
+		* @param parentSessionId - the parent Session the panel is open on.
+		* @param childSessionId - the sidechat thread.
+		* @returns the follow address.
+		*/
+		function sidechatAddress(parentSessionId, childSessionId) {
+			return {
+				kind: "subagent",
+				parentSessionId,
+				childSessionId,
+				mode: "continuable"
+			};
+		}
+		/** Whether one message data value carries the content-part array. */
+		function hasContentParts(value) {
+			return Array.isArray(value);
+		}
+		/** The joined text of one message event's data, or `undefined` when it carries none. */
+		function messageText(data) {
+			const content = data.content;
+			if (!hasContentParts(content)) return void 0;
+			const parts = [];
+			for (const part of content) if (part?.type === "text" && typeof part.text === "string") parts.push(part.text);
+			const text = parts.join("");
+			return text.length > 0 ? text : void 0;
+		}
+		/**
+		* Fold one durable history record into a transcript entry, or `undefined`
+		* for events the panel does not draw.
+		* @param record - one journal record.
+		* @returns the entry, when the event is a user, boundary, or assistant message.
+		*/
+		function transcriptEntryOf(record) {
+			const event = record.event;
+			const text = messageText(event.data);
+			if (text === void 0) return void 0;
+			if (event.type === "user/message") {
+				const sourceKind = event.data.source?.kind;
+				return {
+					seq: event.seq,
+					kind: sourceKind === "sidechat-boundary" ? "boundary" : "user",
+					text
+				};
+			}
+			if (event.type === "assistant/message") return {
+				seq: event.seq,
+				kind: "assistant",
+				text
+			};
+		}
+		/**
+		* Fold one follow frame into transcript entries: the opening snapshot replays
+		* whole records, committed frames arrive one event at a time, and the
+		* process-local assistant stream is ignored (durable events own the transcript).
+		* @param frame - one frame from the thread's follow stream.
+		* @returns the entries the frame contributes, oldest first.
+		*/
+		function transcriptEntriesOfFrame(frame) {
+			if (frame.type === "snapshot") return frame.records.map(transcriptEntryOf).filter((entry) => entry !== void 0);
+			if (frame.type === "event") {
+				const entry = transcriptEntryOf(frame);
+				return entry === void 0 ? [] : [entry];
+			}
+			return [];
+		}
+		//#endregion
+		//#region lib/types/client/face.js
+		/**
+		* Bind the sidechat remotes to one state source.
+		* @param source - the panel's state source.
+		* @param remote - the Session Remote slice.
+		* @returns the injected face.
+		*/
+		function sidechatFace(source, remote) {
+			let activeStop;
+			const refresh = async (parentSessionId) => {
+				source.setPhase("loading");
+				const rows = await remote.sidechatThreads({ sessionId: parentSessionId });
+				if (rows.ok) source.setThreads(rows.value.threads);
+				else source.setPhase("failed");
+			};
+			const openTranscript = (parentSessionId, threadId) => {
+				activeStop?.();
+				const controller = new AbortController();
+				activeStop = () => {
+					controller.abort();
+				};
+				source.select(threadId);
+				source.resetEntries(threadId, []);
+				(async () => {
+					try {
+						for await (const frame of remote.follow({
+							address: sidechatAddress(parentSessionId, threadId),
+							assistantStream: true
+						}, controller.signal)) {
+							if (controller.signal.aborted) return;
+							const entries = transcriptEntriesOfFrame(frame);
+							if (frame.type === "snapshot") source.resetEntries(threadId, entries);
+							else for (const entry of entries) source.appendEntry(threadId, entry);
+						}
+					} catch {}
+				})();
+				return () => {
+					controller.abort();
+				};
+			};
+			return {
+				hooks: { sidechat: source },
+				refresh,
+				start: async (parentSessionId, question) => {
+					source.setBusy(true);
+					try {
+						const started = await remote.sidechatStart(question === void 0 ? { sessionId: parentSessionId } : {
+							sessionId: parentSessionId,
+							question
+						});
+						if (!started.ok) return;
+						await refresh(parentSessionId);
+						openTranscript(parentSessionId, started.value.threadId);
+					} finally {
+						source.setBusy(false);
+					}
+				},
+				send: async (parentSessionId, threadId, text) => {
+					source.setBusy(true);
+					try {
+						const prompted = await remote.sidechatPrompt({
+							sessionId: threadId,
+							text
+						});
+						if (!prompted.ok) return false;
+						await refresh(parentSessionId);
+						return prompted.value.accepted;
+					} finally {
+						source.setBusy(false);
+					}
+				},
+				cancel: async (threadId) => {
+					return (await remote.sidechatCancel({ sessionId: threadId })).ok;
+				},
+				release: async (parentSessionId, threadId) => {
+					await remote.sidechatRelease({ sessionId: threadId });
+					await refresh(parentSessionId);
+				},
+				openTranscript
+			};
+		}
+		//#endregion
+		//#region lib/types/client/locales.js
+		/** Dictionary namespace owned by this plugin. */
+		const NS = "sidebarSidechat";
+		/** Simplified Chinese dictionary and key-set source of truth. */
+		const zh = {
+			"type.label": "侧聊",
+			"guide.title": "侧聊线程",
+			"guide.description": "从当前会话分叉的侧聊线程",
+			"threads.title": "侧聊线程",
+			"threads.empty": "还没有侧聊线程",
+			"threads.failed": "无法读取侧聊线程",
+			"threads.new": "新建侧聊",
+			"threads.starting": "正在创建…",
+			"threads.count.one": "{count} 个线程",
+			"threads.count.other": "{count} 个线程",
+			"thread.live": "活跃",
+			"thread.running": "运行中",
+			"thread.cancel": "取消本轮",
+			"thread.release": "释放",
+			"thread.open": "打开线程",
+			"prompt.placeholder": "在侧聊里问点什么…",
+			"prompt.send": "发送",
+			"prompt.sending": "发送中…",
+			"entry.boundary": "侧聊边界：继承的上文仅供参考。",
+			"panel.empty": "选择或新建一个侧聊线程。"
+		};
+		/** English dictionary. */
+		const en = {
+			"type.label": "Sidechat",
+			"guide.title": "Sidechat threads",
+			"guide.description": "Threads forked from the current session",
+			"threads.title": "Sidechat threads",
+			"threads.empty": "No sidechat threads yet",
+			"threads.failed": "Could not read sidechat threads",
+			"threads.new": "New sidechat",
+			"threads.starting": "Creating…",
+			"threads.count.one": "{count} thread",
+			"threads.count.other": "{count} threads",
+			"thread.live": "live",
+			"thread.running": "running",
+			"thread.cancel": "Cancel turn",
+			"thread.release": "Release",
+			"thread.open": "Open thread",
+			"prompt.placeholder": "Ask something in the sidechat…",
+			"prompt.send": "Send",
+			"prompt.sending": "Sending…",
+			"entry.boundary": "Sidechat boundary: the inherited context is reference only.",
+			"panel.empty": "Select or create a sidechat thread."
+		};
+		//#endregion
+		//#region lib/types/client/sidechat-source.js
+		/** The initial snapshot: nothing read, nothing open. */
+		const EMPTY_STATE = {
+			threads: [],
+			phase: "idle",
+			selectedId: void 0,
+			entries: {},
+			busy: false
+		};
+		/**
+		* One registration-scoped state source. The snapshot reference is stable
+		* between changes, so hook bindings observe by identity.
+		*/
+		var SidechatSource = class {
+			state = EMPTY_STATE;
+			listeners = /* @__PURE__ */ new Set();
+			/**
+			* The current snapshot; the same reference until the next change.
+			* @returns the current state object.
+			*/
+			getSnapshot() {
+				return this.state;
+			}
+			/**
+			* Subscribe to changes.
+			* @param listener - called after every published change.
+			* @returns the unsubscribe function.
+			*/
+			subscribe(listener) {
+				this.listeners.add(listener);
+				return () => {
+					this.listeners.delete(listener);
+				};
+			}
+			publish(state) {
+				this.state = state;
+				for (const listener of this.listeners) listener();
+			}
+			/**
+			* Publish the roster and mark the read complete.
+			* @param threads - the parent's thread rows in display order.
+			*/
+			setThreads(threads) {
+				this.publish({
+					...this.state,
+					threads,
+					phase: "ready"
+				});
+			}
+			/**
+			* Mark a roster read as in flight or failed; `loading` only on the first read.
+			* @param phase - the roster phase to publish.
+			*/
+			setPhase(phase) {
+				if (phase !== "failed" && this.state.phase !== "idle" && this.state.phase !== "failed") return;
+				this.publish({
+					...this.state,
+					phase
+				});
+			}
+			/**
+			* Select the thread whose transcript the panel shows.
+			* @param threadId - the thread to select, or undefined to clear.
+			*/
+			select(threadId) {
+				if (this.state.selectedId === threadId) return;
+				this.publish({
+					...this.state,
+					selectedId: threadId
+				});
+			}
+			/**
+			* Replace one thread's transcript with a freshly replayed cut.
+			* @param threadId - the thread owning the transcript.
+			* @param entries - the replayed entries in log order.
+			*/
+			resetEntries(threadId, entries) {
+				this.publish({
+					...this.state,
+					entries: {
+						...this.state.entries,
+						[threadId]: entries
+					}
+				});
+			}
+			/**
+			* Append one committed entry to a thread's transcript.
+			* @param threadId - the thread owning the transcript.
+			* @param entry - the committed entry to append after the current tail.
+			*/
+			appendEntry(threadId, entry) {
+				const existing = this.state.entries[threadId] ?? [];
+				const last = existing[existing.length - 1];
+				if (last !== void 0 && last.seq >= entry.seq) return;
+				this.publish({
+					...this.state,
+					entries: {
+						...this.state.entries,
+						[threadId]: [...existing, entry]
+					}
+				});
+			}
+			/**
+			* Set the in-flight flag for start and send actions.
+			* @param busy - whether a start or send is in flight.
+			*/
+			setBusy(busy) {
+				if (this.state.busy === busy) return;
+				this.publish({
+					...this.state,
+					busy
+				});
+			}
+		};
+		/**
+		* Create one registration-scoped sidechat source.
+		* @returns a fresh source with empty state and no listeners.
+		*/
+		function createSidechatSource() {
+			return new SidechatSource();
+		}
+		//#endregion
+		//#region ../../../node_modules/.pnpm/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
+		function r(e) {
+			var t, f, n = "";
+			if ("string" == typeof e || "number" == typeof e) n += e;
+			else if ("object" == typeof e) if (Array.isArray(e)) {
+				var o = e.length;
+				for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+			} else for (f in e) e[f] && (n && (n += " "), n += f);
+			return n;
+		}
+		function clsx() {
+			for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+			return n;
+		}
+		//#endregion
+		//#region \0qilin-css:/home/runner/work/QiLin/QiLin/packages/client/ui-sidechat/src/client/SidechatBody.module.css.mjs
+		const css = ".vstdAW_panel{gap:var(--qilin-space-3);width:100%;min-height:0;color:var(--qilin-color-text-primary);flex:1;display:flex}.vstdAW_failed{color:var(--qilin-color-text-secondary);justify-content:center;align-items:center}.vstdAW_rail{gap:var(--qilin-space-2);flex-direction:column;flex-shrink:0;width:168px;min-height:0;display:flex;overflow-y:auto}.vstdAW_railEmpty{color:var(--qilin-color-text-secondary);font-size:var(--qilin-font-size-sm);margin:0}.vstdAW_newThread{padding:var(--qilin-space-2) var(--qilin-space-3);border:1px solid var(--qilin-color-border-primary);border-radius:var(--qilin-radius-md);color:inherit;cursor:pointer;background:0 0}.vstdAW_newThread:disabled{cursor:default;opacity:.6}.vstdAW_threadList{gap:var(--qilin-space-1);flex-direction:column;margin:0;padding:0;list-style:none;display:flex}.vstdAW_threadRow{justify-content:space-between;align-items:center;gap:var(--qilin-space-2);width:100%;padding:var(--qilin-space-2);border-radius:var(--qilin-radius-md);color:inherit;text-align:left;cursor:pointer;background:0 0;border:1px solid #0000;display:flex}.vstdAW_threadRow.vstdAW_selected{border-color:var(--qilin-color-border-accent);background:var(--qilin-color-bg-accent-subtle)}.vstdAW_threadLabel{text-overflow:ellipsis;white-space:nowrap;font-size:var(--qilin-font-size-sm);overflow:hidden}.vstdAW_threadState{color:var(--qilin-color-text-secondary);font-size:var(--qilin-font-size-xs);flex-shrink:0}.vstdAW_running{color:var(--qilin-color-text-accent)}.vstdAW_transcript{gap:var(--qilin-space-2);flex-direction:column;flex:1;min-width:0;min-height:0;display:flex}.vstdAW_transcriptEmpty{color:var(--qilin-color-text-secondary);margin:0}.vstdAW_entries{gap:var(--qilin-space-2);flex-direction:column;flex:1;min-height:0;display:flex;overflow-y:auto}.vstdAW_entry{padding:var(--qilin-space-2) var(--qilin-space-3);border-radius:var(--qilin-radius-md);background:var(--qilin-color-bg-subtle);white-space:pre-wrap;overflow-wrap:anywhere;margin:0}.vstdAW_user{background:var(--qilin-color-bg-accent-subtle)}.vstdAW_boundary{color:var(--qilin-color-text-secondary);border:1px dashed var(--qilin-color-border-primary);background:0 0}.vstdAW_assistant{background:0 0}.vstdAW_composer{gap:var(--qilin-space-2);flex-direction:column;display:flex}.vstdAW_input{width:100%;min-height:56px;padding:var(--qilin-space-2);border:1px solid var(--qilin-color-border-primary);border-radius:var(--qilin-radius-md);background:var(--qilin-color-bg-primary);color:inherit;resize:vertical}.vstdAW_composerActions{justify-content:flex-end;gap:var(--qilin-space-2);display:flex}.vstdAW_secondary{padding:var(--qilin-space-1) var(--qilin-space-3);border:1px solid var(--qilin-color-border-primary);border-radius:var(--qilin-radius-md);color:inherit;cursor:pointer;background:0 0}.vstdAW_primary{padding:var(--qilin-space-1) var(--qilin-space-3);border-radius:var(--qilin-radius-md);background:var(--qilin-color-bg-accent);color:var(--qilin-color-text-accent-contrast);cursor:pointer;border:1px solid #0000}.vstdAW_primary:disabled{cursor:default;opacity:.6}";
+		const tagId = "@qilin-agent/client-ui-sidechat/SidechatBody.module.css";
+		if (typeof document !== "undefined" && document.querySelector("style[data-plugin-css=" + JSON.stringify(tagId) + "]") === null) {
+			const tag = document.createElement("style");
+			tag.dataset.plugin = "@qilin-agent/client-ui-sidechat";
+			tag.dataset.pluginCss = tagId;
+			tag.textContent = css;
+			document.head.appendChild(tag);
+		}
+		var SidechatBody_module_css_default = {
+			"assistant": "vstdAW_assistant",
+			"boundary": "vstdAW_boundary",
+			"composer": "vstdAW_composer",
+			"composerActions": "vstdAW_composerActions",
+			"entries": "vstdAW_entries",
+			"entry": "vstdAW_entry",
+			"failed": "vstdAW_failed",
+			"input": "vstdAW_input",
+			"newThread": "vstdAW_newThread",
+			"panel": "vstdAW_panel",
+			"primary": "vstdAW_primary",
+			"rail": "vstdAW_rail",
+			"railEmpty": "vstdAW_railEmpty",
+			"running": "vstdAW_running",
+			"secondary": "vstdAW_secondary",
+			"selected": "vstdAW_selected",
+			"threadLabel": "vstdAW_threadLabel",
+			"threadList": "vstdAW_threadList",
+			"threadRow": "vstdAW_threadRow",
+			"threadState": "vstdAW_threadState",
+			"transcript": "vstdAW_transcript",
+			"transcriptEmpty": "vstdAW_transcriptEmpty",
+			"user": "vstdAW_user"
+		};
+		//#endregion
+		//#region lib/types/client/SidechatBody.js
+		/**
+		* The sidechat panel body: the thread roster on the left rail, the open
+		* thread's transcript, and the composer. Everything arrives through the
+		* derived props shares; the body writes nothing directly.
+		*/
+		/** One transcript row's accent class, by entry kind. */
+		const ENTRY_CLASS = {
+			user: SidechatBody_module_css_default.user,
+			boundary: SidechatBody_module_css_default.boundary,
+			assistant: SidechatBody_module_css_default.assistant
+		};
+		/**
+		* The panel body.
+		* @param props - the runtime share (sessionId, useSidechat), the injected face, and the copy.
+		* @returns the roster rail and the transcript pane, or the empty line.
+		*/
+		function SidechatBody({ sessionId, useSidechat, refresh, start, send, cancel, release, openTranscript, t }) {
+			const state = useSidechat((snapshot) => snapshot);
+			const [draft, setDraft] = (0, react.useState)("");
+			const selected = state.threads.find((row) => row.id === state.selectedId);
+			const entries = state.selectedId === void 0 ? [] : state.entries[state.selectedId] ?? [];
+			(0, react.useEffect)(() => {
+				refresh(sessionId);
+			}, [refresh, sessionId]);
+			const submit = () => {
+				const text = draft.trim();
+				if (text.length === 0 || state.selectedId === void 0 || state.busy) return;
+				setDraft("");
+				send(sessionId, state.selectedId, text);
+			};
+			if (state.phase === "failed") return (0, react_jsx_runtime.jsx)("p", {
+				className: clsx(SidechatBody_module_css_default.panel, SidechatBody_module_css_default.failed),
+				children: t("threads.failed")
+			});
+			return (0, react_jsx_runtime.jsxs)("div", {
+				className: SidechatBody_module_css_default.panel,
+				children: [(0, react_jsx_runtime.jsxs)("section", {
+					className: SidechatBody_module_css_default.rail,
+					"aria-label": t("threads.title"),
+					children: [(0, react_jsx_runtime.jsx)("button", {
+						type: "button",
+						className: SidechatBody_module_css_default.newThread,
+						disabled: state.busy,
+						onClick: () => {
+							start(sessionId);
+						},
+						children: state.busy ? t("threads.starting") : t("threads.new")
+					}), state.threads.length === 0 ? (0, react_jsx_runtime.jsx)("p", {
+						className: SidechatBody_module_css_default.railEmpty,
+						children: t("threads.empty")
+					}) : (0, react_jsx_runtime.jsx)("ul", {
+						className: SidechatBody_module_css_default.threadList,
+						children: state.threads.map((row) => (0, react_jsx_runtime.jsx)("li", { children: (0, react_jsx_runtime.jsxs)("button", {
+							type: "button",
+							className: clsx(SidechatBody_module_css_default.threadRow, row.id === state.selectedId && SidechatBody_module_css_default.selected),
+							"aria-label": t("thread.open"),
+							onClick: () => openTranscript(sessionId, row.id),
+							children: [(0, react_jsx_runtime.jsx)("span", {
+								className: SidechatBody_module_css_default.threadLabel,
+								children: row.label
+							}), (0, react_jsx_runtime.jsx)("span", {
+								className: clsx(SidechatBody_module_css_default.threadState, row.running && SidechatBody_module_css_default.running),
+								children: row.running ? t("thread.running") : row.live ? t("thread.live") : ""
+							})]
+						}) }, row.id))
+					})]
+				}), (0, react_jsx_runtime.jsx)("section", {
+					className: SidechatBody_module_css_default.transcript,
+					"aria-label": t("threads.title"),
+					children: selected === void 0 ? (0, react_jsx_runtime.jsx)("p", {
+						className: SidechatBody_module_css_default.transcriptEmpty,
+						children: t("panel.empty")
+					}) : (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [(0, react_jsx_runtime.jsx)("div", {
+						className: SidechatBody_module_css_default.entries,
+						children: entries.map((entry) => (0, react_jsx_runtime.jsx)("p", {
+							className: clsx(SidechatBody_module_css_default.entry, ENTRY_CLASS[entry.kind]),
+							children: entry.kind === "boundary" ? `${t("entry.boundary")}\n${entry.text}` : entry.text
+						}, entry.seq))
+					}), (0, react_jsx_runtime.jsxs)("div", {
+						className: SidechatBody_module_css_default.composer,
+						children: [(0, react_jsx_runtime.jsx)("textarea", {
+							className: SidechatBody_module_css_default.input,
+							value: draft,
+							placeholder: t("prompt.placeholder"),
+							onChange: (event) => {
+								setDraft(event.target.value);
+							},
+							onKeyDown: (event) => {
+								if (event.key === "Enter" && !event.shiftKey) {
+									event.preventDefault();
+									submit();
+								}
+							}
+						}), (0, react_jsx_runtime.jsxs)("div", {
+							className: SidechatBody_module_css_default.composerActions,
+							children: [selected.running ? (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								className: SidechatBody_module_css_default.secondary,
+								onClick: () => {
+									cancel(selected.id);
+								},
+								children: t("thread.cancel")
+							}) : (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								className: SidechatBody_module_css_default.secondary,
+								onClick: () => {
+									release(sessionId, selected.id);
+								},
+								children: t("thread.release")
+							}), (0, react_jsx_runtime.jsx)("button", {
+								type: "button",
+								className: SidechatBody_module_css_default.primary,
+								disabled: state.busy || draft.trim().length === 0,
+								onClick: submit,
+								children: state.busy ? t("prompt.sending") : t("prompt.send")
+							})]
+						})]
+					})] })
+				})]
+			});
+		}
+		//#endregion
+		//#region lib/types/client/index.js
+		/**
+		* Required browser services: the tab registry, the keyed seat, the Session
+		* Remote namespace, and copy.
+		*/
+		const inject = [
+			"slots",
+			"locale",
+			"sidebarRightTabs",
+			"remote",
+			"remote.session"
+		];
+		/**
+		* Client plugin body: register the type, its dictionaries, and the body.
+		* @param ctx - client root context carrying the registry, the slots, and the Remote face.
+		*/
+		function apply(ctx) {
+			ctx.effect(() => ctx.locale.register(NS, {
+				zh,
+				en
+			}), "ui-sidechat: dictionaries");
+			const t = ctx.locale.bind(NS);
+			ctx.effect(() => ctx.sidebarRightTabs.register(sidechatDefinition(t)), "ui-sidechat: sidechat type");
+			const source = createSidechatSource();
+			const remote = ctx.remote.session;
+			const face = sidechatFace(source, remote);
+			ctx.effect(() => ctx.slots.inject("sidebar.right.pane.tab", () => ctx.slots.register({
+				name: "sidebar.right.pane.tab",
+				key: SIDECHAT_ID,
+				locale: NS,
+				inject: () => face
+			}, SidechatBody)), "ui-sidechat: sidechat tab body");
+		}
+		//#endregion
+		exports.apply = apply;
+		exports.inject = inject;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map

package/lib/index.js

@@ -0,0 +1,6 @@
+//#region lib/types/index.js
+/** Pure host half; the whole tab type lives in the browser export. */
+/** Host plugin body: the sidechat page contributes nothing to the host tree. */
+function apply() {}
+//#endregion
+export { apply };

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

@@ -0,0 +1,18 @@
+/**
+ * The sidechat panel body: the thread roster on the left rail, the open
+ * thread's transcript, and the composer. Everything arrives through the
+ * derived props shares; the body writes nothing directly.
+ */
+import { type ReactNode } from 'react';
+import type { InjectFace, PropsLocale, PropsRuntime } from '@qilin-agent/client-ui-slots';
+import type { SidechatInjected } from './face.ts';
+import { NS } from './locales.ts';
+/** The body's composed props: the tab it draws, its face, and its copy. */
+export type SidechatBodyProps = PropsRuntime<'sidebar.right.pane.tab'> & InjectFace<SidechatInjected> & PropsLocale<typeof NS>;
+/**
+ * The panel body.
+ * @param props - the runtime share (sessionId, useSidechat), the injected face, and the copy.
+ * @returns the roster rail and the transcript pane, or the empty line.
+ */
+export declare function SidechatBody({ sessionId, useSidechat, refresh, start, send, cancel, release, openTranscript, t, }: SidechatBodyProps): ReactNode;
+//# sourceMappingURL=SidechatBody.d.ts.map

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

@@ -0,0 +1,19 @@
+/**
+ * Stage one of this package's registration: what the `sidechat` tab type is.
+ *
+ * The type is a page, not a viewer: it claims no address, so a tab of this
+ * kind is opened by kind alone — `ctx.sidebarRight.openTab('sidechat')`.
+ */
+import type { TranslateNS } from '@qilin-agent/client-locale/client';
+import type { SidebarRightTabDefinition } from '@qilin-agent/client-ui-sidebar-right/client';
+/** The tab kind this package owns; `ctx.sidebarRight.openTab` names it. */
+export declare const SIDECHAT_KIND = "sidechat";
+/** This implementation's identity in the tab system, and the key its body registers under. */
+export declare const SIDECHAT_ID = "@qilin-agent/client-ui-sidechat";
+/**
+ * The sidechat type's registry definition.
+ * @param t - namespace-bound translate, read fresh on every label call.
+ * @returns the definition to register.
+ */
+export declare function sidechatDefinition(t: TranslateNS<'sidebarSidechat'>): SidebarRightTabDefinition;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1,67 @@
+/**
+ * The sidechat panel's business face: the six Session Controller sidechat
+ * remotes plus the follow stream, bound to one state source. The panel reads
+ * everything through the source and acts only through these actions.
+ */
+import type { ClientRemote } from '@qilin-agent/api-remotes/client';
+import type { SessionId } from '@qilin-agent/session';
+import type { SidechatSource } from './sidechat-source.ts';
+/**
+ * The Session Remote slice this panel reads and drives, exactly as the Host's
+ * generated client declares it.
+ */
+export type SidechatRemote = Pick<ClientRemote['session'], 'sidechatStart' | 'sidechatPrompt' | 'sidechatCancel' | 'sidechatSnapshot' | 'sidechatRelease' | 'sidechatThreads' | 'follow'>;
+/** The panel's injected face, as the body receives it. */
+export interface SidechatInjected {
+    hooks: {
+        /** The panel's state source, bound by the renderer as `useSidechat`. */
+        sidechat: SidechatSource;
+    };
+    /**
+     * Re-read the parent's thread roster.
+     * @param parentSessionId - the Session the panel is open on.
+     */
+    refresh(parentSessionId: SessionId): Promise<void>;
+    /**
+     * Fork one new thread off the parent and open it.
+     * @param parentSessionId - the Session to fork from.
+     * @param question - optional first question, delivered with the boundary.
+     */
+    start(parentSessionId: SessionId, question?: string): Promise<void>;
+    /**
+     * Deliver one follow-up message to a thread.
+     * @param parentSessionId - the Session the panel is open on.
+     * @param threadId - the thread to prompt.
+     * @param text - the message text.
+     * @returns whether the Host accepted the prompt.
+     */
+    send(parentSessionId: SessionId, threadId: SessionId, text: string): Promise<boolean>;
+    /**
+     * Cancel a thread's running turn.
+     * @param threadId - the thread whose turn is cancelled.
+     * @returns whether the Host accepted the cancel.
+     */
+    cancel(threadId: SessionId): Promise<boolean>;
+    /**
+     * Release a thread's live Agent and refresh the roster.
+     * @param parentSessionId - the Session the panel is open on.
+     * @param threadId - the thread to release.
+     */
+    release(parentSessionId: SessionId, threadId: SessionId): Promise<void>;
+    /**
+     * Open one thread's transcript: replay its own events and follow the live
+     * log. Opening a second thread closes the first subscription.
+     * @param parentSessionId - the Session the panel is open on.
+     * @param threadId - the thread to follow.
+     * @returns the stop function.
+     */
+    openTranscript(parentSessionId: SessionId, threadId: SessionId): () => void;
+}
+/**
+ * Bind the sidechat remotes to one state source.
+ * @param source - the panel's state source.
+ * @param remote - the Session Remote slice.
+ * @returns the injected face.
+ */
+export declare function sidechatFace(source: SidechatSource, remote: SidechatRemote): SidechatInjected;
+//# sourceMappingURL=face.d.ts.map

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

@@ -0,0 +1,29 @@
+/**
+ * Browser half: register `sidechat` as a right-Sidebar tab type.
+ *
+ * The public two-stage path: the type into `ctx.sidebarRightTabs`, the body
+ * into the keyed `sidebar.right.pane.tab` seat, both under the type's `id`.
+ *
+ * The split is this package's layering: what the type is (`definition.tsx`),
+ * what it says (`locales.ts`), the pure view model (`sidechat-model.ts`), the
+ * object-layer state source (`sidechat-source.ts`), the actions it performs
+ * (`face.ts`), what it draws (`SidechatBody.tsx`), and this module, which
+ * wires them.
+ */
+import type { Context as ClientContext } from '@qilin-agent/kylin';
+export type { SidechatInjected, SidechatRemote } from './face.ts';
+export type { SidechatState, SidechatPhase } from './sidechat-source.ts';
+export type { SidechatTranscriptEntry } from './sidechat-model.ts';
+export type { SidechatKey } from './locales.ts';
+export type { SidechatBodyProps } from './SidechatBody.tsx';
+/**
+ * Required browser services: the tab registry, the keyed seat, the Session
+ * Remote namespace, and copy.
+ */
+export declare const inject: string[];
+/**
+ * Client plugin body: register the type, its dictionaries, and the body.
+ * @param ctx - client root context carrying the registry, the slots, and the Remote face.
+ */
+export declare function apply(ctx: ClientContext): void;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,36 @@
+declare module '@qilin-agent/client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** Sidechat panel type name, thread list copy, and transcript copy. */
+        sidebarSidechat: SidechatKey;
+    }
+}
+/** Dictionary namespace owned by this plugin. */
+export declare const NS = "sidebarSidechat";
+/** Simplified Chinese dictionary and key-set source of truth. */
+export declare const zh: {
+    readonly 'type.label': "侧聊";
+    readonly 'guide.title': "侧聊线程";
+    readonly 'guide.description': "从当前会话分叉的侧聊线程";
+    readonly 'threads.title': "侧聊线程";
+    readonly 'threads.empty': "还没有侧聊线程";
+    readonly 'threads.failed': "无法读取侧聊线程";
+    readonly 'threads.new': "新建侧聊";
+    readonly 'threads.starting': "正在创建…";
+    readonly 'threads.count.one': "{count} 个线程";
+    readonly 'threads.count.other': "{count} 个线程";
+    readonly 'thread.live': "活跃";
+    readonly 'thread.running': "运行中";
+    readonly 'thread.cancel': "取消本轮";
+    readonly 'thread.release': "释放";
+    readonly 'thread.open': "打开线程";
+    readonly 'prompt.placeholder': "在侧聊里问点什么…";
+    readonly 'prompt.send': "发送";
+    readonly 'prompt.sending': "发送中…";
+    readonly 'entry.boundary': "侧聊边界：继承的上文仅供参考。";
+    readonly 'panel.empty': "选择或新建一个侧聊线程。";
+};
+/** The namespace's key set; en must define exactly these keys. */
+export type SidechatKey = keyof typeof zh;
+/** English dictionary. */
+export declare const en: Record<SidechatKey, string>;
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/sidechat-model.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Pure sidechat view model: the follow address of one thread, and the fold
+ * from durable Session events to the panel's transcript entries.
+ */
+import type { SessionId } from '@qilin-agent/session';
+import type { SessionFollowFrame, SessionHistoryRecord } from '@qilin-agent/api-session-controller/types';
+/** One rendered line of a thread's transcript. */
+export interface SidechatTranscriptEntry {
+    readonly seq: number;
+    readonly kind: 'user' | 'boundary' | 'assistant';
+    readonly text: string;
+}
+/**
+ * The subagent history address of one sidechat thread: every thread is a
+ * `continuable` child of its parent Session.
+ * @param parentSessionId - the parent Session the panel is open on.
+ * @param childSessionId - the sidechat thread.
+ * @returns the follow address.
+ */
+export declare function sidechatAddress(parentSessionId: SessionId, childSessionId: SessionId): {
+    kind: 'subagent';
+    parentSessionId: SessionId;
+    childSessionId: SessionId;
+    mode: 'continuable';
+};
+/**
+ * Fold one durable history record into a transcript entry, or `undefined`
+ * for events the panel does not draw.
+ * @param record - one journal record.
+ * @returns the entry, when the event is a user, boundary, or assistant message.
+ */
+export declare function transcriptEntryOf(record: SessionHistoryRecord): SidechatTranscriptEntry | undefined;
+/**
+ * Fold one follow frame into transcript entries: the opening snapshot replays
+ * whole records, committed frames arrive one event at a time, and the
+ * process-local assistant stream is ignored (durable events own the transcript).
+ * @param frame - one frame from the thread's follow stream.
+ * @returns the entries the frame contributes, oldest first.
+ */
+export declare function transcriptEntriesOfFrame(frame: SessionFollowFrame): readonly SidechatTranscriptEntry[];
+//# sourceMappingURL=sidechat-model.d.ts.map

package/lib/types/client/sidechat-source.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The sidechat panel's object-layer state source: the thread roster, the
+ * open thread's transcript, and the in-flight flags — one bare observable
+ * the renderer binds as `useSidechat`. React-free by design; the face in
+ * `face.ts` is the only writer.
+ */
+import type { SessionId } from '@qilin-agent/session';
+import type { SidechatThreadRow } from '@qilin-agent/api-session-controller/types';
+import type { SidechatTranscriptEntry } from './sidechat-model.ts';
+/** How far the roster read has got. */
+export type SidechatPhase = 'idle' | 'loading' | 'ready' | 'failed';
+/** The panel's state snapshot. */
+export interface SidechatState {
+    /** The parent's sidechat threads, oldest first. */
+    readonly threads: readonly SidechatThreadRow[];
+    /** The roster read's phase. */
+    readonly phase: SidechatPhase;
+    /** The thread whose transcript is open. */
+    readonly selectedId: SessionId | undefined;
+    /** One transcript per opened thread, oldest first. */
+    readonly entries: Readonly<Record<string, readonly SidechatTranscriptEntry[]>>;
+    /** Whether a start or send is in flight. */
+    readonly busy: boolean;
+}
+/**
+ * One registration-scoped state source. The snapshot reference is stable
+ * between changes, so hook bindings observe by identity.
+ */
+export declare class SidechatSource {
+    private state;
+    private readonly listeners;
+    /**
+     * The current snapshot; the same reference until the next change.
+     * @returns the current state object.
+     */
+    getSnapshot(): SidechatState;
+    /**
+     * Subscribe to changes.
+     * @param listener - called after every published change.
+     * @returns the unsubscribe function.
+     */
+    subscribe(listener: () => void): () => void;
+    private publish;
+    /**
+     * Publish the roster and mark the read complete.
+     * @param threads - the parent's thread rows in display order.
+     */
+    setThreads(threads: readonly SidechatThreadRow[]): void;
+    /**
+     * Mark a roster read as in flight or failed; `loading` only on the first read.
+     * @param phase - the roster phase to publish.
+     */
+    setPhase(phase: SidechatPhase): void;
+    /**
+     * Select the thread whose transcript the panel shows.
+     * @param threadId - the thread to select, or undefined to clear.
+     */
+    select(threadId: SessionId | undefined): void;
+    /**
+     * Replace one thread's transcript with a freshly replayed cut.
+     * @param threadId - the thread owning the transcript.
+     * @param entries - the replayed entries in log order.
+     */
+    resetEntries(threadId: SessionId, entries: readonly SidechatTranscriptEntry[]): void;
+    /**
+     * Append one committed entry to a thread's transcript.
+     * @param threadId - the thread owning the transcript.
+     * @param entry - the committed entry to append after the current tail.
+     */
+    appendEntry(threadId: SessionId, entry: SidechatTranscriptEntry): void;
+    /**
+     * Set the in-flight flag for start and send actions.
+     * @param busy - whether a start or send is in flight.
+     */
+    setBusy(busy: boolean): void;
+}
+/**
+ * Create one registration-scoped sidechat source.
+ * @returns a fresh source with empty state and no listeners.
+ */
+export declare function createSidechatSource(): SidechatSource;
+//# sourceMappingURL=sidechat-source.d.ts.map

package/lib/types/index.d.ts

@@ -0,0 +1,4 @@
+/** Pure host half; the whole tab type lives in the browser export. */
+/** Host plugin body: the sidechat page contributes nothing to the host tree. */
+export declare function apply(): void;
+//# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,75 @@
 {
   "name": "@qilin-agent/client-ui-sidechat",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "description": "Sidechat tab type for the right Sidebar: one panel with this Session's side threads, each forked from the parent log with the inherited prefix as reference context",
+  "version": "3.1.3",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kkutysllb/QiLin.git",
+    "directory": "packages/client/ui-sidechat"
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./src/*": "./src/*",
+    "./package.json": "./package.json"
+  },
+  "qilin": {
+    "client": {
+      "inject": [
+        "@qilin-agent/api-remotes",
+        "@qilin-agent/client-ui-sidebar-right"
+      ],
+      "platform": "web"
+    }
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "@qilin-agent/kylin": "~4.0.3"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.1.0",
+    "@types/react": "~18.3.1",
+    "@types/react-dom": "~18.3.0",
+    "clsx": "^2.0.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "@qilin-agent/api-session-controller": "3.1.3",
+    "@qilin-agent/client-test-runtime": "3.1.3",
+    "@qilin-agent/client-ui-primitives": "3.1.3",
+    "@qilin-agent/api-remotes": "3.1.3",
+    "@qilin-agent/client-ui-renderer": "3.1.3",
+    "@qilin-agent/client-locale": "3.1.3",
+    "@qilin-agent/client-ui-session": "3.1.3",
+    "@qilin-agent/client-ui-sidebar-right": "3.1.3",
+    "@qilin-agent/client-ui-slots": "3.1.3",
+    "@qilin-agent/kylin": "~4.0.3",
+    "@qilin-agent/remote-mock": "3.1.3",
+    "@qilin-agent/typert-protocol": "3.1.3",
+    "@qilin-agent/session": "3.1.3",
+    "@qilin-agent/subagent": "3.1.3"
+  },
+  "files": [
+    "lib/index.js",
+    "lib/client.js",
+    "lib/types/**/*.d.ts"
+  ],
+  "scripts": {
+    "bundle": "tsdown",
+    "watch": "tsdown --watch"
+  }
 }