@mzzsfy/dsh-context-manager 0.2.0 → 0.2.1

package/README.md

@@ -1,6 +1,6 @@
 # dsh-context-manager
 
-对话增强插件:历史输入回溯、插话撤回、对话分叉(家族版本切换/进行中轮分叉/自动重发)、标题栏复制 sessionId。dsh-session-manager 历史输入功能的独立延续包(原包已移除该功能)。
+对话增强插件:历史输入回溯、插话撤回、对话分叉(进行中轮分叉/自动重发)、标题栏复制 sessionId。dsh-session-manager 历史输入功能的独立延续包(原包已移除该功能)。
 
 ## 功能
 
@@ -30,14 +30,6 @@
 - 回填时序:宿主 open 可能先于草稿登记完成子会话挂载,消费侧以有限次延迟重查兜底
 - 分叉后自动重发(开关,默认关):开启时分叉成功即以该轮原输入经 `remote.session.prompt` 发送到子会话立即开跑(重生成语义);prompt 失败仅通知,文本已在输入框可手动发送;旧宿主缺 prompt 通道自动降级为仅回填
 
-### 家族版本计数(‹ n/m ›)
-
-用户输入气泡操作排的家族版本环:当前会话在同源分叉家族(parentSession 链)中的序位/成员数,`‹ ›` 在家族成员间直接跳转(`sessions.open`,纯切换不分叉)。
-
-- 家族判定:`sessions.list` 快照行的 `parentId` 建链投影(wire 形态字段名为 `parentSessionId`,客户端快照行映射为 `parentId`),断链视为独立根;单成员家族不注入
-- 零新 RPC:数据源为既有会话列表快照,环序按 `updatedAt` 升序(与分叉先后一致)
-- 启停:随「对话分叉」开关一并启停(环由同一 dock 注入),宿主缺 sessions.list 快照面不注入
-
 ### 标题栏复制 sessionId
 
 会话标题栏(「标准模式」标签右侧)的复制按钮:点击复制当前会话 id 到剪贴板,便于粘贴给他人排查或脚本引用。
@@ -48,7 +40,7 @@
 
 ## 启停
 
-设置页「插件」→「对话增强」卡片五开关(历史输入/插话撤回/对话分叉/分叉后自动重发/标题栏复制 sessionId),经宿主 settings 持久,变更刷新页面生效;家族版本环随「对话分叉」开关一并启停。
+设置页「插件」→「对话增强」卡片五开关(历史输入/插话撤回/对话分叉/分叉后自动重发/标题栏复制 sessionId),经宿主 settings 持久,变更刷新页面生效。
 
 ## 依赖与门控
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mzzsfy/dsh-context-manager",
-  "description": "对话增强:历史输入浮层(范围导航/搜索/subagent排除)、常用提示词收藏、插话撤回、对话 fork(家族版本切换/进行中轮分叉/自动重发)",
-  "version": "0.2.0",
+  "description": "对话增强:历史输入浮层(范围导航/搜索/subagent排除)、常用提示词收藏、插话撤回、对话 fork(进行中轮分叉/自动重发)",
+  "version": "0.2.1",
   "type": "module",
   "main": "src/index.js",
   "exports": {

package/src/client.js

@@ -34,11 +34,6 @@ window.__ModuleLoader__.load({
     }
 
 const CSS = [
-  // 家族版本环:与官方 28px icon 按钮同高同隙,chevron 用官方线形 svg,
-  // label 小号 caption 色,不另起风格
-  '.cx-family-ring { display:inline-flex; align-items:center; gap:2px; }',
-  '.cx-family-ring .cx-family-ring__label { font:var(--dsw-font-xxs-12); color:var(--dsw-alias-label-caption);',
-  '  min-width:24px; text-align:center; line-height:28px; }',
   // 开关行(规约 switch 形态):track 胶囊 + thumb 圆点,状态选择器锚定 checkbox
   '.cx-switch { display:inline-flex; align-items:center; gap:8px; margin-top:10px; cursor:pointer;',
   '  font:var(--dsw-font-xxs-12, 12px/18px sans-serif); color:var(--dsw-alias-label-caption, rgba(127,127,127,.9)); }',
@@ -241,50 +236,6 @@ function forkRetryText(data) {
   return text.trim() === '' ? null : text
 }
 
-// 家族谱系投影镜像(与 core.mjs sessionFamilyMap/familyRing 同步维护):
-// 客户端快照行主键为 id、父引用为 parentId(与 RPC wire 的 sessionId/parentSessionId 不同名),
-// 编排派生会话(origin === 'subagent')剔除——家族只统计用户的 fork 分支;
-// 断链视为独立根;环序按 updatedAt 升序
-function sessionFamilyMap(items) {
-  const byId = new Map()
-  for (const item of Array.isArray(items) ? items : []) {
-    if (item && item.origin === 'subagent') continue
-    const id = item && item.id
-    if (typeof id === 'string' && id !== '') byId.set(id, item)
-  }
-  const chains = new Map()
-  for (const id of byId.keys()) {
-    const chain = []
-    let cursor = id
-    let root = cursor
-    while (cursor !== undefined) {
-      chain.unshift(cursor)
-      root = cursor
-      const parent = byId.get(cursor)
-      cursor = parent && typeof parent.parentId === 'string' && byId.has(parent.parentId)
-        ? parent.parentId
-        : undefined
-      if (chain.includes(cursor)) break
-    }
-    chains.set(id, { root, chain, item: byId.get(id) })
-  }
-  return chains
-}
-
-function familyRing(chains, sessionId) {
-  const entry = chains instanceof Map ? chains.get(sessionId) : undefined
-  if (!entry) return null
-  const members = [...chains.entries()]
-    .filter(([, value]) => value.root === entry.root)
-    .sort((left, right) => {
-      const at = (record) => (record && record.item && typeof record.item.updatedAt === 'number' ? record.item.updatedAt : 0)
-      return at(left[1]) - at(right[1])
-    })
-    .map(([id]) => id)
-  if (members.length < 2) return null
-  return { index: members.indexOf(sessionId) + 1, total: members.length, members }
-}
-
 function HistoryDock({ session, inputActions }) {
   const [open, setOpen] = useState(false)
   const [items, setItems] = useState(null)
@@ -751,8 +702,6 @@ function forkSvg() {
 // 注入按钮标记:识别自家节点与官方按钮,防止重复注入与误删官方节点
 const STEER_BTN_FLAG = 'data-cx-steer-recall'
 const FORK_BTN_FLAG = 'data-cx-fork'
-// 家族版本环标记:识别自家 ‹n/m› 计数器节点,防重复注入
-const FAMILY_RING_FLAG = 'data-cx-family-ring'
 // 官方 pending steering 气泡的语义标记(官方同构:UserStyleBubble data 属性)与
 // 其操作图标排的 CSS module 类名后缀(哈希前缀随构建漂移,后缀稳定);
 // 消息节点的轮号标记(fork 锚点输入)
@@ -883,7 +832,7 @@ function SteerRecallDock({ session, useSession, inputActions, updateQueue }) {
 // 轮号无映射 = 该轮未完成,首问无文本(纯图等)= 无法重试,均不注入;
 // 首轮无前锚(宿主 fork 边界必须落在 turn/end 上,复制零事件不可表达),也不注入。
 // 分叉动作经宿主 sessions 服务面 fork+open(与官方 chat 同构),成功 toast 并切换
-function ForkDockWithBootstrap({ session, inputActions, forkSession, cancelSession, openSession, loadFamily, submitPrompt, loadTurnEnds }) {
+function ForkDockWithBootstrap({ session, inputActions, forkSession, cancelSession, submitPrompt, loadTurnEnds }) {
   // 依赖键 = 会话 id:session 快照身份随每次投影更新漂移,不能作 effect 依赖;
   // loadTurnEnds 闭包身份同样不稳定,经 ref 取用
   const sessionId = session && session.sessionId
@@ -936,17 +885,15 @@ function ForkDockWithBootstrap({ session, inputActions, forkSession, cancelSessi
     }
     return undefined
   }, [sessionId, inputActions, draftPollTick])
-  return h(ForkDock, { session, forkSession, cancelSession, openSession, loadFamily, turnEnds })
+  return h(ForkDock, { session, forkSession, cancelSession, turnEnds })
 }
 
-function ForkDock({ session, forkSession, cancelSession, openSession, loadFamily, turnEnds }) {
+function ForkDock({ session, forkSession, cancelSession, turnEnds }) {
   const [enabled, setEnabled] = useState(true)
   const [autoResend, setAutoResend] = useState(false)
   const turnEndsRef = useRef(null)
   const forkRef = useRef(null)
   const cancelRef = useRef(null)
-  const familyRef = useRef(null)
-  const openRef = useRef(null)
   const sessionRef = useRef(null)
   const enabledRef = useRef(true)
   const autoResendRef = useRef(false)
@@ -965,13 +912,10 @@ function ForkDock({ session, forkSession, cancelSession, openSession, loadFamily
   turnEndsRef.current = turnEnds
   forkRef.current = forkSession
   cancelRef.current = cancelSession
-  familyRef.current = loadFamily
-  openRef.current = openSession
   sessionRef.current = session
   useEffect(() => {
     function removeAll() {
       document.querySelectorAll('[' + FORK_BTN_FLAG + ']').forEach((button) => button.remove())
-      document.querySelectorAll('[' + FAMILY_RING_FLAG + ']').forEach((node) => node.remove())
     }
     function scan() {
       // 停用即不注入并移除已注入按钮(开关可在挂载后才到达停用值)
@@ -1053,73 +997,6 @@ function ForkDock({ session, forkSession, cancelSession, openSession, loadFamily
         button.appendChild(forkSvg())
         actionsRow.appendChild(button)
       })
-      // 家族版本环:每个用户气泡操作排的 ‹n/m›,箭头在家族成员间跳转;
-      // 单成员家族/快照面缺失不注入(与官方按钮并存,hover 显隐一致)
-      const loadFamilyFn = familyRef.current
-      const ring = (sessionRef.current && typeof loadFamilyFn === 'function')
-        ? loadFamilyFn(sessionRef.current.sessionId)
-        : null
-      if (ring && ring.total >= 2) {
-        bubbles.forEach((bubble) => {
-          if (bubble.getAttribute(FLOW_KIND_ATTR) !== 'user') return
-          const actionsRow = bubble.querySelector(STEER_ACTIONS_SUFFIX)
-          if (!actionsRow || actionsRow.querySelector('[' + FAMILY_RING_FLAG + ']')) return
-          const official = actionsRow.querySelector('button:not([' + FORK_BTN_FLAG + ']):not([' + STEER_BTN_FLAG + '])')
-          if (!official) return
-          const ringEl = document.createElement('span')
-          ringEl.setAttribute(FAMILY_RING_FLAG, '')
-          ringEl.className = 'cx-family-ring'
-          ringEl.title = '家族版本:本会话在同源分叉家族中的序位,箭头在各版本间切换'
-          const makeChevron = (direction, tip) => {
-            const chevron = document.createElement('button')
-            chevron.type = 'button'
-            chevron.className = official.className
-            chevron.setAttribute(FAMILY_RING_FLAG, '')
-            chevron.title = tip
-            chevron.setAttribute('aria-label', tip)
-            chevron.addEventListener('click', () => jumpFamilyMember(direction))
-            chevron.appendChild(familyChevronSvg(direction))
-            return chevron
-          }
-          const label = document.createElement('span')
-          label.setAttribute(FAMILY_RING_FLAG, '')
-          label.className = 'cx-family-ring__label'
-          label.textContent = ring.index + '/' + ring.total
-          ringEl.appendChild(makeChevron(-1, '上一个家族版本'))
-          ringEl.appendChild(label)
-          ringEl.appendChild(makeChevron(1, '下一个家族版本'))
-          actionsRow.appendChild(ringEl)
-        })
-      }
-    }
-    // 家族环 chevron 图标:与官方 outline chevron 同款线形(12px 视窗)
-    function familyChevronSvg(direction) {
-      const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg')
-      svg.setAttribute('width', '12')
-      svg.setAttribute('height', '12')
-      svg.setAttribute('viewBox', '0 0 14 14')
-      svg.setAttribute('fill', 'none')
-      svg.setAttribute('aria-hidden', 'true')
-      const path = document.createElementNS('http://www.w3.org/2000/svg', 'path')
-      path.setAttribute('d', direction < 0 ? 'M8.75 3.5L5.25 7L8.75 10.5' : 'M5.25 3.5L8.75 7L5.25 10.5')
-      path.setAttribute('stroke', 'currentColor')
-      path.setAttribute('stroke-width', '1.2')
-      path.setAttribute('stroke-linecap', 'round')
-      path.setAttribute('stroke-linejoin', 'round')
-      svg.appendChild(path)
-      return svg
-    }
-    function jumpFamilyMember(offset) {
-      const loadFamilyFn = familyRef.current
-      const openFn = openRef.current
-      const current = sessionRef.current
-      if (!current || typeof loadFamilyFn !== 'function' || typeof openFn !== 'function') return
-      const ring = loadFamilyFn(current.sessionId)
-      if (!ring) return
-      const nextIndex = ring.index - 1 + offset
-      if (nextIndex < 0 || nextIndex >= ring.members.length) return
-      const target = ring.members[nextIndex]
-      if (target && target !== current.sessionId) openFn(target)
     }
     if (typeof MutationObserver === 'undefined' || typeof document.querySelectorAll !== 'function') return undefined
     const scanRef = { current: scan }
@@ -1290,18 +1167,6 @@ function ContextPanel() {
           })
           : null
 
-        // 家族环通道:会话列表快照(parentSessionId 字段)投影为当前会话的 ‹n/m› 计数;
-        // 快照面缺失(旧宿主)时返回 null,计数器整体不注入
-        const loadFamily = (sessionId) => {
-          if (!sessions || !sessions.list || typeof sessions.list.getSnapshot !== 'function') return null
-          const snapshot = sessions.list.getSnapshot()
-          const rows = snapshot && snapshot.byId
-            ? (Array.isArray(snapshot.ids) ? snapshot.ids : []).map((id) => snapshot.byId[id]).filter(Boolean)
-            : (Array.isArray(snapshot) ? snapshot : [])
-          if (rows.length === 0) return null
-          return familyRing(sessionFamilyMap(rows), sessionId)
-        }
-
         // 自动重发通道:开启开关时分叉后以该轮原输入 prompt 子会话;
         // remote.session 缺失或缺 prompt(旧宿主/部分 stub)时返回 null,降级为仅回填;
         // 请求形态与官方 client face 同源:content 为 text 分段数组(宿主 hasPromptContent
@@ -1387,8 +1252,6 @@ function ContextPanel() {
                     cancelSession: (typeof remoteSession.cancel === 'function')
                       ? (opts) => remoteSession.cancel(opts)
                       : null,
-                    openSession: (sessions && typeof sessions.open === 'function') ? (id) => sessions.open(id) : null,
-                    loadFamily: () => loadFamily(sessionId),
                     submitPrompt,
                     loadTurnEnds: () => followOpening(remoteSession, sessionId).then((records) => {
                       // 轮号 → { 结束 seq, 该轮首问文本, open }:上个 turn/end 之后首条

package/src/core.mjs

@@ -144,57 +144,3 @@ export function forkRetryText(data) {
     .join('\n')
   return text.trim() === '' ? null : text
 }
-
-/**
- * 家族谱系投影:按 parentSessionId 把会话行组装成「根 → 后代」链,
- * parentSessionId 断链(引用的父不在集合内)的行视为独立根。
- * 编排派生会话(origin === 'subagent')不是用户的 fork 版本,整行剔除,
- * 其后代随之断链成独立根——家族只统计用户可跳转的对话分支。
- * @param items - sessions.list 行数组(至少含 sessionId/parentSessionId)
- * @returns Map<sessionId, { root, chain: string[] }>——chain 为根到自身的 id 序列
- */
-export function sessionFamilyMap(items) {
-  const byId = new Map()
-  for (const item of Array.isArray(items) ? items : []) {
-    if (item && item.origin === 'subagent') continue
-    const id = item && (item.sessionId ?? item.id)
-    if (typeof id === 'string' && id !== '') byId.set(id, item)
-  }
-  const chains = new Map()
-  for (const id of byId.keys()) {
-    const chain = []
-    let cursor = id
-    let root = cursor
-    while (cursor !== undefined) {
-      chain.unshift(cursor)
-      root = cursor
-      const parent = byId.get(cursor)
-      cursor = parent && typeof parent.parentSessionId === 'string' && byId.has(parent.parentSessionId)
-        ? parent.parentSessionId
-        : undefined
-      if (chain.includes(cursor)) break
-    }
-    chains.set(id, { root, chain, item: byId.get(id) })
-  }
-  return chains
-}
-
-/**
- * 家族环计数:某会话在所属家族中的序位与成员数(按 updatedAt 升序,与分叉先后一致)。
- * 单成员家族返回 null(不渲染计数器)。
- * @param chains - sessionFamilyMap 的结果
- * @param sessionId - 目标会话
- */
-export function familyRing(chains, sessionId) {
-  const entry = chains instanceof Map ? chains.get(sessionId) : undefined
-  if (!entry) return null
-  const members = [...chains.entries()]
-    .filter(([, value]) => value.root === entry.root)
-    .sort((left, right) => {
-      const at = (record) => (record && record.item && typeof record.item.updatedAt === 'number' ? record.item.updatedAt : 0)
-      return at(left[1]) - at(right[1])
-    })
-    .map(([id]) => id)
-  if (members.length < 2) return null
-  return { index: members.indexOf(sessionId) + 1, total: members.length, members }
-}

package/test/client-help.test.mjs

@@ -44,7 +44,6 @@ test('源码契约:悬停说明覆盖各设置的关键行为语义', () => {
   assert.ok(CLIENT_SRC.includes('回填子会话输入框'), 'fork 说明缺重试回填语义')
   assert.ok(CLIENT_SRC.includes('尾号递增'), 'fork 说明缺标题递增语义')
   assert.ok(CLIENT_SRC.includes('重生成语义'), '自动重发说明缺重生成语义')
-  assert.ok(CLIENT_SRC.includes('家族版本'), '计数器说明缺家族版本语义')
 })
 
 // 搜索功能源码契约:query 双写 + 组合输入守卫 + 命中计数 + 两级 Esc

package/test/client-fork-family.test.mjs

@@ -1,48 +0,0 @@
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { readFileSync } from 'node:fs'
-import { fileURLToPath } from 'node:url'
-
-const CLIENT_SRC = readFileSync(fileURLToPath(new URL('../src/client.js', import.meta.url)), 'utf8')
-
-// F1 家族版本环 的客户端契约(源码切片锁定):
-// - 数据源是 sessions.list 快照行(parentSessionId),零新 RPC
-// - 单成员家族/快照缺失不注入
-// - 箭头跳转经 sessions.open(纯打开,不 fork)
-// - 计数器防重复注入,停用 fork 时随 removeAll 一并清除
-
-test('源码契约:家族环数据源为 sessions.list 快照(零新 RPC)', () => {
-  assert.ok(CLIENT_SRC.includes('sessions.list.getSnapshot()'), '家族投影应读会话列表快照')
-  assert.ok(CLIENT_SRC.includes('parent.parentId'), '投影应按快照行 parentId 建链(快照字段名与 wire 不同)')
-})
-
-test('源码契约:快照行主键为 id(与服务 wire 字段名不同源)', () => {
-  const slice = CLIENT_SRC.slice(CLIENT_SRC.indexOf('function sessionFamilyMap'), CLIENT_SRC.indexOf('function familyRing'))
-  assert.ok(slice.includes('item.id'), '快照行主键应取 id')
-})
-
-test('源码契约:编排派生会话(subagent)剔除出家族投影', () => {
-  const slice = CLIENT_SRC.slice(CLIENT_SRC.indexOf('function sessionFamilyMap'), CLIENT_SRC.indexOf('function familyRing'))
-  assert.ok(slice.includes("item.origin === 'subagent'"), 'subagent 会话不是用户的 fork 版本,应整行剔除')
-})
-
-test('源码契约:单成员家族与快照缺失不注入计数器', () => {
-  const slice = CLIENT_SRC.slice(CLIENT_SRC.indexOf('// 家族版本环'), CLIENT_SRC.indexOf('function jumpFamilyMember'))
-  assert.ok(slice.includes('ring && ring.total >= 2'), '成员不足 2 不注入')
-  assert.ok(slice.includes('actionsRow.querySelector'), '注入前应查重')
-})
-
-test('源码契约:箭头跳转经 sessions.open 且不 fork', () => {
-  const jump = CLIENT_SRC.slice(CLIENT_SRC.indexOf('function jumpFamilyMember'), CLIENT_SRC.indexOf('if (typeof MutationObserver'))
-  assert.ok(jump.includes('openFn(target)'), '跳转应调用 open 通道')
-  assert.ok(jump.includes('target !== current.sessionId'), '目标为自身时不切换')
-})
-
-test('源码契约:家族环标记与清除齐备(停用开关一并移除)', () => {
-  assert.ok(CLIENT_SRC.includes("const FAMILY_RING_FLAG = 'data-cx-family-ring'"), '应有家族环标记常量')
-  assert.ok(CLIENT_SRC.includes("querySelectorAll('[' + FORK_BTN_FLAG + ']')"), '清除逻辑存在(环与按钮同排,按钮清除即整排消失)')
-})
-
-test('源码契约:loadFamily 通道旧宿主降级返回 null', () => {
-  assert.ok(CLIENT_SRC.includes('typeof sessions.list.getSnapshot'), '快照面应以能力探测守门')
-})

package/test/core-family.test.mjs

@@ -1,122 +0,0 @@
-import test from 'node:test'
-import assert from 'node:assert/strict'
-
-import {
-  forkFailureText,
-  forkRetryText,
-  sessionFamilyMap,
-  familyRing,
-} from '../src/core.mjs'
-
-// ── fork 锚点解析 ──
-
-test('Given 插件注入消息, When forkRetryText, Then 返回 null', () => {
-  assert.equal(forkRetryText({ source: { kind: 'plugin' }, content: [{ type: 'text', text: 'hi' }] }), null)
-})
-
-test('Given 纯图或空白 user 消息, When forkRetryText, Then 返回 null', () => {
-  assert.equal(forkRetryText({ source: { kind: 'user' }, content: [{ type: 'image', attachment: {} }] }), null)
-  assert.equal(forkRetryText({ source: { kind: 'user' }, content: [{ type: 'text', text: '   ' }] }), null)
-})
-
-test('Given undefined 或畸形 data, When forkRetryText, Then 返回 null', () => {
-  assert.equal(forkRetryText(undefined), null)
-  assert.equal(forkRetryText({}), null)
-  assert.equal(forkRetryText({ source: { kind: 'user' } }), null)
-})
-
-test('Given 多文本块 user 消息, When forkRetryText, Then 按行拼接且跳过图块', () => {
-  const text = forkRetryText({
-    source: { kind: 'user' },
-    content: [
-      { type: 'text', text: '第一行' },
-      { type: 'image', attachment: {} },
-      { type: 'text', text: '第二行' },
-    ],
-  })
-  assert.equal(text, '第一行\n第二行')
-})
-
-test('Given user 消息先于 turn/start(无门), When forkRetryText, Then 照常提取', () => {
-  assert.equal(forkRetryText({ source: { kind: 'user' }, content: [{ type: 'text', text: '首问' }] }), '首问')
-})
-
-// ── 家族谱系投影 ──
-
-test('Given 空/畸形输入, When sessionFamilyMap, Then 返回空 Map', () => {
-  assert.equal(sessionFamilyMap(undefined).size, 0)
-  assert.equal(sessionFamilyMap([]).size, 0)
-  assert.equal(sessionFamilyMap([null, {}, { sessionId: '' }]).size, 0)
-})
-
-test('Given 直链家族 根→A→B, When sessionFamilyMap, Then 各成员链正确且同根', () => {
-  const items = [
-    { sessionId: 'root', updatedAt: 3 },
-    { sessionId: 'a', parentSessionId: 'root', updatedAt: 1 },
-    { sessionId: 'b', parentSessionId: 'a', updatedAt: 2 },
-  ]
-  const chains = sessionFamilyMap(items)
-  assert.deepEqual(chains.get('b').chain, ['root', 'a', 'b'])
-  assert.equal(chains.get('b').root, 'root')
-  assert.equal(chains.get('a').root, 'root')
-  assert.equal(chains.get('root').root, 'root')
-})
-
-test('Given parentSessionId 指向不存在的会话(孤儿), When sessionFamilyMap, Then 视为独立根', () => {
-  const chains = sessionFamilyMap([{ sessionId: 'x', parentSessionId: 'ghost' }])
-  assert.equal(chains.get('x').root, 'x')
-  assert.deepEqual(chains.get('x').chain, ['x'])
-})
-
-test('Given 循环引用, When sessionFamilyMap, Then 不死循环', () => {
-  const chains = sessionFamilyMap([
-    { sessionId: 'p', parentSessionId: 'q' },
-    { sessionId: 'q', parentSessionId: 'p' },
-  ])
-  assert.ok(chains.get('p').chain.length <= 2)
-})
-
-test('Given 编排派生会话(origin=subagent)挂在根下, When sessionFamilyMap, Then subagent 行剔除且不计数', () => {
-  const chains = sessionFamilyMap([
-    { sessionId: 'root', updatedAt: 30 },
-    { sessionId: 'task', parentSessionId: 'root', origin: 'subagent', updatedAt: 20 },
-    { sessionId: 'fork', parentSessionId: 'root', updatedAt: 10 },
-  ])
-  assert.equal(chains.has('task'), false)
-  const ring = familyRing(chains, 'root')
-  assert.deepEqual(ring, { index: 2, total: 2, members: ['fork', 'root'] })
-})
-
-test('Given 整链均为 subagent, When familyRing, Then 单成员返回 null', () => {
-  const chains = sessionFamilyMap([{ sessionId: 'task', origin: 'subagent' }])
-  assert.equal(familyRing(chains, 'task'), null)
-})
-
-// ── 家族环计数 ──
-
-test('Given 家族 3 成员, When familyRing(中间 updatedAt), Then index=2 total=3 members 按 updatedAt 升序', () => {
-  const chains = sessionFamilyMap([
-    { sessionId: 'root', updatedAt: 30 },
-    { sessionId: 'a', parentSessionId: 'root', updatedAt: 10 },
-    { sessionId: 'b', parentSessionId: 'root', updatedAt: 20 },
-  ])
-  const ring = familyRing(chains, 'b')
-  assert.deepEqual(ring, { index: 2, total: 3, members: ['a', 'b', 'root'] })
-})
-
-test('Given 单成员家族, When familyRing, Then 返回 null', () => {
-  const chains = sessionFamilyMap([{ sessionId: 'only' }])
-  assert.equal(familyRing(chains, 'only'), null)
-})
-
-test('Given 目标不在投影内, When familyRing, Then 返回 null', () => {
-  assert.equal(familyRing(new Map(), 'nope'), null)
-  assert.equal(familyRing(undefined, 'nope'), null)
-})
-
-test('Given fork 错误码, When forkFailureText, Then 已知码映射中文未知码透出', () => {
-  assert.equal(forkFailureText('session/fork-unavailable'), '该轮尚未完成,不可分叉')
-  assert.equal(forkFailureText('session/workspace-attach-failed'), '分叉成功,但挂载到工作区失败')
-  assert.equal(forkFailureText('gateway/internal'), '分叉失败: gateway/internal')
-  assert.equal(forkFailureText(undefined), '分叉失败: 未知错误')
-})