dsh-side-branch 0.1.1 → 0.2.2

package/lib/client.js

@@ -440,6 +440,11 @@ window.__ModuleLoader__.load({
 			'.dsh-side-branch-quotebox{display:flex;align-items:center;gap:8px;border-left:2px solid var(--dsw-alias-border-l4,rgba(0,0,0,.16));padding-left:10px;margin:8px 0;color:var(--dsw-alias-label-secondary,#57585a);font-size:12px;line-height:18px;}',
 			'.dsh-side-branch-quotelabel{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}',
 			'.dsh-side-branch-quoteclose{width:20px;height:20px;font-size:14px;line-height:1;}',
+			// ★ 轮次里的引用块（引用随轮入档）：与「思考」行同款折叠形态，左 2px 边 + 次要色，
+			//   内容区自己滚（引用上限 8000 字，不能把整轮撑开）。
+			'.dsh-side-branch-refblock{margin:2px 0 6px;border-left:2px solid var(--dsw-alias-border-l4,rgba(0,0,0,.16));padding-left:10px;color:var(--dsw-alias-label-secondary,#57585a);font-size:12px;line-height:18px;}',
+			'.dsh-side-branch-refsummary{cursor:pointer;color:var(--dsw-alias-label-tertiary,#8b8d90);}',
+			'.dsh-side-branch-refbody{margin:4px 0 0;white-space:pre-wrap;word-break:break-word;max-height:240px;overflow-y:auto;}',
 			// 错误框（官方无对应物 ⇒ token 化自建；对比度用 state-error-primary，随主题合规）
 			'.dsh-side-branch-errbox{border:1px solid var(--dsw-alias-state-error-primary,#e5484d);background:var(--dsw-alias-bg-overlay,rgba(229,72,77,.10));color:var(--dsw-alias-state-error-primary,#e5484d);border-radius:6px;padding:8px;margin-bottom:8px;font-family:monospace;font-size:12px;line-height:18px;white-space:pre-wrap;word-break:break-word;}',
 			// ⚠️ **不要给答案区加任何"运行中占位行"**（流式闪烁光标、`thinking…` 之类）：官方主会话也没有。
@@ -447,6 +452,21 @@ window.__ModuleLoader__.load({
 			// 工具调用提示行（白名单放行 read/grep 等之后，模型会真的调工具 ⇒ 必须看得见，
 			// 否则面板会毫无理由地停住不动）。与推理行同字号，颜色更淡一档。
 			'.dsh-side-branch-toolline{color:var(--dsw-alias-label-caption,#a0a0a0);font-size:12px;line-height:18px;}',
+			// ── ★ 层 1 / 层 2：「继承了什么 / 注入了什么」
+			// 面板里**唯一**会展示"主会话内容"的地方；全部只读、只放内存（⛔ 不进持久化状态，见组件里那段注释）。
+			'.dsh-side-branch-meta{display:flex;flex-direction:column;gap:6px;margin-bottom:12px;}',
+			'.dsh-side-branch-metaline{display:block;width:100%;text-align:start;background:none;border:0;padding:0;margin:0;font:inherit;font-size:12px;line-height:18px;color:var(--dsw-alias-label-tertiary,#8b8b8b);cursor:pointer;}',
+			'.dsh-side-branch-metaline:disabled{cursor:default;}',
+			'.dsh-side-branch-metaline:hover:not(:disabled){color:var(--dsw-alias-label-secondary,#57585a);}',
+			'.dsh-side-branch-inherited{border-left:2px solid var(--dsw-alias-border-l4,rgba(0,0,0,.16));padding-left:10px;margin:2px 0 6px;display:flex;flex-direction:column;gap:4px;font-size:12px;line-height:18px;color:var(--dsw-alias-label-secondary,#57585a);max-height:320px;overflow:auto;}',
+			'.dsh-side-branch-inhturn{font-size:12px;line-height:18px;}',
+			'.dsh-side-branch-inhturn>summary{cursor:pointer;color:var(--dsw-alias-label-tertiary,#8b8b8b);}',
+			// 继承内容里那一层「思考」（主会话的 reasoning）——比正文再淡一档
+			'.dsh-side-branch-inhthink{margin:2px 0 2px 12px;font-size:12px;line-height:18px;}',
+			'.dsh-side-branch-inhthink>summary{cursor:pointer;color:var(--dsw-alias-label-caption,#a0a0a0);}',
+			'.dsh-side-branch-inhrow{display:flex;gap:6px;padding:2px 0 2px 12px;white-space:pre-wrap;word-break:break-word;}',
+			'.dsh-side-branch-inhtag{flex:none;color:var(--dsw-alias-label-caption,#a0a0a0);}',
+			'.dsh-side-branch-notice{white-space:pre-wrap;word-break:break-word;margin:4px 0 0 12px;font-family:monospace;font-size:11px;line-height:16px;color:var(--dsw-alias-label-tertiary,#8b8b8b);}',
 			// ── 多轮追问：每轮 = 问题气泡（在上）→ 可折叠「思考」行 → 答案
 			'.dsh-side-branch-rounds{display:flex;flex-direction:column;}',
 			'.dsh-side-branch-round{display:flex;flex-direction:column;gap:8px;margin-bottom:18px;}',
@@ -512,6 +532,81 @@ window.__ModuleLoader__.load({
 		 * （`POST /side-branch/close` 释放侧会话）并把面板清干净 ⇒ 下次提问就是新的一段。
 		 */
 
+		// ──────────────────────────────────────────────────────────── 段落（多段回答）的形状与上限
+		//
+		// ⚠️⚠️ **这几个必须留在模块作用域（`createPanelStore` 与 `SideBranchBody` 之外）。**
+		//   它们**两边都要用**：store 里 `normalizeRound` 用它做持久化形状校验；
+		//   组件里 `appendSegment` / `replaceLastSegment` / `snapshot` 处理函数用它做实时写入。
+		//   踩过的坑：把它们 `const` 声明在 `createPanelStore()` **内部**，而组件在**另一个函数**里 ——
+		//   于是第一个 `delta` 一到就抛 `ReferenceError: MAX_SEGMENTS is not defined`，
+		//   被浏览器的事件派发**吞掉**（只在 console 里），现象就是"问了之后答案永远不出现"。
+		//   `node --check`、`scripts/smoke.mjs` 的正则、端到端 harness（它只打 HTTP 路由）三处都查不出来
+		//   ⇒ 所以补了 `scripts/client-check.mjs`（真的把客户端跑起来）。
+		//   ⛔ 别把它们挪回任何一个函数内部。
+		/** 字符串收敛（超长截断；非字符串给空串）。 */
+		const clampString = (value, max) => (typeof value === 'string' ? value.slice(0, max) : '')
+		/** 段落种类白名单（与宿主 `createJob` 的 kind 同源）。 */
+		const SEGMENT_KINDS = new Set(['reasoning', 'text', 'tool'])
+		/** 一轮最多留多少段、每段多长、以及一**轮**的段落总字符预算
+		 *（防止一份坏数据或一次狂长的多段回答把面板与 `sessionStorage` 配额撑爆）。 */
+		const MAX_SEGMENTS = 200
+		const MAX_SEGMENT_CHARS = 200000
+		const MAX_SEGMENTS_TOTAL_CHARS = 400000
+		/** 一「段」的形状校验（坏段直接丢弃，不整轮作废）。 */
+		const normalizeSegment = (raw) => {
+			if (raw === null || typeof raw !== 'object') return null
+			if (typeof raw.kind !== 'string' || SEGMENT_KINDS.has(raw.kind) !== true) return null
+			const out = { kind: raw.kind, text: clampString(raw.text, raw.kind === 'tool' ? 200 : MAX_SEGMENT_CHARS) }
+			// `turn`/`step` 只为"同一 step 重试时精确定位该丢哪几段"而留（很小，随段落一起落盘）
+			if (typeof raw.turn === 'number' && Number.isFinite(raw.turn)) out.turn = raw.turn
+			if (typeof raw.step === 'number' && Number.isFinite(raw.step)) out.step = raw.step
+			return out
+		}
+		/**
+		 * 把段落数组的总字符数压到预算内：**从最早的那几段**开始砍（保留最近的，
+		 * 与"面板上最该看得见的是最新输出"一致）。超预算时逐段缩短，最后必要时丢掉最早的整段。
+		 * @param {Array<{kind: string, text: string}>} list - 段落数组
+		 * @returns {Array<{kind: string, text: string}>}
+		 */
+		const trimSegments = (list) => {
+			let total = 0
+			for (const segment of list) total += segment.text.length
+			if (total <= MAX_SEGMENTS_TOTAL_CHARS) return list
+			const kept = list.slice()
+			let index = 0
+			while (total > MAX_SEGMENTS_TOTAL_CHARS && index < kept.length) {
+				const segment = kept[index]
+				const room = Math.max(0, segment.text.length - (total - MAX_SEGMENTS_TOTAL_CHARS))
+				if (room === 0) {
+					total -= segment.text.length
+					kept[index] = null
+				} else {
+					total -= segment.text.length - room
+					kept[index] = { ...segment, text: segment.text.slice(0, room) }
+				}
+				index += 1
+			}
+			return kept.filter((item) => item !== null)
+		}
+		/**
+		 * ★ 段落的形状校验 + **向后兼容**。
+		 *
+		 * 老的持久化数据**没有** `segments`（那时 job 只有 `answer`/`reasoning` 两个槽位）
+		 * ⇒ 由它们**合成**段落（`reasoning` 段 + `text` 段），别让刷新后的老面板变空。
+		 * @param {unknown} raw - 持久化里的 `segments`
+		 * @param {string} answer - 该轮的 `answer`（最后一段正文）
+		 * @param {string} reasoning - 该轮的 `reasoning`（最后一段推理）
+		 * @returns {Array<{kind: string, text: string}>}
+		 */
+		const normalizeSegments = (raw, answer, reasoning) => {
+			const list = Array.isArray(raw) ? raw.slice(-MAX_SEGMENTS).map(normalizeSegment).filter((item) => item !== null) : []
+			if (list.length > 0) return trimSegments(list)
+			const synthesized = []
+			if (reasoning !== '') synthesized.push({ kind: 'reasoning', text: reasoning })
+			if (answer !== '') synthesized.push({ kind: 'text', text: answer })
+			return synthesized
+		}
+
 		/**
 		 * 面板状态 store：按 (sessionId, paneId) 分桶，切 tab / 切会话后仍能恢复。
 		 * 极小实现（不引入官方 `dsh-client-store` 包）：read/write/subscribe。
@@ -546,7 +641,10 @@ window.__ModuleLoader__.load({
 				question: '',
 				/**
 				 * 多轮追问：**轮次数组**。
-				 * 每轮 = `{ id, question, answer, reasoning, tool, phase, error, newSegment }`。
+				 * 每轮 = `{ id, question, answer, reasoning, tool, segments, phase, error, newSegment }`。
+				 * ★ `segments` = **有序段落**（`{kind:'reasoning'|'text'|'tool', text}`）：一个回合里
+				 *   模型可能"说一段 → 调工具 → 再说一段"，面板按数组顺序渲染，中间的段落不再丢。
+				 *   `answer` / `reasoning` 仍保留（是最后一段的快捷引用，老数据也靠它们合成段落）。
 				 * `phase` ∈ `running` | `done` | `stopped` | `error`。
 				 */
 				rounds: [],
@@ -569,6 +667,16 @@ window.__ModuleLoader__.load({
 				 * ⇒ 切 tab / 切会话回来仍在（与本面板其它状态同源）。
 				 */
 				selection: null,
+				/**
+				 * ★ 层 1：主会话**这次**贡献了多少（宿主在 `/start` 响应里给）。
+				 * `{ turns, chars }`；`null` = 宿主还没说过（老数据 / 还没提过问）。
+				 */
+				synced: null,
+				/**
+				 * ★ 层 1：本段**注入给模型的分支引导词全文**（宿主在第一轮告诉我们的）。
+				 * 只用于"让用户看见到底注入了什么"；模型看到的文本一律英文，与界面语言无关。
+				 */
+				notice: '',
 			})
 			/** key 的分隔符（`sessionId\0paneId`）。 */
 			const SEP = String.fromCharCode(0)
@@ -588,19 +696,32 @@ window.__ModuleLoader__.load({
 				}
 				return undefined
 			})()
-			/** 字符串收敛（超长截断；非字符串给空串）。 */
-			const clampString = (value, max) => (typeof value === 'string' ? value.slice(0, max) : '')
+			/** `synced`（`{turns, chars}`）的形状校验；坏数据当 `null`。 */
+			const normalizeSynced = (raw) => {
+				if (raw === null || raw === undefined || typeof raw !== 'object') return null
+				const turns = typeof raw.turns === 'number' && Number.isFinite(raw.turns) ? Math.max(0, Math.floor(raw.turns)) : 0
+				const chars = typeof raw.chars === 'number' && Number.isFinite(raw.chars) ? Math.max(0, Math.floor(raw.chars)) : 0
+				return { turns, chars }
+			}
 			/** 一轮的形状校验（补默认；坏数据不进面板）。 */
 			const normalizeRound = (raw) => {
 				const round = raw !== null && typeof raw === 'object' ? raw : {}
+				const answer = clampString(round.answer, 200000)
+				const reasoning = clampString(round.reasoning, 200000)
 				return {
 					id: clampString(round.id, 64),
 					question: clampString(round.question, 20000),
-					answer: clampString(round.answer, 200000),
-					reasoning: clampString(round.reasoning, 200000),
+					// ★ 引用原文（随轮入档）⇒ 刷新后引用块还在。
+					//   上限对齐 `MAX_REFERENCE_LENGTH`，再多留一点给截断标记
+					//   （标记是在切片**之后**追加的，见 clipReference）。
+					reference: clampString(round.reference, MAX_REFERENCE_LENGTH + 64),
+					answer,
+					reasoning,
 					// ⚠️ `tool` 必须一起落盘：刷新页面后要**续上**未结束的流，
 					//    少了它，重连回来的那一轮就不显示「正在使用工具：…」了。
 					tool: clampString(round.tool, 200),
+					// ★ 多段：老数据没有它 ⇒ 由 `reasoning`/`answer` 合成（见 `normalizeSegments`）
+					segments: normalizeSegments(round.segments, answer, reasoning),
 					phase: typeof round.phase === 'string' ? round.phase : 'done',
 					error: clampString(round.error, 4000),
 					newSegment: round.newSegment === true,
@@ -628,6 +749,9 @@ window.__ModuleLoader__.load({
 					busy: raw.busy === true,
 					jobId: typeof raw.jobId === 'string' && raw.jobId !== '' ? raw.jobId : null,
 					selection: normalizeSelection(raw.selection),
+					// ★ 层 1 的两项：主会话贡献摘要 + 注入的分支引导词全文
+					synced: normalizeSynced(raw.synced),
+					notice: clampString(raw.notice, 4000),
 				}
 			}
 			/** 读回一次（坏 JSON / 坏形状一律当空；只读不写）。 */
@@ -880,8 +1004,27 @@ window.__ModuleLoader__.load({
 			'panel.openTabHint': '无法自动打开右侧栏（{message}）——请手动展开，并在「临时会话」中继续',
 			// 引用块左侧那颗「引用」chip 的文字
 			'panel.quoteChip': '引用',
-			// 工具调用提示行（白名单放行后模型会真的调 read/grep 等，只显示工具名）
-			'panel.toolPrefix': '运行：',
+			// ★ 轮次里那个可折叠的引用块（引用随轮入档）——与「思考 · N 字」同款形态
+			'panel.referenceChip': '引用原文 · {n} 字',
+			// 工具已经调过（多段渲染里工具是**段落序列**的一员，跑完仍要看得见）
+			'panel.toolUsed': '工具：',
+			// ★ 层 1：「继承了什么」那一行（re-fork：每轮追问都用主会话**最新**内容重建历史）
+			'panel.inheritedLine': '已继承主会话 {turns} 轮 · 约 {chars} 字',
+			'panel.inheritedNone': '尚未继承任何已完成的回合（主会话还没有答完一轮）',
+			'panel.inheritedShow': '查看继承内容',
+			'panel.inheritedHide': '收起继承内容',
+			'panel.inheritedLoading': '正在读取继承内容…',
+			'panel.inheritedTurn': '第 {n} 轮',
+			'panel.inheritedAsk': '问',
+			'panel.inheritedAnswer': '答',
+			// ★ 主会话的**思考**也在继承里（种子里的 reasoning 块；会作为 thinking 发给模型）
+			'panel.inheritedThink': '思考',
+			'panel.inheritedChars': '{n} 字',
+			'panel.inheritedTruncated': '（已截断，仅显示摘要）',
+			'panel.inheritedNewer': '主会话此后又有新回合；下一次追问会带上它们',
+			// ★ 层 1：注入给模型的分支引导词（本插件注入的**只有它**；系统提示词/工具声明是 DSH 自己组装的）
+			'panel.noticeLine': '注入给模型的分支引导词',
+			'panel.noticeHint': '（英文，与界面语言无关；改它会让本段的前缀缓存失效）',
 			// 可折叠的「思考」行（数值/CSS 照官方 `ReasoningRow`）
 			'panel.think': '思考',
 			// ★ 「清空」= 输入栏左下角那个按钮（结束这一段并另起一段）。
@@ -941,7 +1084,25 @@ window.__ModuleLoader__.load({
 			'panel.streamLost': 'Connection lost. Retry later or check logs.',
 			'panel.openTabHint': 'Could not open the right sidebar automatically ({message}) — expand it and continue in "Side Ask"',
 			'panel.quoteChip': 'Quote',
-			'panel.toolPrefix': 'Running: ',
+			'panel.referenceChip': 'Quoted text · {n} chars',
+			// 工具已经调过（多段渲染里工具是**段落序列**的一员，跑完仍要看得见）
+			'panel.toolUsed': 'Tool: ',
+			// ★ 层 1：「继承了什么」那一行（与中文词典**同键集**）
+			'panel.inheritedLine': 'Inherited {turns} main-session turns · ~{chars} chars',
+			'panel.inheritedNone': 'Nothing inherited yet (the main session has not finished a turn)',
+			'panel.inheritedShow': 'Show inherited content',
+			'panel.inheritedHide': 'Hide inherited content',
+			'panel.inheritedLoading': 'Loading inherited content…',
+			'panel.inheritedTurn': 'Turn {n}',
+			'panel.inheritedAsk': 'Q',
+			'panel.inheritedAnswer': 'A',
+			'panel.inheritedThink': 'Thinking',
+			'panel.inheritedChars': '{n} chars',
+			'panel.inheritedTruncated': '(truncated to a summary)',
+			'panel.inheritedNewer': 'The main session has newer turns; the next follow-up will include them',
+			// ★ 层 1：注入给模型的分支引导词
+			'panel.noticeLine': 'Branch notice injected into the model',
+			'panel.noticeHint': '(English regardless of interface language; changing it invalidates this segment\u2019s prefix cache)',
 			// 多轮追问（与中文词典**同键集**，两边必须同时改）
 			'panel.think': 'Thinking',
 			'panel.clearChat': 'Clear',
@@ -1119,6 +1280,8 @@ window.__ModuleLoader__.load({
 			const listModels = props.listModels
 			/** ★ 设置的读写（宿主半的 `/side-branch/settings`）。 */
 			const fetchSettings = props.fetchSettings
+			/** ★ 层 2：按需读「继承到的主会话历史」（只读，结果只放内存）。 */
+			const fetchInherited = props.fetchInherited
 			const saveSettings = props.saveSettings
 
 			/**
@@ -1151,6 +1314,10 @@ window.__ModuleLoader__.load({
 			const rounds = Array.isArray(state.rounds) ? state.rounds : []
 			/** 这一段临时会话在宿主侧的会话 id（`null` = 下次提问新开一段）。 */
 			const conversationId = typeof state.conversationId === 'string' && state.conversationId !== '' ? state.conversationId : null
+			/** ★ 层 1：主会话这次贡献了多少（`{turns, chars}`；宿主在 `/start` 里给）。 */
+			const synced = state.synced ?? null
+			/** ★ 层 1：本段注入给模型的分支引导词全文（宿主在第一轮给）。 */
+			const notice = typeof state.notice === 'string' ? state.notice : ''
 			const error = state.error
 			const busy = state.busy
 			/** 模型覆盖：`null` = 跟随会话 */
@@ -1176,6 +1343,99 @@ window.__ModuleLoader__.load({
 				return Array.isArray(list) && list.length > 0 ? list[list.length - 1] : undefined
 			}
 
+			// ── ★ 多段（有序段落）的写入助手 ─────────────────────────────────────
+			//
+			// 为什么要有它们：一个回合里模型可能"说一段 → 调工具 → 再说一段"，
+			// 每一段都会开一次新的流式 attempt（宿主因此发 `segment` 事件）。
+			// 渲染必须**按段落的数组顺序**，所以写入也只能往这个序列里追加，
+			// 而不是像老版本那样只往 `answer` 这一个字符串上拼。
+			/** 读当前轮的段落数组（永远是数组）。 */
+			const currentSegments = () => {
+				const current = currentRound()
+				return current !== undefined && Array.isArray(current.segments) ? current.segments : []
+			}
+			/**
+			 * 段落数组 → 两个快捷引用（`answer`/`reasoning`）。
+			 *
+			 * ⚠️ 语义与**宿主完全一致**：= 本轮**全部**正文段落（或推理段落）按顺序拼接。
+			 *   两处算法必须是同一个，否则 `snapshot` 回来时会把面板上的正文"改短"。
+			 * @param {Array<object>} list - 段落数组
+			 * @returns {{answer: string, reasoning: string}}
+			 */
+			const shortcutsOf = (list) => {
+				let answer = ''
+				let reasoning = ''
+				for (const segment of list) {
+					if (segment.kind === 'text') answer += segment.text
+					else if (segment.kind === 'reasoning') reasoning += segment.text
+				}
+				return { answer, reasoning }
+			}
+			/**
+			 * 往当前轮追加内容：与**最后一段**同 kind（且同 turn/step）⇒ 接着写这一段；否则**开新段**。
+			 *
+			 * ⚠️ **一次写入**（段落 + 快捷引用同一个 patch）：`patchRound` 每调一次都会通知订阅者
+			 *   重渲染，逐词流式下一帧写两次会让每个 token 渲染两遍。
+			 * @param {'reasoning'|'text'|'tool'} kind - 段落种类
+			 * @param {string} text - 追加的文本（工具段是工具名）
+			 * @param {number|undefined} turn - 宿主给的归属（用于 `reset` 精确定位）
+			 * @param {number|undefined} step - 同上
+			 */
+			const appendSegment = (kind, text, turn, step) => {
+				const current = currentRound()
+				if (current === undefined) return
+				const list = (Array.isArray(current.segments) ? current.segments : []).slice()
+				const last = list[list.length - 1]
+				const samePlace = last !== undefined && last.turn === turn && last.step === step
+				if (last !== undefined && last.kind === kind && samePlace === true) {
+					list[list.length - 1] = { ...last, text: last.text + text }
+				} else {
+					const item = { kind, text }
+					if (turn !== undefined) item.turn = turn
+					if (step !== undefined) item.step = step
+					list.push(item)
+				}
+				const kept = list.slice(-MAX_SEGMENTS)
+				patchRound({ segments: kept, ...shortcutsOf(kept), ...(kind === 'tool' ? { tool: text } : {}) })
+			}
+			/**
+			 * 把当前轮**最后一段同 kind** 的文本整段替换（宿主 `replace` 事件）。
+			 * 宿主只会在"终局文本 ≠ 累积文本"时发它。
+			 */
+			const replaceLastSegment = (kind, text) => {
+				const current = currentRound()
+				if (current === undefined) return
+				const list = (Array.isArray(current.segments) ? current.segments : []).slice()
+				let found = false
+				for (let i = list.length - 1; i >= 0; i -= 1) {
+					if (list[i].kind !== kind) continue
+					list[i] = { ...list[i], text }
+					found = true
+					break
+				}
+				if (found !== true) list.push({ kind, text })
+				const kept = list.slice(-MAX_SEGMENTS)
+				patchRound({ segments: kept, ...shortcutsOf(kept) })
+			}
+			/**
+			 * 丢掉**当前 step** 已经产出的段落（宿主 `reset` 事件 = 同一个 step 内重试）。
+			 *
+			 * 判据优先用宿主给的 `turn`/`step`（**精确定位**）；拿不到就退回"这一步段落的起点下标"
+			 * （`segmentMarkRef`，在收到 `segment` / `snapshot` 时记录）。
+			 * ⚠️ 绝不能整轮清空 —— 那样前面几个 step 的思考与正文又会被抹掉（就是那个 BUG）。
+			 * @param {number|undefined} turn - 宿主 `reset` 载荷里的回合号
+			 * @param {number|undefined} step - 同上
+			 */
+			const dropCurrentStepSegments = (turn, step) => {
+				const list = currentSegments()
+				const precise = typeof turn === 'number' && typeof step === 'number'
+				const kept = precise
+					? list.filter((segment) => !(segment.turn === turn && segment.step === step))
+					: list.slice(0, typeof segmentMarkRef.current === 'number' ? segmentMarkRef.current : 0)
+				patchRound({ segments: kept, ...shortcutsOf(kept), tool: '' })
+				segmentMarkRef.current = kept.length
+			}
+
 			// ── 模型选择器的 UI 状态（只有 `selection` 需要持久 ⇒ 那个在 store 里）
 			/** 官方模型目录快照；`null` = 还没拉过 */
 			const [models, setModels] = react.useState(null)
@@ -1197,6 +1457,39 @@ window.__ModuleLoader__.load({
 			/** 悬浮窗元素（用来量尺寸 / 判断"点到里面没有"）。 */
 			const menuRef = react.useRef(null)
 
+			// ── ★ 层 2：「继承来的主会话历史」按需展开 ───────────────────────────
+			//
+			// ⛔ **这份数据只放内存，绝不进 `rounds` / `normalizeRound` / 持久化状态**：
+			//    一份主会话前缀可能有几十万字符，而面板状态走 `sessionStorage`（5–10 MB 配额），
+			//    塞进去会立刻爆配额、坏掉"刷新不丢"这个现有特性。所以每次展开**按需向宿主拉一次**。
+			const [inherited, setInherited] = react.useState(null)
+			const [inheritedOpen, setInheritedOpen] = react.useState(false)
+			const [inheritedBusy, setInheritedBusy] = react.useState(false)
+			const [inheritedError, setInheritedError] = react.useState('')
+			/** 换段（re-fork）之后旧的那份继承内容就作废 ⇒ 关掉并丢掉。 */
+			react.useEffect(() => {
+				setInherited(null)
+				setInheritedError('')
+			}, [conversationId])
+			/** 展开时按需拉一次（收起不拉；`conversationId` 为空时没法拉）。 */
+			const toggleInherited = async () => {
+				const next = inheritedOpen !== true
+				setInheritedOpen(next)
+				if (next !== true || inherited !== null || inheritedBusy === true) return
+				if (typeof conversationId !== 'string' || conversationId === '') return
+				setInheritedBusy(true)
+				setInheritedError('')
+				try {
+					const data = await fetchInherited(conversationId)
+					if (data?.error !== undefined) throw new Error(String(data.error))
+					setInherited(data)
+				} catch (cause) {
+					setInheritedError(errorText(cause, t))
+				} finally {
+					setInheritedBusy(false)
+				}
+			}
+
 			// 官方行为：**点菜单外部就关**（`model-selection\lib\client.js:448-452` 的 closeOutside）。
 			//
 			// 用 `closest('[data-side-branch-menu],[data-side-branch-trigger]')` 判归属，而不是比 DOM 引用：
@@ -1277,6 +1570,12 @@ window.__ModuleLoader__.load({
 			const jobRef = react.useRef(state.jobId)
 			/** 防重入：不依赖 `busy` 渲染态（React 状态更新是异步的，极快双击会漏过按钮禁用） */
 			const inFlightRef = react.useRef(false)
+			/**
+			 * ★ 当前 step 在**段落数组**里的起点下标（收到宿主 `segment` 事件时刷新）。
+			 * 用途只有一个：同一 step 内重试（宿主 `reset`）时**只截掉这一个 step** 的段落。
+			 * ⚠️ 只在内存里，不进 store（它是流式期的临时记账）。
+			 */
+			const segmentMarkRef = react.useRef(0)
 
 			// ── 键盘 / IME / 自动滚底
 			/**
@@ -1318,14 +1617,30 @@ window.__ModuleLoader__.load({
 					}
 				}
 			}, [sessionId])
-			/** 答案区元素；流式时必须自动滚到底，否则新内容不可见 */
-			const answerRef = react.useRef(null)
+			/**
+			 * **真正可滚动的那一层**（`.dsh-side-branch-scroll{flex:1;min-height:0;overflow-y:auto}`）。
+			 *
+			 * ⚠️ 血的教训：这个 ref 原来挂在 `.dsh-side-branch-rounds`（轮次列表）上，而那个 div 是
+			 *   `display:flex;flex-direction:column`、**不滚动** ⇒ `scrollTop = scrollHeight` 是**空操作**，
+			 *   自动滚底其实**从来没生效过**。以前内容短、不容易看出来；0.2.0 在轮次**上面**加了
+			 *   「已继承 / 注入」那一块（可以展开成很长）之后，新答案就落到可视区之外了 ——
+			 *   现象是"问了之后面板像卡住一样，回答不出现"（其实回答已经在 DOM 里，只是没滚下去）。
+			 *   ⛔ 别把它挪回内层。
+			 */
+			const scrollRef = react.useRef(null)
 			react.useLayoutEffect(() => {
-				const node = answerRef.current
+				const node = scrollRef.current
 				if (node === null || node === undefined) return
 				node.scrollTop = node.scrollHeight
-				// 依赖：最后一轮的正文 + 推理（多轮下内容都长在最后一轮里）
-			}, [rounds.length, rounds[rounds.length - 1]?.answer, rounds[rounds.length - 1]?.reasoning])
+				// 依赖：最后一轮的正文 / 推理 / **段落数**（多段下内容都长在最后一轮里），
+				// 以及**继承区是否展开**（它也在滚动容器里，展开会把下方内容顶出去）。
+			}, [
+				rounds.length,
+				rounds[rounds.length - 1]?.answer,
+				rounds[rounds.length - 1]?.reasoning,
+				rounds[rounds.length - 1]?.segments?.length,
+				inheritedOpen,
+			])
 
 			const write = (patch) => panelStore.write(sessionId, paneId, patch)
 			/** 把异常写进面板错误框（文案在这里统一走词典）。 */
@@ -1402,50 +1717,65 @@ window.__ModuleLoader__.load({
 					if (jobRef.current !== mine) return
 					const payload = parseEvent(event)
 					if (payload === undefined) return
-					// 补连/重连：把宿主已经累积的正文与推理补进这一轮
+					// 补连/重连：把宿主已经累积的正文、推理**与有序段落**补进这一轮
 					const patch = {}
 					if (typeof payload.text === 'string' && payload.text !== '') patch.answer = payload.text
 					if (typeof payload.reasoning === 'string' && payload.reasoning !== '') patch.reasoning = payload.reasoning
+					// ★ 段落是**权威形状**（刷新/重连后靠它还原"思考 → 正文 → 工具 → 思考 → 正文"）
+					if (Array.isArray(payload.segments)) {
+						patch.segments = payload.segments.slice(-MAX_SEGMENTS).map(normalizeSegment).filter((item) => item !== null)
+					}
 					if (payload.stats !== undefined && payload.stats !== null) patch.stats = payload.stats
 					if (Object.keys(patch).length > 0) patchRound(patch)
+					// 重连时把"当前 step 的起点"对齐到段落末尾（后面的 reset 才有正确的截点）
+					segmentMarkRef.current = Array.isArray(patch.segments) ? patch.segments.length : currentSegments().length
 					if (payload.status === 'error') {
 						settle({ error: payload.error ?? t('panel.childFailed') }, 'error')
 					} else if (payload.status === 'done' || payload.status === 'stopped') {
 						settle({}, payload.status)
 					}
 				})
+				// ★ 多段：一个回合里进入下一个 step ⇒ 开一个新段（**绝不删旧的**）
+				on('segment', (event) => {
+					if (jobRef.current !== mine) return
+					segmentMarkRef.current = currentSegments().length
+				})
 				on('delta', (event) => {
 					if (jobRef.current !== mine) return
 					const payload = parseEvent(event)
 					if (payload === undefined || typeof payload.text !== 'string' || payload.text === '') return
-					// ★ 逐词追加：读当前值再拼（不依赖渲染态，避免丢字）
-					const current = currentRound()
-					patchRound({ answer: (current?.answer ?? '') + payload.text })
+					// ★ 追加到**当前段**（读当前值再拼，不依赖渲染态，避免丢字）
+					appendSegment('text', payload.text, payload.turn, payload.step)
 				})
 				// ★ v2：推理增量（官方 `reasoning-delta`）——可折叠「思考」行的内容
 				on('reasoning', (event) => {
 					if (jobRef.current !== mine) return
 					const payload = parseEvent(event)
 					if (payload === undefined || typeof payload.text !== 'string' || payload.text === '') return
-					const current = currentRound()
-					patchRound({ reasoning: (current?.reasoning ?? '') + payload.text })
+					appendSegment('reasoning', payload.text, payload.turn, payload.step)
 				})
-				on('reset', () => {
+				on('reset', (event) => {
 					if (jobRef.current !== mine) return
-					// ⚠️ 重试（新的 attempt）也要把工具提示清掉，否则上一轮的工具名会挂着
-					patchRound({ answer: '', reasoning: '', tool: '' })
+					const payload = parseEvent(event)
+					// ⚠️ **只丢当前 step**（宿主 `reset` 的语义 = 同一个 step 内重试）。
+					//    老版本在这里清空整轮 ⇒ 前面几个 step 的思考与正文全没了（就是那个 BUG）。
+					dropCurrentStepSegments(payload?.turn, payload?.step)
 				})
 				// ★ 工具调用提示：宿主只推工具名
 				on('tool', (event) => {
 					if (jobRef.current !== mine) return
 					const payload = parseEvent(event)
 					if (payload === undefined || typeof payload.name !== 'string' || payload.name === '') return
-					patchRound({ tool: payload.name })
+					// 工具也进**段落序列**（跑完之后仍然看得见"这一步用了什么"）
+					appendSegment('tool', payload.name, payload.turn, payload.step)
 				})
 				on('replace', (event) => {
 					if (jobRef.current !== mine) return
 					const payload = parseEvent(event)
-					if (payload !== undefined && typeof payload.text === 'string') patchRound({ answer: payload.text })
+					if (payload !== undefined && typeof payload.text === 'string') {
+						// ★ 只替换**当前段**（宿主也是这么发的）：老版本整段替换会把前面几段覆盖掉
+						replaceLastSegment('text', payload.text)
+					}
 				})
 				// ⚠️ 终态事件**要带上载荷**（v2：里面有 `stats` 用量摘要），别写成 `settle({})`
 				on('done', (event) => settle(parseEvent(event) ?? {}, 'done'))
@@ -1654,13 +1984,22 @@ window.__ModuleLoader__.load({
 				inFlightRef.current = true
 				// 有引用时把原文包进结构化信封（动态围栏 + 8000 上限 + 反注入声明）；
 				// 无引用时就是问题本身。实现见 buildReferenceEnvelope。
-				const composed = buildReferenceEnvelope(text, quoted, t)
+				//
+				// ★ 引用原文**只收窄一次**（`clipReference`），同一份既进 prompt 信封、
+				//   又进这一轮的记录 ⇒ 面板上看到的引用与模型收到的**逐字一致**。
+				//   （`buildReferenceEnvelope` 内部也会 `clipReference`，但它对已收窄的文本
+				//     是**幂等**的 —— 见那个函数的注释。）
+				const reference = quoted === '' ? '' : clipReference(quoted).text
+				const composed = buildReferenceEnvelope(text, reference, t)
 				closeStream()
 				jobRef.current = null
 				const round = {
 					id: 'r' + Date.now().toString(36),
 					// 面板上显示的是**原话**（引用信封不进界面）。⚠️ 问题必非空（ask 的守卫已挡住空问题）
 					question: text,
+					// ★ 这一轮带进来的**引用原文**（空串 = 没引用）。随轮入档 ⇒ 渲染成可折叠的
+					//   引用块，刷新后也还在；不再只是输入框上方那个"随时会消失"的临时槽。
+					reference,
 					answer: '',
 					reasoning: '',
 					phase: 'running',
@@ -1670,6 +2009,11 @@ window.__ModuleLoader__.load({
 				}
 				// 草稿清空、追加新轮、清掉上一轮的错误框
 				write({ busy: true, error: '', question: '', rounds: [...rounds, round], jobId: null })
+				// ★ 引用已经**随这一轮入档** ⇒ 引用槽立刻清空（下一轮从干净的输入框开始）。
+				//   ⚠️ 必须连 `quoteBus` 一起清：只清组件 state 的话，面板重挂载 / 换格时
+				//     会把同一份引用**再捞回来**（与「清除引用」按钮是同一个动作）。
+				quoteBus.clear(sessionId, paneId)
+				setQuote('')
 				try {
 					if (sessionId === undefined || sessionId === null) throw new Error(t('panel.noSession'))
 					// 只有显式选过模型才把覆盖发下去（`null` ⇒ 宿主取父会话当下的模型）
@@ -1704,9 +2048,15 @@ window.__ModuleLoader__.load({
 					write({
 						jobId,
 						// 宿主确认/新建的侧会话 id —— 下一轮靠它继续。
-						// ⚠️ 换模型时宿主会**带历史**换段并回一个新的 id（`handoff: true`）——
-						//    那一段里含上面所有轮次，所以**不画分隔线**、历史在视觉上连续。
+						// ⚠️ **re-fork：每轮追问宿主都会新建一段侧会话 ⇒ 这个 id 每轮都变**，
+						//    所以这里必须**每轮都更新**它（否则下一轮拿着已释放的 id 去问，会被拒）。
+						//    宿主每轮都会回 `handoff: true` ⇒ 下面那条"换段就画分隔线"的判据不会误触发，
+						//    历史在视觉上是连续的（它**确实**是连续的：旧问答都被重放进新段了）。
 						conversationId: typeof started?.conversationId === 'string' ? started.conversationId : revived === true ? null : conversationId,
+						// ★ 层 1：宿主告诉我们"这一次继承了多少"，以及**注入的分支引导词全文**
+						//   （引导词只有**第一轮**会拼，所以只有那时候宿主才回它）
+						...(started?.synced === undefined || started.synced === null ? {} : { synced: started.synced }),
+						...(typeof started?.notice === 'string' && started.notice !== '' ? { notice: started.notice } : {}),
 					})
 					// 宿主说"这段已不存在 / 已回收"，或**没带历史**地换了段（换了 id 且不是 handoff）
 					// ⇒ 上面那些轮次不再进模型，给他画一条分隔线，如实说明
@@ -1907,29 +2257,34 @@ window.__ModuleLoader__.load({
 				footnotes: t('panel.footnotes'),
 			}
 			/**
-			 * 一轮的正文渲染。
-			 * @param {object} round - 一轮
-			 * @param {boolean} streaming - 这一轮是否仍在流式（只有最后一轮可能为真）
+			 * 一段正文的渲染。
+			 * @param {string} text - 这一段的正文
+			 * @param {boolean} streaming - 这一段是否仍在流式（只有最后一轮的最后一段可能为真）
 			 */
-			const renderAnswer = (round, streaming) => {
+			const renderAnswer = (text, streaming) => {
 				// ⚠️ 判断条件必须是 `!= null`：`MarkdownText` 是 `React.memo` 的对象（见文件头注释），
 				//    用 `typeof === 'function'` 会永远为假 —— 会一直退回纯文本。
 				if (MarkdownText != null) {
 					return react.createElement(
 						// 安全网：官方组件抛异常时只让"这条答案"退回纯文本，不让整个面板白屏
 						MarkdownBoundary,
-						{ key: 'md', text: round.answer },
-						react.createElement(MarkdownText, { text: round.answer, streaming, labels }),
+						{ key: 'md', text },
+						react.createElement(MarkdownText, { text, streaming, labels }),
 					)
 				}
 				return react.createElement(
 					'div',
 					{ key: 'plain', style: { whiteSpace: 'pre-wrap', wordBreak: 'break-word' } },
-					round.answer,
+					text,
 				)
 			}
 
-			/** 一轮的完整渲染：问题气泡 →（可选）可折叠「思考」行 →（可选）工具行 → 答案 → 轮次小标签。 */
+			/**
+			 * 一轮的完整渲染：问题气泡 → **按段落数组顺序**的（思考行 / 工具行 / 正文）→ 轮次小标签。
+			 *
+			 * ★ 为什么按数组顺序：一个回合里模型可能"说一段 → 调工具 → 再说一段"，
+			 *   老版本只有 `reasoning`/`answer`/`tool` 三个槽位 ⇒ 中间的段落必然被覆盖掉。
+			 */
 			const renderRound = (round, index) => {
 				const streaming = round.phase === 'running' && index === rounds.length - 1
 				const children = []
@@ -1937,34 +2292,61 @@ window.__ModuleLoader__.load({
 				//   ① 宿主回 `conversationGone`（插件重载 / DSH 重启后，睡着的记录随内存消失）
 				//      后自动重开 ⇒ `ask` 补置 `newSegment`；
 				//   ② 宿主没带 `handoff` 地换了段（`ask` 里的兜底判据，正常路径走不到）。
-				//   换模型 = `handoff` 带历史换段、**不画**；「清空」把面板清空（`rounds` 为 0）、
-				//   闲置唤醒是同一个 id ⇒ 这两种也不会画。
+				//   ⚠️ re-fork（每轮都用主会话最新内容重建历史）**带** `handoff: true` ⇒ **不画**：
+				//      它的历史是接得上的，画了反而误导。
+				//   「清空」把面板清空（`rounds` 为 0）、闲置唤醒是同一个 id ⇒ 这两种也不会画。
 				if (round.newSegment === true) {
 					children.push(react.createElement('div', { key: 'seg', className: 'dsh-side-branch-segbreak' }, t('panel.segmentBreak')))
 				}
+				// ⓪ 这一轮带进来的**引用原文**（可折叠引用块；没有引用时**什么都不渲染**）。
+				//   引用可能到 `MAX_REFERENCE_LENGTH` ⇒ 必须可折叠，且内容区自己滚。
+				if (typeof round.reference === 'string' && round.reference !== '') {
+					children.push(
+						react.createElement(
+							'details',
+							{ key: 'ref', className: 'dsh-side-branch-refblock' },
+							react.createElement('summary', { className: 'dsh-side-branch-refsummary' }, t('panel.referenceChip', { n: round.reference.length })),
+							react.createElement('blockquote', { className: 'dsh-side-branch-refbody' }, round.reference),
+						),
+					)
+				}
 				// ① 问题在**答案上方**（样式照官方主会话的用户气泡）
 				if (typeof round.question === 'string' && round.question !== '') {
 					children.push(react.createElement('div', { key: 'q', className: 'dsh-side-branch-qbubble' }, round.question))
 				}
-				const hasReasoning = typeof round.reasoning === 'string' && round.reasoning !== ''
-				if (hasReasoning) {
-					children.push(react.createElement(ReasoningRow, { key: 'think', text: round.reasoning, running: streaming, t }))
-				}
-				// ②b 工具调用提示行（只在运行中显示；终态后自动消失）
-				if (streaming === true && typeof round.tool === 'string' && round.tool !== '') {
+				// ② **有序段落**（思考 → 正文 → 工具 → 思考 → 正文 …）
+				const segments = Array.isArray(round.segments) ? round.segments : []
+				segments.forEach((segment, i) => {
+					const isLast = i === segments.length - 1
+					if (segment.kind === 'reasoning') {
+						children.push(
+							react.createElement(ReasoningRow, {
+								key: 'think' + i,
+								text: segment.text,
+								running: streaming === true && isLast === true,
+								t,
+							}),
+						)
+						return
+					}
+					if (segment.kind === 'tool') {
+						// 工具行**跑完也保留**：它是"这一步干了什么"的记录（老版本只在流式时显示）
+						children.push(
+							react.createElement('div', { key: 'tool' + i, className: 'dsh-side-branch-toolline' }, t('panel.toolUsed') + segment.text),
+						)
+						return
+					}
 					children.push(
-						react.createElement('div', { key: 'tool', className: 'dsh-side-branch-toolline' }, t('panel.toolPrefix') + round.tool),
+						react.createElement(
+							'div',
+							{ key: 'a' + i },
+							segment.text === '' ? '' : renderAnswer(segment.text, streaming === true && isLast === true),
+						),
 					)
-				}
-				// ③ 正文（还没出字就什么都不画：运行状态由工具行的**停止键**表达）
-				children.push(
-					react.createElement(
-						'div',
-						{ key: 'a' },
-						round.answer === '' ? '' : renderAnswer(round, streaming),
-					),
-				)
-				// ④ 轮次小标签：已停止 / 出错（终态可见，而不是只留在错误框里）
+				})
+				// 还没有任何段落时也占一个位（运行状态由工具行的**停止键**表达）
+				if (segments.length === 0) children.push(react.createElement('div', { key: 'a-empty' }, ''))
+				// ③ 轮次小标签：已停止 / 出错（终态可见，而不是只留在错误框里）
 				if (round.phase === 'stopped' || round.phase === 'error') {
 					children.push(
 						react.createElement(
@@ -1977,11 +2359,122 @@ window.__ModuleLoader__.load({
 				return react.createElement('div', { key: round.id ?? String(index), className: 'dsh-side-branch-round' }, ...children)
 			}
 
+			// ── ★ 层 1 / 层 2：「继承了什么 / 注入了什么」────────────────────────
+			//
+			// 分两样东西，别混：
+			//   · **继承来的主会话历史**（seed）：每轮追问都会用主会话**最新**的已结算前缀重建 ⇒
+			//     这一行告诉用户"这一次带上了多少"，点开按需拉内容（层 2，只放内存）。
+			//   · **分支引导词**：本插件**唯一**注入给模型的东西（系统提示词/工具声明是 DSH 自己组装的，
+			//     不属于本插件，显示它们会误导用户以为插件能改）。
+			const metaChildren = []
+			if (synced !== null && (synced.turns > 0 || synced.chars > 0)) {
+				const toggleLabel = inheritedOpen === true ? t('panel.inheritedHide') : t('panel.inheritedShow')
+				metaChildren.push(
+					react.createElement(
+						'button',
+						{
+							key: 'synced',
+							type: 'button',
+							className: 'dsh-side-branch-metaline',
+							// ⚠️ 没有 `conversationId` 就没法按需拉内容（那说明这一段还没在宿主侧建立）
+							disabled: conversationId === null,
+							title: toggleLabel,
+							'aria-label': toggleLabel,
+							'aria-expanded': inheritedOpen === true,
+							onClick: () => {
+								void toggleInherited()
+							},
+						},
+						(inheritedOpen === true ? '▾ ' : '▸ ') + t('panel.inheritedLine', { turns: synced.turns, chars: synced.chars }),
+					),
+				)
+			} else if (rounds.length > 0) {
+				metaChildren.push(react.createElement('div', { key: 'synced-none', className: 'dsh-side-branch-metaline' }, t('panel.inheritedNone')))
+			}
+			if (inheritedOpen === true) {
+				if (inheritedBusy === true) {
+					metaChildren.push(react.createElement('div', { key: 'inh-loading', className: 'dsh-side-branch-inherited' }, t('panel.inheritedLoading')))
+				} else if (inheritedError !== '') {
+					metaChildren.push(react.createElement('div', { key: 'inh-err', className: 'dsh-side-branch-inherited' }, inheritedError))
+				} else if (inherited !== null) {
+					const turns = Array.isArray(inherited.turns) ? inherited.turns : []
+					const rows = turns.map((entry, i) => {
+						// 最后一轮**默认展开**（全文）；更早的每轮只有宿主给的一行摘要。
+						const isLast = i === turns.length - 1
+						const body = []
+						if (entry.question !== '') {
+							body.push(
+								react.createElement(
+									'div',
+									{ key: 'q', className: 'dsh-side-branch-inhrow' },
+									react.createElement('span', { className: 'dsh-side-branch-inhtag' }, t('panel.inheritedAsk')),
+									react.createElement('span', null, entry.question),
+								),
+							)
+						}
+						// ★ 主会话的**思考**也在继承里（种子里的 `reasoning` 块，会作为 `thinking` 发给模型）
+						//   ⇒ 单独一层可折叠，别让它看起来像"没继承"。
+						if (typeof entry.reasoning === 'string' && entry.reasoning !== '') {
+							body.push(
+								react.createElement(
+									'details',
+									{ key: 'think', className: 'dsh-side-branch-inhthink' },
+									react.createElement(
+										'summary',
+										null,
+										t('panel.inheritedThink') + ' · ' + t('panel.inheritedChars', { n: entry.reasoningChars ?? entry.reasoning.length }),
+									),
+									react.createElement('pre', { className: 'dsh-side-branch-notice' }, entry.reasoning),
+								),
+							)
+						}
+						if (entry.answer !== '') {
+							body.push(
+								react.createElement(
+									'div',
+									{ key: 'a', className: 'dsh-side-branch-inhrow' },
+									react.createElement('span', { className: 'dsh-side-branch-inhtag' }, t('panel.inheritedAnswer')),
+									react.createElement('span', null, entry.answer),
+								),
+							)
+						}
+						return react.createElement(
+							'details',
+							{ key: 'turn' + i, className: 'dsh-side-branch-inhturn', open: isLast },
+							react.createElement(
+								'summary',
+								null,
+								t('panel.inheritedTurn', { n: entry.turn }) + (entry.truncated === true ? ' ' + t('panel.inheritedTruncated') : ''),
+							),
+							...body,
+						)
+					})
+					metaChildren.push(react.createElement('div', { key: 'inh', className: 'dsh-side-branch-inherited' }, ...rows))
+					if (inherited.parentHasNewer === true) {
+						metaChildren.push(
+							react.createElement('div', { key: 'inh-newer', className: 'dsh-side-branch-metaline' }, t('panel.inheritedNewer')),
+						)
+					}
+				}
+			}
+			if (notice !== '') {
+				metaChildren.push(
+					react.createElement(
+						'details',
+						{ key: 'notice', className: 'dsh-side-branch-inhturn' },
+						react.createElement('summary', null, t('panel.noticeLine') + ' ' + t('panel.noticeHint')),
+						// 引导词**逐字**展示（它就是模型看到的那份英文原文）
+						react.createElement('pre', { className: 'dsh-side-branch-notice' }, notice),
+					),
+				)
+			}
+			const metaBlock =
+				metaChildren.length === 0 ? null : react.createElement('div', { key: 'meta', className: 'dsh-side-branch-meta' }, ...metaChildren)
+
 			const answerBlock = react.createElement(
 				'div',
 				{
 					key: 'answer',
-					ref: answerRef,
 					className: 'dsh-side-branch-rounds',
 					// 可访问性：流式逐段到达，`role=status` = aria-live polite
 					role: 'status',
@@ -2470,7 +2963,7 @@ window.__ModuleLoader__.load({
 					onMouseDownCapture: claimActive,
 					onFocusCapture: claimActive,
 				},
-				react.createElement('div', { className: 'dsh-side-branch-scroll' }, errorBlock, answerBlock),
+				react.createElement('div', { className: 'dsh-side-branch-scroll', ref: scrollRef }, errorBlock, metaBlock, answerBlock),
 				composer,
 				settingsPanel,
 				usageLine,
@@ -2695,18 +3188,52 @@ window.__ModuleLoader__.load({
 		}
 
 		/**
-		 * 划选命中范围的**黑名单闸**。
+		 * 选区是否落在**主会话正文区**里（「引用并提问」入口的作用域）。
+		 *
+		 * ★ 0.2.2 修的缺陷：入口的监听挂在 `document` 上（这样"在会话里划字就能用"），
+		 *   而 DSH 页面里除了主会话还有**右栏面板**（文件预览、设置、其它插件的面板、本插件面板）
+		 *   与**设置弹层**，它们都在同一棵 DOM 下 ⇒ 只靠输入框黑名单挡不住：
+		 *   用户在右栏打开的 md 里划字，也会弹出「引用并提问」，点下去就把**不属于主会话**的原文
+		 *   引进了侧枝的 prompt。
+		 *
+		 * 判据（官方 DOM 标记，已核对 0.2.1-rc.3 的 `dsh-client-ui-conversation`）：
+		 *   · 主会话正文 = `[data-conversation-content]`（其内是 `[data-conversation-scroll]`，
+		 *     消息列表与 composer 座位都在里面）；
+		 *   · composer 座位 = `[data-conversation-region="composer"]` ⇒ 排除（输入框另有黑名单）；
+		 *   · **右栏** = `[data-sidebar-right-panel]` ⇒ 排除。这一条不能省：
+		 *     子代理的嵌入会话（右栏里的 sidebar chat）**也带 `[data-conversation-content]`**，
+		 *     只判正文标记会把"子会话的正文"当成主会话。
+		 *   · 找不到任何会话正文标记 ⇒ **不弹**（fail-closed）。宁可少一个入口，
+		 *     也不要引用来源不明的文字；旧版 DSH 上这个入口会因此不出现（已登记在 CHANGELOG）。
+		 *
+		 * @param {Element} element - 选区起点所在的元素
+		 * @returns {boolean} 是否允许弹出「引用并提问」
+		 */
+		function insideMainConversation(element) {
+			// `[data-conversation-scroll]` 是兜底：0.1.7 一代只有它、没有 `-content`
+			const surface = element.closest('[data-conversation-content], [data-conversation-scroll]')
+			if (surface === null) return false
+			// 右栏的三个标记都要判：panel = 右栏根；session = 同一根上的会话归属；
+			// chat = 右栏里"带会话的标签页"（子代理的嵌入会话就在里面，它自己也有正文标记）
+			if (element.closest('[data-sidebar-right-panel], [data-sidebar-right-session], [data-sidebar-chat]') !== null) return false
+			if (element.closest('[data-conversation-region="composer"]') !== null) return false
+			return true
+		}
+
+		/**
+		 * 划选命中范围的**黑名单闸**（黑名单 + 主会话正文白名单，见 `insideMainConversation`）。
 		 *
 		 * 为什么必须有：composer（Lexical 输入区）与 `[data-conversation-scroll]` 在**同一个容器**内
 		 * （`official-ui-conversation\lib\client.js:14953-14956`），
 		 * 所以"在输入框里划字"会被当成"划选了会话原文"引用并发给子代理 —— **这是信任级缺陷**。
 		 *
 		 * 契约取舍：
-		 *   · **只加黑名单，不加白名单**。另一种做法用
-		 *     `closest('[data-chat-flow-kind="assistant-step"|"assistant"|"user"]')` 做白名单，
-		 *     但那是**私有契约**（官方核心包里存在、`.d.ts` 与 README 里零命中），
-		 *     宿主一改属性名，入口就会**整体消失**（fail-closed）——刻意不这么做。
-		 *   · 将来若要用 `data-chat-flow-*`，只能是"**有则收窄、无则退回本黑名单**"的 fail-open。
+		 *   · **不做"消息级"白名单**。`closest('[data-chat-flow-kind="assistant-step"|"assistant"|"user"]')`
+		 *     看着更准，但那是**私有契约**（官方核心包里存在、`.d.ts` 与 README 里零命中），
+		 *     而且粒度是"行"不是"消息"；用它会把入口绑死在更细的内部结构上。
+		 *   · **做"正文区级"白名单**（`insideMainConversation`）：`[data-conversation-content]`
+		 *     / `[data-conversation-scroll]` 是会话外壳自己的标记（右栏面板、设置弹层、左侧列表里都没有），
+		 *     恰好回答"这段文字属不属于某个会话的正文"。找不到标记时**不弹**（fail-closed）。
 		 *
 		 * @param selection - 当前 `window.getSelection()`（可能为 null）
 		 * @returns 合法的选区文本（已 trim）；不合法时为 `''`（调用方据此隐藏按钮）
@@ -2721,8 +3248,17 @@ window.__ModuleLoader__.load({
 			const startElement = anchorNode.nodeType === 1 ? anchorNode : anchorNode.parentElement
 			if (startElement === null || startElement === undefined) return ''
 
-			const refused = 'input, textarea, button, [contenteditable]:not([contenteditable="false"]), [hidden]'
+			// ⚠️ `refused` 里那两段**本插件自己的**选择器是必需的，别删：
+			//   · `.dsh-side-branch-panel` = 临时会话面板的整棵子树（面板根就这一个类）。
+			//     少了它，用户在**侧枝里**划选文字时也会弹出「引用并提问」—— 而这个按钮的语义是
+			//     "把**主会话**里的原文引用进来"。在侧枝里点它会把这**一段自己的**问题气泡/答案/
+			//     引导词原文引用回**同一段**，形成自指循环（`quoteBus` 按最后聚焦的面板投递，
+			//     所以它确实会投给自己）。侧枝要追问，直接在输入框里写就行，不需要引用入口。
+			//   · `[data-side-branch-menu]` = 模型选择悬浮窗（挂在 `document.body` 下，不在面板子树里）。
+			const refused = 'input, textarea, button, [contenteditable]:not([contenteditable="false"]), [hidden], .dsh-side-branch-panel, [data-side-branch-menu]'
 			if (startElement.closest(refused) !== null) return ''
+			// ★ 只允许**主会话正文区**（见 insideMainConversation；0.2.2 修的"右栏/设置里划字也弹"）
+			if (insideMainConversation(startElement) === false) return ''
 
 			const text = String(selection.toString()).trim()
 			return text
@@ -2941,6 +3477,24 @@ window.__ModuleLoader__.load({
 				return await response.json()
 			}
 
+			/** 只读 GET（目前只有「继承来的主会话历史」那一处用它）。 */
+			const getJson = async (path) => {
+				const response = await fetch(path, { method: 'GET' })
+				if (!response.ok) throw new Error('HTTP ' + response.status + ' ' + path)
+				return await response.json()
+			}
+
+			/**
+			 * ★ 层 2：按需读「这一段继承到的**主会话历史**」（只读路由 `GET /side-branch/inherited`）。
+			 *
+			 * 粒度由宿主决定：**最后一轮全文 + 更早每轮一行摘要**（服务端截断，不调模型）。
+			 * ⛔ 返回值**只放面板内存**（`useState`），绝不进 `rounds` / 持久化状态 —— 见面板里那段注释。
+			 * @param {string} conversationId - 这一段侧枝会话
+			 * @returns {Promise<object>} `{ turns, chars, truncated, parentHasNewer, … }`
+			 */
+			const fetchInherited = (conversationId) =>
+				getJson(ROUTE + '/inherited?conversationId=' + encodeURIComponent(conversationId) + '&locale=' + localeId())
+
 			/**
 			 * 当前界面语言（`'zh'` / `'en'`），**随每次请求发给宿主**。
 			 *
@@ -3227,7 +3781,7 @@ window.__ModuleLoader__.load({
 								// 官方做法：用 inject face 把能力作为 props 交给组件。
 								// 注意：它**不会**覆盖席位声明的 hooks —— 渲染器把 `contextual`
 								// （含 `useTabInfo`）排在 `injected` 之后展开（已核实）。
-								inject: () => ({ startSideBranch, streamUrl, stopSideBranch, closeSideBranch, listModels, fetchSettings, saveSettings }),
+								inject: () => ({ startSideBranch, streamUrl, stopSideBranch, closeSideBranch, listModels, fetchSettings, saveSettings, fetchInherited }),
 							},
 							SideBranchBody,
 						),