@mzzsfy/dsh-session-manager 0.7.0 → 0.8.1

package/README.md

@@ -1,6 +1,6 @@
 # @mzzsfy/dsh-session-manager
 
-DeepSeek Harness 会话生命周期管理插件:自动归档 + 归档面板 + 归档删除 + 回收站还原重挂载 + 历史输入浮层。
+DeepSeek Harness 会话生命周期管理插件:自动归档 + 归档面板 + 归档删除 + 回收站还原重挂载 + 历史输入浮层 + 插话撤回。
 
 ## 功能
 
@@ -8,9 +8,10 @@ DeepSeek Harness 会话生命周期管理插件:自动归档 + 归档面板 +
   - **范围导航**:浮层内 `←/→` 切换范围,范围序为 **常用 → 当前会话(默认落点)→ 本工作区 → 全部工作区**,`→` 向更大范围,`←` 返回收藏,边界停住;范围显示为浮层左上角徽标。
   - **工作区持久缓存**:每工作区一个 JSON 文件(`~/.dsh/historyPrompt/<工作区>-<路径哈希>.json`,可辨认 + 防同名冲突),内容为该工作区聚合后的输入条目(带 `sid` 来源会话溯源)。浮层请求直接读缓存文件立即返回(毫秒级,响应 `{ inputs, aligned }`);**对齐**在后台进行:解压范围内最近会话产物(经官方 `sessionQuery.readSession`,仅 `source.kind === 'user'` 的人类输入,工具结果回填与插件注入排除)、与缓存合并去重后原子写回(临时文件 + 改名)。对齐时机:插件启动对齐最近会话覆盖的工作区、每次浮层请求触发(同工作区 30 秒节流)、**运行中会话参与对齐(输入实时追加)**。
   - **范围语义**:`prompts` 用户显式收藏的常用提示词(全局单文件 `prompts.json`,不按工作区,详见收藏交互);`session` 该会话输入(缓存按 `sid` 过滤);`workspace` 同 cwd 工作区缓存;`global` 全部工作区缓存并集。
-  - **上限与首次对齐**:全部历史最多保留最新 200 条(`HISTORY_INPUT_LIMIT`)、单条截 2 万字符(`HISTORY_INPUT_MAX_CHARS`),聚合精确文本去重保留最新时间。首次(该工作区尚无缓存文件)`aligned=false`,client 显示「首次对齐历史中」提示并每 3 秒(`HISTORY_REPULL_MS`)静默重拉;单会话产物读取失败仅告警跳过;scope 非法或缺省回退 `session`。
+  - **上限与首次对齐**:全部历史最多保留最新 200 条(`HISTORY_INPUT_LIMIT`)、单条截 2 万字符(`HISTORY_INPUT_MAX_CHARS`),聚合精确文本去重保留最新时间;**每会话首条保护**:超出上限被挤出时,每个来源会话在去重后集合中的最早条目仍保留(会话开场提示词最旧也最有复用价值,时间倒序截断总先挤掉它们;保护在去重后集合上计算,首条文本已被更新的会话复用时不再按旧会话重复追加;无 sid 的收藏条目不触发)。首次(该工作区尚无缓存文件)`aligned=false`,client 显示「首次对齐历史中」提示并每 3 秒(`HISTORY_REPULL_MS`)静默重拉;单会话产物读取失败仅告警跳过;scope 非法或缺省回退 `session`。
 - 常用提示词收藏:`prompts` 以外的范围,历史行鼠标悬停时行尾出现收藏星标(已收藏实星、未收藏空心),点击即收藏/取消(经 `POST /api/session-manager/prompts/toggle`),toast 反馈并同步星标;`prompts` 范围右上角「编辑」按钮进入编辑态:行内文本框直接改(Enter/失焦保存,实现为移除旧文本 + 收藏新文本)、行尾 `×` 删除、底部输入框 Enter 新增,「完成」退出;上限 `HISTORY_PROMPTS_MAX` 条,超出裁掉最旧;收藏与自动对齐的历史缓存互不覆写(工作区缓存列举跳过 prompts.json);global 范围读取走 stat 指纹缓存(`listWorkspaceCachesCached`),产物未变的文件不重复读盘;client 与 core 的 `HISTORY_SCOPES` 镜像由 parity 测试锁定。
 - 历史浮层启停开关:低频功能,归档面板末行小尺寸开关(规约 switch 形态 `sm-histsw`,状态选择器锚定 `input[type=checkbox]`);值存宿主 settings(`historyEnabled`,默认启用,原生设置页与本面板同存储即时同值),读写经本插件 `GET/POST /api/session-manager/history-enabled`(client 写 settings 不经宿主 remotes,零版本脆弱依赖);浮层挂载拉取一次,停用即锚点/快捷键/浮层整体不渲染、键盘监听放行,变更刷新页面生效。
+- 插话撤回:插话发送(steer)后、消息尚未被智能体应用(宿主队列快照中仍存在 `placement=steering` 条目,即 Inbox next-step 等待 step 边界 claim)期间,撤回图标**直接出现在该插话气泡的原生操作图标排**(复制图标旁,与其同排同款):经 MutationObserver 定位官方 pending steering 气泡的语义标记 `data-pending-steering` 及其图标排(CSS module 类名后缀 `_actions`),注入 undo 弯箭头按钮并**克隆官方按钮 className**——尺寸/hover/悬停显隐(reveal)全部原生;气泡被应用后整棵卸载,注入按钮随之消失。dock 插槽本体 `display:none` 零占位,仅承载观察与注入;官方 DOM 结构漂移时注入静默跳过(不报错,干净禁用精神);点击经官方 `ISession.updateQueue(itemId, {kind:'remove'})` 摘除(对 next-step 同样有效,无运行状态限制——智能体停止后残留的未送达插话同样可撤),成功才回填输入框草稿(`inputActions.setDraft` 整体替换,与历史浮层回填同语义,**会覆盖输入框中未发送的既有草稿**)并 toast 提示;回填自身失败(会话切换等竞态)时经 toast 兜底展示原文;消息已被应用(竞态窗口内被 claim,宿主返回 `session/queue-item-not-found`)时专用文案报错且不动草稿。含附件的插话(text 为 null)图标禁用并提示(与官方队列编辑同为纯文本限制,撤回丢附件);subagent 非 continuable 会话不注入(与官方队列面板 queueMutable 同规);RPC 走会话绑定面 `binding.session.updateQueue`(RemoteResult 不抛错,与官方 conversation 服务零耦合),会话绑定缺失或会话面无 `updateQueue`(旧宿主)时返回空 props 整体禁用。归档面板提供启停开关(`steerRecallEnabled`,默认启用,开关行在历史浮层开关之下,复用同款 switch 形态),读写经本插件 `GET/POST /api/session-manager/steer-recall-enabled`,停用即不注入并移除已注入按钮,变更刷新页面生效。
 - 自动归档:host 半区对超期会话走官方 `workspace.archiveSession` 通道,三个触发源共用同一评估与门闩:新会话创建(`session/created`,按该会话所属工作区限定)、settings 就绪后的启动补扫(全量,清掉停机期间积压)、每日周期轮(全量,经宿主 timer 服务固定短 tick + 到期判断)。幂等:已归档会话不参与评估。阈值 `autoArchiveDays` 默认 7,`0` 关闭;周期间隔 `autoArchiveIntervalHours` 默认 24,`0` 关闭周期轮,变更经周期 tick 对账(关闭即时暂停、重启用最迟下个 tick 生效、缩短经锚定钳制前移,最长等新间隔而非等满旧周期)。评估筛选:createdAt 纯内存预筛 + 已归档跳过 + stat 后活跃度判定,locate 缺失(第三方后端)与产物不可读的会话一律跳过,宁可漏归档不可误归档。经 settings 命名空间 `session-manager` 注册(schema 拒绝负数与非整数)。timer 为软依赖:宿主定时服务不可用时仅周期轮停用,面板顶部提示,插件其余能力不受影响。
 - 自动归档配置:归档面板「已删除」区下方的配置行,阈值天数与检查周期小时数两个数字输入,失焦或 Enter 单字段即时提交,非法输入前端拦截不发请求,服务端失败回读生效值回滚;读写经本插件 `GET/POST /api/session-manager/auto-archive`(POST 部分更新,仅接受出现且为非负整数的字段,空字段拒绝),值存宿主 settings 与评估逻辑同源,`0` = 关闭,GET 返回含默认回退的当前生效值。
 - 归档面板:设置页「会话归档」分区,数据为 client 侧 `session.list` 行 ∩ `workspaces.follow` 归档快照的交集,按更新时间倒序;主列表只展开最近 `ARCHIVE_PAGE_SIZE`(100)条,列表尾部「按工作区浏览」按钮直接进入二级视图查看全部(主列表不翻页,防归档集合无限增长拖垮渲染)。二级视图:无搜索词时按工作区分组(组间按组内最新活跃倒序,分组默认收起,展开即见组内首页并可继续翻页,`workspace` 假值并入「未分组」组);输入搜索词后平铺展示标题命中(不区分大小写子串,标题缺失回退会话 id 天然可搜)的全部归档会话并显示匹配计数,同样分页。行内标题前显示所属工作区徽标——映射优先走 workspace 账本(`sessionIds`,与官方 dsh-client-ui-workspace 的 workspaceBySession 同构),cwd 命中某登记工作区路径时回退该工作区标题(较官方「cwd basename 直接回退」收紧,防未登记目录名冒充工作区),均未命中显示「未分组」;工作区 title 缺失回退路径末段。镜像函数 client 与 core 双实现由 parity 测试锁定。行内支持取消归档与删除。
@@ -71,12 +72,12 @@ DeepSeek Harness 会话生命周期管理插件:自动归档 + 归档面板 +
   - 对齐扫描各工作区最近 20 个会话(`HISTORY_SESSION_SCAN_LIMIT`,更早会话的输入不入缓存),解压发生在后台、永不阻塞浮层响应,代价是首次对齐期间列表为空、需等静默重拉。
   - **解压不重复执行**:每会话提取结果持久化在工作区缓存 `extracts` 段并附产物 stat 指纹(mtimeMs+size),对齐时先 stat 比对、产物未变零解压,判断完全基于磁盘、跨重启生效;运行中会话(当前会话)提取结果只保留内存不落盘——产物持续变化,落盘指纹立即失效。
   - 启动零解压(历史直接读磁盘缓存,重启前的输入本就在 entries 里),全量对齐延迟 30 秒(`HISTORY_STARTUP_DELAY_MS`)再跑且只回溯最近 100 个会话(`HISTORY_STARTUP_SCAN_LIMIT`)覆盖的工作区。
-  - 对齐中连续解压占用超 200ms(`HISTORY_ALIGN_SLICE_MS`)即让出 100ms(`HISTORY_ALIGN_YIELD_MS`,zstd 解压为同步 CPU 操作,不设让出会让宿主启动阻塞数十秒);超 8MiB(`HISTORY_ALIGN_MAX_ARTIFACT_BYTES`)的巨产物跳过自动对齐(单次 readSession 内部同步解压不可让出,实时性让位于不卡主循环)。
+  - 对齐中连续解压占用超 200ms(`HISTORY_ALIGN_SLICE_MS`)即让出 100ms(`HISTORY_ALIGN_YIELD_MS`,解压为 CPU 操作,不设让出会长时间霸占主循环);巨产物跳过自动对齐,跳过线按宿主版本黑名单取值:0.1.1/0.1.2 系列(解压实现无周期让出)8MiB,其余(0.1.5 实测 `readZstdPrefix` 逐帧解压 + 周期让出,不阻塞主循环)16MiB(`HISTORY_ALIGN_LEGACY/MODERN_MAX_ARTIFACT_BYTES`,压缩字节数)——上限防的是解压耗时与事件对象内存峰值失控(压缩比约 1:3.4,超线产物解压后可达数百 MB);版本探测经 require 链解析宿主清单,失败保守按旧线。
   - header 查找走 ctx 级 TTL 缓存(inputs 路由不每次全量扫描 listSessions)。
   - 对齐为双车道:批量车道(窗口对齐)与焦点车道(单会话实时追加)各自串行互不等待,会话范围请求检测到产物指纹失配即触发焦点对齐并返回 aligned=false。
   - 浮层打开期间固定节奏轮询当前范围(数据可能晚于首次响应到达,一次性重拉预算会让迟到数据永不出现);单会话首条数据可见预算 3s:会话范围路由触发焦点对齐后就地等待 2s(`HISTORY_FOCUS_WAIT_MS`),正常会话单次请求内拿到新数据,超时(巨产物)走轮询流式补齐。
   - 不解压搬进 worker:产物为多帧 zstd + 帧扫描 + 记录解码 + 版本协商,`readSession` 深度耦合宿主持持层,worker 内复刻等于维护第二份产物解析实现,宿主升级即漂移。
-  - 缓存上限 200 条(`HISTORY_INPUT_LIMIT`),超出裁掉最旧(超长会话史会丢早期输入);新输入从发送到浮层可见有秒级延迟(宿主批量刷盘 200ms + 焦点对齐 + 轮询节奏),非严格实时。
+  - 缓存上限 200 条(`HISTORY_INPUT_LIMIT`),超出裁掉最旧,每会话最早条目例外保留(首条保护,见「上限与首次对齐」);巨产物(超线跳过对齐,见对齐参数)会话的条目只能来自既有缓存,首条从未入库则无法恢复;新输入从发送到浮层可见有秒级延迟(宿主批量刷盘 200ms + 焦点对齐 + 轮询节奏),非严格实时。
   - 缓存文件为明文 JSON(输入内容落盘 `~/.dsh/historyPrompt`,与产物本身同级敏感);单条超长文本(大段粘贴)在 host 侧截断,回填与展示均用截断后文本。
   - 交互收敛为快捷键唤起浮层(`Alt+↑`,无 mac 系统占用,与编辑器光标移动无冲突),无常驻界面元素。
 - 重挂载的并发窗口:attachSession 后、台账清除前进程中断,残留条目重挂载时因官方 attachSession 幂等(已在 sessionIds 中则跳过校验直写)无副作用,再次点按或「移除记录」即可收尾。台账域打开失败时已删除 / 重挂载 / forget 以 400 拒绝;删除路由走 partial 降级(其余步骤照常,提示「已移入回收站,但重挂载记录失败」),不做无台账中断——产物进回收站后中断删除只会造成状态不一致。

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mzzsfy/dsh-session-manager",
   "description": "会话自动归档与管理:超期自动归档、归档面板、删除进系统回收站、还原后一键重挂载",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "type": "module",
   "main": "src/index.js",
   "exports": {

package/src/client.js

@@ -14,11 +14,11 @@ window.__ModuleLoader__.load({
   id: '@mzzsfy/dsh-session-manager',
   factory(require) {
     const React = require('react')
-    const { useState, useEffect, useSyncExternalStore } = React
+    const { useState, useEffect, useRef, useSyncExternalStore } = React
 
-    // 导航图标声明:交给 dsh-settings-nav-icons 统一渲染(本插件分区 → archive);
-    // 该插件未就绪时入队,由其启动时排空
-    const NAV_ICON = { '会话归档': 'archive' }
+    // 导航图标声明:交给 dsh-settings-nav-icons 统一渲染;双键 = 分区 label + 市场
+    // 短名(发现页收录显示形态);该插件未就绪时入队,由其启动时排空
+    const NAV_ICON = { '会话归档': 'archive', 'dsh-session-manager': 'archive' }
     if (window.__navicIcons !== undefined) window.__navicIcons.register(NAV_ICON)
     else if (Array.isArray(window.__navicIconQueue)) window.__navicIconQueue.push(NAV_ICON)
     else window.__navicIconQueue = [NAV_ICON]
@@ -173,6 +173,9 @@ const CSS = [
   '.sm-hist__banner { padding:7px 14px; flex:none; text-align:center; font:var(--dsw-font-xxs-12, 12px/18px sans-serif);',
   '  color:light-dark(rgba(15,17,21,.55), rgba(232,234,237,.55));',
   '  background:light-dark(rgba(15,17,21,.04), rgba(255,255,255,.06)); }',
+  // 插话撤回图标:注入原生 pending steering 气泡的操作图标排,样式经克隆官方
+  // 按钮类名原生同款;dock 本体零 DOM,仅承载注入逻辑
+  '.sm-steer-host { display:none; }',
 ].join('\n')
 
 const UNARCHIVE_URL = '/api/session-manager/unarchive'
@@ -649,6 +652,7 @@ function SessionManagerApp(props) {
     }),
     h(AutoArchiveConfig, null),
     h(HistorySwitchRow, null),
+    h(SteerSwitchRow, null),
   )
 }
 
@@ -682,6 +686,34 @@ function HistorySwitchRow() {
   )
 }
 
+// 插话撤回启停开关:与历史浮层开关同构,复用同款 switch 形态与样式(同前缀);
+// 值存宿主 settings,切换经本插件路由中转,变更刷新页面生效
+function SteerSwitchRow() {
+  const [enabled, setEnabled] = useState(null)
+  useEffect(() => {
+    api(STEER_ENABLED_URL)
+      .then((payload) => setEnabled(payload ? payload.enabled !== false : true))
+      .catch(() => setEnabled(true))
+  }, [])
+  const flip = (event) => {
+    const next = event.target.checked
+    setEnabled(next)
+    api(STEER_ENABLED_URL, { method: 'POST', body: JSON.stringify({ enabled: next }) })
+      .then((payload) => {
+        toast('插话撤回已' + (payload && payload.enabled !== false ? '启用' : '停用') + ',刷新页面后生效')
+      })
+      .catch(() => {
+        setEnabled(!next)
+        toast('切换失败', { kind: 'error' })
+      })
+  }
+  return h('label', { className: 'sm-histsw' },
+    h('input', { type: 'checkbox', checked: enabled !== false, onChange: flip }),
+    h('span', { className: 'sm-histsw__track' }, h('span', { className: 'sm-histsw__thumb' })),
+    h('span', { className: 'sm-histsw__label', onClick: (event) => event.preventDefault() }, '插话撤回图标'),
+  )
+}
+
 // 自动归档配置:阈值天数与检查周期小时数,数值语义,失焦或 Enter 单字段即时提交;
 // 值存宿主 settings(与评估逻辑同源,0 = 关闭),非法输入前端拒绝不发包,
 // 服务端失败后回读生效值回滚显示
@@ -776,6 +808,7 @@ const HISTORY_SCOPE_DEFAULT = HISTORY_SCOPES.indexOf('session')
 const HISTORY_REPULL_MS = 3 * 1000
 const PROMPTS_TOGGLE_URL = '/api/session-manager/prompts/toggle'
 const HISTORY_ENABLED_URL = '/api/session-manager/history-enabled'
+const STEER_ENABLED_URL = '/api/session-manager/steer-recall-enabled'
 
 function HistoryDock({ session, inputActions }) {
   const [open, setOpen] = useState(false)
@@ -1097,6 +1130,158 @@ function HistoryDock({ session, inputActions }) {
   )
 }
 
+// 插话撤回投影:仅用户插话(宿主队列 placement=steering,已发出但未被 step 边界
+// claim 应用);queued 由官方队列面板呈现,context 为注入上下文非用户消息
+function steerRowsOf(queue) {
+  const rows = Array.isArray(queue) ? queue : []
+  return rows.filter((row) => row && row.placement === 'steering')
+}
+
+// 撤回失败文案:queue-item-not-found = 消息已被 step 边界 claim(应用),无法撤回;
+// 其余透传宿主错误消息
+function withdrawFailureText(result) {
+  const error = result && result.error
+  if (error && error.code === 'session/queue-item-not-found') return '插话已被应用,无法撤回'
+  return '撤回失败: ' + ((error && error.message) || '未知错误')
+}
+
+// 撤回动作:先宿主移除(inbox next-step 摘除,未应用即消失),成功才回填草稿,
+// 顺序保证「移除失败绝不覆盖输入框」;actions 注入便于测试与组件解耦
+async function withdrawSteer(row, actions) {
+  let result
+  try {
+    result = await actions.updateQueue(row.id, { kind: 'remove' })
+  } catch (error) {
+    actions.notify('撤回失败: ' + String(error && error.message || error), { kind: 'error' })
+    return false
+  }
+  if (!(result && result.ok)) {
+    actions.notify(withdrawFailureText(result), { kind: 'error' })
+    return false
+  }
+  try {
+    actions.setDraft(row.text)
+  } catch (error) {
+    // 摘除已成功,草稿回填失败(会话切换等竞态)时文本必须可达:通知兜底展示原文
+    actions.notify('草稿回填失败,原文: ' + row.text, { kind: 'error' })
+    return false
+  }
+  actions.notify('已撤回到输入框')
+  return true
+}
+
+// 撤回图标 svg(undo 弯箭头,stroke 继承 currentColor,尺寸由所克隆的官方按钮类控制)
+function steerRecallSvg() {
+  const namespace = 'http://www.w3.org/2000/svg'
+  const svg = document.createElementNS(namespace, 'svg')
+  svg.setAttribute('viewBox', '0 0 16 16')
+  svg.setAttribute('fill', 'none')
+  svg.setAttribute('stroke', 'currentColor')
+  svg.setAttribute('stroke-width', '1.5')
+  svg.setAttribute('stroke-linecap', 'round')
+  svg.setAttribute('stroke-linejoin', 'round')
+  svg.setAttribute('aria-hidden', 'true')
+  const paths = ['M3 6.5h6.5a3.5 3.5 0 0 1 0 7H6', 'M6 3.5 3 6.5l3 3']
+  for (const d of paths) {
+    const path = document.createElementNS(namespace, 'path')
+    path.setAttribute('d', d)
+    svg.appendChild(path)
+  }
+  return svg
+}
+
+// 注入按钮标记:识别自家节点与官方按钮,防止重复注入与误删官方节点
+const STEER_BTN_FLAG = 'data-sm-steer-recall'
+// 官方 pending steering 气泡的语义标记(官方同构:UserStyleBubble data 属性)与
+// 其操作图标排的 CSS module 类名后缀(哈希前缀随构建漂移,后缀稳定)
+const STEER_BUBBLE_SELECTOR = '[data-pending-steering]'
+const STEER_ACTIONS_SUFFIX = '[class$="_actions"]'
+
+// 插话撤回:注入原生 pending steering 气泡的操作图标排(复制图标旁),样式经克隆
+// 官方按钮 className 完全原生;气泡被应用后整棵卸载,注入按钮随之消失。
+// dock 本体 display:none 零占位,仅承载观察与注入;官方 DOM 结构漂移时注入静默
+// 跳过(不报错),干净禁用精神
+function SteerRecallDock({ session, useSession, inputActions, updateQueue }) {
+  const queue = useSession((state) => state.queue)
+  const queueMutable = useSession((state) => state.subagent === null || state.subagent.address.mode === 'continuable')
+  const [busy, setBusy] = useState(false)
+  // 启停开关(设置页):挂载拉取一次,停用即不注入并移除已注入按钮;失败按启用兜底
+  const [enabled, setEnabled] = useState(true)
+  useEffect(() => {
+    api(STEER_ENABLED_URL)
+      .then((payload) => setEnabled(payload ? payload.enabled !== false : true))
+      .catch(() => {})
+  }, [])
+  // 观察回调经由 ref 读最新状态,观察器只挂一次不随渲染重挂
+  const rowsRef = useRef([])
+  const mutableRef = useRef(true)
+  const busyRef = useRef(false)
+  const actionsRef = useRef(null)
+  rowsRef.current = steerRowsOf(queue)
+  mutableRef.current = queueMutable
+  busyRef.current = busy
+  actionsRef.current = { updateQueue, setDraft: inputActions ? inputActions.setDraft : undefined }
+  const scanRef = useRef(null)
+  useEffect(() => {
+    function withdraw(row) {
+      const actions = actionsRef.current
+      if (busyRef.current || !actions || typeof actions.updateQueue !== 'function') return
+      setBusy(true)
+      void withdrawSteer(row, { updateQueue: actions.updateQueue, setDraft: actions.setDraft, notify: toast })
+        .finally(() => setBusy(false))
+    }
+    function syncButton(button, row) {
+      const textOnly = row.text !== null
+      button.disabled = busyRef.current || !textOnly
+      button.title = textOnly ? '撤回到输入框: ' + row.preview : '含附件的插话不支持撤回'
+    }
+    function scan() {
+      const bubbles = document.querySelectorAll(STEER_BUBBLE_SELECTOR)
+      const rows = mutableRef.current ? rowsRef.current : []
+      bubbles.forEach((bubble, index) => {
+        const actionsRow = bubble.querySelector(STEER_ACTIONS_SUFFIX)
+        if (!actionsRow) return
+        let button = actionsRow.querySelector('[' + STEER_BTN_FLAG + ']')
+        const row = rows[index]
+        if (!row) {
+          // 气泡尚存但行已被应用/撤回(帧差瞬态):按钮随气泡卸载,先禁用防误触
+          if (button) button.disabled = true
+          return
+        }
+        if (!button) {
+          const official = actionsRow.querySelector('button:not([' + STEER_BTN_FLAG + '])')
+          if (!official) return
+          button = document.createElement('button')
+          button.type = 'button'
+          button.setAttribute(STEER_BTN_FLAG, '')
+          // 克隆官方按钮类名:尺寸/hover/悬停显隐(reveal)全部原生
+          button.className = official.className
+          button.addEventListener('click', () => withdraw(row))
+          button.appendChild(steerRecallSvg())
+          actionsRow.appendChild(button)
+        }
+        syncButton(button, row)
+      })
+    }
+    scanRef.current = scan
+    const observer = new MutationObserver(scan)
+    observer.observe(document.documentElement, { childList: true, subtree: true })
+    scan()
+    return () => {
+      scanRef.current = null
+      observer.disconnect()
+      document.querySelectorAll('[' + STEER_BTN_FLAG + ']').forEach((button) => button.remove())
+    }
+  }, [])
+  // 行集/开关/忙碌变化即时重扫(观察器只覆盖 DOM 变更,状态变化需主动对账)
+  useEffect(() => {
+    if (scanRef.current) scanRef.current()
+  }, [queue, enabled, busy, queueMutable])
+  if (session === undefined || inputActions === undefined || updateQueue === undefined) return null
+  if (!enabled || !queueMutable) return null
+  return h('div', { className: 'sm-steer-host' })
+}
+
     return {
       inject: ['slots', 'sessions', 'workspaces'],
       apply(ctx) {
@@ -1144,6 +1329,29 @@ function HistoryDock({ session, inputActions }) {
           console.warn('[session-manager] 历史输入入口未注册(宿主无 conversation.input.dock 插槽)', error)
         }
 
+        // 插话撤回入口:未应用的插话撤回到输入框重新编辑。RPC 走会话绑定面
+        // binding.session.updateQueue(RemoteResult 不抛错,与官方 conversation 服务
+        // 无耦合);会话面缺失或无 updateQueue(旧宿主)返回空 props,组件不渲染
+        try {
+          ctx.slots.inject('conversation.input.dock', () =>
+            ctx.slots.register(
+              {
+                name: 'conversation.input.dock',
+                id: 'session-manager-steer',
+                order: 25,
+                inject: (sessionId) => {
+                  const binding = sessions.binding(sessionId)
+                  const updateQueue = binding && binding.session && binding.session.updateQueue
+                  if (typeof updateQueue !== 'function') return {}
+                  return { updateQueue: (itemId, action) => binding.session.updateQueue(itemId, action) }
+                },
+              },
+              SteerRecallDock,
+            ))
+        } catch (error) {
+          console.warn('[session-manager] 插话撤回入口未注册(宿主无 conversation.input.dock 插槽)', error)
+        }
+
         ctx.effect(() => unsubscribe, 'session-manager archived diff')
 
         function SessionManagerPanel({ sessions: sessionSvc, workspaces: workspaceSvc }) {

package/src/core.mjs

@@ -251,10 +251,10 @@ export function filterArchiveRows(rows, query) {
 // 范围按 ←/→ 切换序排列:索引 0 为常用提示词(个人收藏),索引 1 为当前会话
 // (浮层默认落点),→ 向更大范围,← 返回收藏
 // 对齐 = 后台解压范围内会话产物与持久缓存合并;两次对齐最小间隔防持续解压。
-// 解压是同步 CPU 操作会阻塞主循环:启动零解压(历史直接读磁盘缓存),
-// 全量对齐延迟 STARTUP_DELAY 再跑、只回溯最近 STARTUP_SCAN 个会话、
-// 跳过超 MAX_ARTIFACT 的巨产物(单次 readSession 内部不可让出,巨产物一解卡死主循环);
-// 对齐中连续解压占用超 SLICE 即让出 YIELD。
+// 解压是 CPU 操作:启动零解压(历史直接读磁盘缓存),全量对齐延迟 STARTUP_DELAY
+// 再跑、只回溯最近 STARTUP_SCAN 个会话;超 MAX_ARTIFACT 的巨产物跳过——
+// 上限防的是解压耗时与事件对象内存峰值失控,非阻塞主循环;跳过线按宿主版本
+// 黑名单取值(见 isLegacyDecompressHost),对齐中连续解压占用超 SLICE 即让出 YIELD。
 // 运行中会话(当前会话)提取结果只保留内存不落盘——产物持续变化,落盘指纹立即失效
 export const HISTORY_SESSION_SCAN_LIMIT = 20
 export const HISTORY_INPUT_LIMIT = 200
@@ -266,7 +266,26 @@ export const HISTORY_STARTUP_DELAY_MS = 30 * 1000
 export const HISTORY_STARTUP_SCAN_LIMIT = 100
 export const HISTORY_ALIGN_SLICE_MS = 200
 export const HISTORY_ALIGN_YIELD_MS = 100
-export const HISTORY_ALIGN_MAX_ARTIFACT_BYTES = 8 * 1024 * 1024
+// 巨产物跳过线(压缩字节数):现役最大产物约 3.5MiB。新解压线 16MiB 留 4 倍余量,
+// 超线产物解压后可达数百 MB(压缩比约 1:3.4,事件对象再放大),内存峰值失控;
+// 旧解压线 8MiB 面向 0.1.1/0.1.2 黑名单宿主——其解压实现尚无周期让出,从严
+export const HISTORY_ALIGN_MODERN_MAX_ARTIFACT_BYTES = 16 * 1024 * 1024
+export const HISTORY_ALIGN_LEGACY_MAX_ARTIFACT_BYTES = 8 * 1024 * 1024
+// 与官方 semver 语义对齐的宽松校验:黑名单判定只取主/次/修订号,prerelease 无关
+const SEMVER_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)/
+// 旧解压实现黑名单:仅 0.1.1 与 0.1.2 系列(含各 prerelease);0.1.5 实测
+// readZstdPrefix 逐帧解压 + 周期让出。版本非法/缺失按黑名单保守回退旧线
+export function isLegacyDecompressHost(version) {
+  const match = SEMVER_PATTERN.exec(typeof version === 'string' ? version.trim() : '')
+  if (!match) return true
+  const major = Number(match[1])
+  const minor = Number(match[2])
+  const patch = Number(match[3])
+  return major === 0 && minor === 1 && (patch === 1 || patch === 2)
+}
+export function maxArtifactBytesForHost(version) {
+  return isLegacyDecompressHost(version) ? HISTORY_ALIGN_LEGACY_MAX_ARTIFACT_BYTES : HISTORY_ALIGN_MODERN_MAX_ARTIFACT_BYTES
+}
 // 会话范围路由触发焦点对齐后就地等待的时限:首条数据可见预算(3s)内
 // 留出解压+读盘份额,超时改走轮询流式补齐
 export const HISTORY_FOCUS_WAIT_MS = 2 * 1000
@@ -294,16 +313,29 @@ export function extractUserInputs(events) {
 }
 
 /** 历史输入聚合:精确文本去重保留最新时间,时间倒序,截 limit 条,单条截 maxChars 字符。
- * 条目可携带 sid(来源会话)用于 session 范围过滤,聚合时原样保留。 */
+ * 条目可携带 sid(来源会话)用于 session 范围过滤,聚合时原样保留。
+ * 首条保护:被 limit 挤出时,每个来源会话在去重后集合中的最早条目仍保留——
+ * 会话开场提示词是最有复用价值也最旧的一批,时间倒序截断总会先挤掉它们;
+ * 保护在去重后集合上计算,文本已被更新的会话复用时不再按旧会话重复追加。 */
 export function aggregateInputs(entries, { limit, maxChars }) {
   const latestByText = new Map()
   for (const entry of entries || []) {
     const known = latestByText.get(entry.text)
     if (known === undefined || entry.at > known.at) latestByText.set(entry.text, entry)
   }
-  return [...latestByText.values()]
+  const earliestBySid = new Map()
+  for (const entry of latestByText.values()) {
+    if (entry.sid === undefined) continue
+    const known = earliestBySid.get(entry.sid)
+    if (known === undefined || entry.at < known.at) earliestBySid.set(entry.sid, entry)
+  }
+  const kept = [...latestByText.values()].sort((left, right) => right.at - left.at).slice(0, limit)
+  const keptTexts = new Set(kept.map((entry) => entry.text))
+  for (const first of earliestBySid.values()) {
+    if (!keptTexts.has(first.text)) kept.push(first)
+  }
+  return kept
     .sort((left, right) => right.at - left.at)
-    .slice(0, limit)
     .map((entry) => ({
       text: entry.text.slice(0, maxChars),
       at: entry.at,

package/src/index.js

@@ -19,7 +19,6 @@ import {
   DAY_MS,
   DEFAULT_AUTO_ARCHIVE_DAYS,
   DEFAULT_AUTO_ARCHIVE_INTERVAL_HOURS,
-  HISTORY_ALIGN_MAX_ARTIFACT_BYTES,
   HISTORY_ALIGN_SLICE_MS,
   HISTORY_ALIGN_THROTTLE_MS,
   HISTORY_ALIGN_YIELD_MS,
@@ -36,7 +35,9 @@ import {
   artifactLooksBlank,
   deleteEligibility,
   extractUserInputs,
+  isLegacyDecompressHost,
   isSessionRunning,
+  maxArtifactBytesForHost,
   mergeDeletedEntry,
   removeDeletedEntry,
   selectArchiveCandidates,
@@ -44,6 +45,7 @@ import {
 } from './core.mjs'
 import { ensureCacheDir, listWorkspaceCachesCached, readPrompts, readWorkspaceCache, writePrompts, writeWorkspaceCache } from './history-cache.mjs'
 import { trashPath } from './trash.mjs'
+import { createRequire } from 'node:module'
 
 export const name = 'dsh-session-manager'
 
@@ -109,6 +111,8 @@ const SETTINGS_SCHEMA = schemastery.object({
     .description('周期评估间隔小时数,0 表示关闭周期评估;变更经周期 tick 对账,关闭即时暂停、重启用最迟下个 tick 生效'),
   historyEnabled: schemastery.boolean().default(true)
     .description('历史输入浮层(Alt+↑),低频功能,关闭后输入框锚点与快捷键整体不渲染;变更刷新页面生效'),
+  steerRecallEnabled: schemastery.boolean().default(true)
+    .description('插话撤回图标(输入框上方),低频功能,关闭后撤回图标整体不渲染;变更刷新页面生效'),
 })
 
 function sendJson(res, status, payload) {
@@ -136,6 +140,7 @@ function readSettings(ctx) {
     days: Number.isInteger(days) && days >= 0 ? days : DEFAULT_AUTO_ARCHIVE_DAYS,
     intervalHours: Number.isInteger(hours) && hours >= 0 ? hours : DEFAULT_AUTO_ARCHIVE_INTERVAL_HOURS,
     historyEnabled: !value || value.historyEnabled !== false,
+    steerRecallEnabled: !value || value.steerRecallEnabled !== false,
   }
 }
 
@@ -382,7 +387,7 @@ export function apply(ctx, config) {
   }
 
   // 历史输入:工作区粒度持久缓存(~/.dsh/historyPrompt/<工作区>-<hash>.json)。
-  // 浮层请求直接读缓存文件立即返回(毫秒级);对齐在后台解压范围内最近会话产物,
+  // 浮层请求直接读缓存文件立即返回(毫秒级);对齐在后台解压范围内会话产物,
   // 与缓存合并去重后写回——运行中会话也参与(实时追加其新输入)。
   // 解压不重复执行:每会话提取结果持久化在工作区缓存 extracts 段,附产物 stat 指纹
   // (mtimeMs+size),对齐时先 stat 比对,产物没变零解压——判断全部基于磁盘,跨重启生效。
@@ -391,6 +396,20 @@ export function apply(ctx, config) {
   // STARTUP_DELAY 再跑,绝不阻塞宿主启动。测试经 env DSH_HISTORY_CACHE_DIR 注入临时目录
   const cacheDir = process.env.DSH_HISTORY_CACHE_DIR
     || join(homedir(), '.dsh', 'historyPrompt')
+  // 巨产物跳过线按宿主版本黑名单取值:0.1.1/0.1.2 解压实现无周期让出从严 8MiB,
+  // 其余 16MiB。运行宿主清单经 require 链解析(插件随宿主树部署时必命中),
+  // 探测失败按黑名单保守回退旧线。激活时求值一次即冻结,热路径只读值;
+  // 宿主热升级后重启生效
+  let maxArtifactBytes = resolveMaxArtifactBytes()
+  function resolveMaxArtifactBytes() {
+    let version = null
+    try {
+      version = createRequire(import.meta.url)('@deepseek-ai/dsh/package.json').version
+    } catch {
+      version = null
+    }
+    return maxArtifactBytesForHost(version)
+  }
   const alignThrottle = new Map()
   const runtimeExtracts = new Map()
   const headerCache = new Map()
@@ -447,8 +466,8 @@ export function apply(ctx, config) {
 
   // 批量对齐执行体:列出范围会话,逐个按指纹增量提取(磁盘 extracts 复用),
   // 与缓存合并后原子写回,extracts 裁剪到完整扫描窗口。经批量队列入队。
-  // 超过 MAX_ARTIFACT 的巨产物直接跳过:单次 readSession 内部同步解压不可让出,
-  // 巨会话一解卡死主循环;其历史来自缓存 entries 的既有贡献
+  // 超过 MAX_ARTIFACT 的巨产物直接跳过:解压耗时与内存峰值随产物规模失控
+  // (宿主内部逐帧解压带周期让出,不阻塞主循环);其历史来自缓存 entries 的既有贡献
   function alignWorkspaceNow(cwd) {
     return enqueueBulkAlign(async () => {
       const agents = ctx.get('agents')
@@ -465,7 +484,7 @@ export function apply(ctx, config) {
         const isRunning = isSessionRunning({ agents, sessionId: recordItem.header.id })
         const located = persistence ? persistence.locate(recordItem.header) : undefined
         const fingerprint = located ? await safeStat(located.path) : null
-        if (fingerprint !== null && fingerprint.size > HISTORY_ALIGN_MAX_ARTIFACT_BYTES) continue
+        if (fingerprint !== null && fingerprint.size > resolveMaxArtifactBytes()) continue
         try {
           const entries = await extractSession(recordItem, fingerprint, extracts, isRunning)
           fresh.push(...entries.map((entry) => ({ ...entry, sid: recordItem.header.id })))
@@ -501,7 +520,7 @@ export function apply(ctx, config) {
       const persistence = ctx.get('sessionPersistence')
       const located = persistence ? persistence.locate(header) : undefined
       const fingerprint = located ? await safeStat(located.path) : null
-      if (fingerprint === null || fingerprint.size > HISTORY_ALIGN_MAX_ARTIFACT_BYTES) return
+      if (fingerprint === null || fingerprint.size > resolveMaxArtifactBytes()) return
       const isRunning = isSessionRunning({ agents: ctx.get('agents'), sessionId })
       const cached = await readWorkspaceCache(cacheDir, cwd)
       const extracts = cached && cached.extracts ? { ...cached.extracts } : {}
@@ -576,7 +595,7 @@ export function apply(ctx, config) {
       // 实时追加:产物 stat 与已知指纹不一致 = 会话有新输入未入缓存——聚焦对齐
       // 只解该会话并写回。路由有界等待本次对齐(首条 <3s 预算):正常会话单次
       // 请求内直接拿到新数据;超时(巨产物等)返回既有数据 aligned=false,后续
-      // 轮询流式补齐。巨产物跳过聚焦(单次解压不可让出),维持 aligned=true
+      // 轮询流式补齐。巨产物跳过聚焦(解压耗时与内存峰值失控),维持 aligned=true
       const check = async (cached) => {
         const agents = ctx.get('agents')
         const running = isSessionRunning({ agents, sessionId })
@@ -585,7 +604,7 @@ export function apply(ctx, config) {
         const fingerprint = located ? await safeStat(located.path) : null
         return {
           stale: fingerprint !== null && !(known && known.mtimeMs === fingerprint.mtimeMs && known.size === fingerprint.size),
-          oversize: fingerprint !== null && fingerprint.size > HISTORY_ALIGN_MAX_ARTIFACT_BYTES,
+          oversize: fingerprint !== null && fingerprint.size > resolveMaxArtifactBytes(),
         }
       }
       let { cached, mine } = await read()
@@ -898,6 +917,32 @@ export function apply(ctx, config) {
         }
       },
     },
+    {
+      // 插话撤回启停:与历史浮层开关同构,读走 settings,写经 settings.update
+      path: '/api/session-manager/steer-recall-enabled',
+      handler: async (req, res) => {
+        try {
+          if (req.method === 'GET') {
+            sendJson(res, 200, { enabled: readSettings(ctx).steerRecallEnabled })
+            return
+          }
+          if (!rejectMethod(req, res, 'POST')) return
+          let body
+          try {
+            body = JSON.parse(await readBody(req))
+          } catch {
+            throw new Error(MESSAGES.badJsonBody)
+          }
+          const settings = ctx.get('settings')
+          if (!settings) throw new Error('宿主设置服务不可用')
+          // update 异步落盘后才提交新值:await 保证持久化完成后再读回
+          await settings.update(NAMESPACE, { steerRecallEnabled: Boolean(body && body.enabled) })
+          sendJson(res, 200, { enabled: readSettings(ctx).steerRecallEnabled })
+        } catch (error) {
+          respondError(ctx, res, error)
+        }
+      },
+    },
     {
       // 自动归档配置:读回生效值(含默认回退),写经 settings.update 部分更新;
       // 0 = 关闭(阈值天数关自动归档,间隔小时数关周期轮),与评估逻辑同源语义

package/test/client-steer.test.mjs

@@ -0,0 +1,266 @@
+// 插话撤回(steer recall)接线与纯函数测试:加载真实 src/client.js,
+// 捕获 slots.register 断言 dock 条目结构,切片实例化纯函数锁定撤回动作与失败文案。
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+
+const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..')
+const CLIENT_SRC = readFileSync(join(PKG_ROOT, 'src', 'client.js'), 'utf8')
+
+// 加载 client.js 并执行 apply(mock 最小服务面),返回插槽注册捕获。
+// slots.inject 收到注册回调即同步执行;binding 桩仅对会话 s1 生效
+function loadClient({ binding } = {}) {
+  const modules = []
+  const registered = []
+  const injectedNames = []
+  const windowStub = { __ModuleLoader__: { load: (module) => modules.push(module) }, addEventListener: () => {} }
+  const reactStub = {
+    useState: (value) => [value, () => {}],
+    useEffect: () => {},
+    useSyncExternalStore: () => [],
+    useRef: (value) => ({ current: value }),
+    createElement: () => null,
+  }
+  const requireStub = (name) => {
+    if (name === '@mzzsfy/dsh-toast/client') return { show: () => 0 }
+    return reactStub
+  }
+  const factory = new Function('window', 'require', 'document', CLIENT_SRC + '\n;return null')
+  factory(
+    windowStub,
+    requireStub,
+    { createElement: () => ({ style: {}, remove() {} }), head: { appendChild: () => {} }, body: { appendChild: () => {} } },
+  )
+  assert.equal(modules.length, 1, 'client.js 模块未被捕获')
+  const mod = modules[0].factory(requireStub)
+
+  const sessions = {
+    binding: (sessionId) => (sessionId === 's1' ? binding : undefined),
+    list: { subscribe: () => () => {}, getSnapshot: () => ({ ids: [], byId: {} }) },
+  }
+  const workspaces = {
+    list: { subscribe: () => () => {}, getSnapshot: () => undefined },
+  }
+  const ctx = {
+    get: (name) => (name === 'sessions' ? sessions : name === 'workspaces' ? workspaces : {}),
+    effect: () => {},
+    slots: {
+      inject: (name, register) => { injectedNames.push(name); register() },
+      register: (options, component) => registered.push({ options, component }),
+    },
+  }
+  mod.apply(ctx)
+  return { registered, injectedNames }
+}
+
+// 插话撤回 dock 条目捕获:与官方 queue dock(order 20)、goal dock(order 10)同槽位
+function findSteerEntry(options) {
+  const { registered, injectedNames } = loadClient(options)
+  assert.ok(injectedNames.includes('conversation.input.dock'), 'apply 未注入 conversation.input.dock 插槽')
+  const entries = registered.filter((item) => item.options.name === 'conversation.input.dock')
+  const entry = entries.find((item) => item.options.id === 'session-manager-steer')
+  assert.ok(entry, '未注册 id=session-manager-steer 的插话撤回 dock 条目')
+  return { entry, entries }
+}
+
+test('Given client.js 装载, When apply, Then 注册插话撤回 dock 条目且历史浮层条目保留', () => {
+  const { entry, entries } = findSteerEntry()
+  assert.equal(typeof entry.component, 'function', 'dock 条目缺组件')
+  assert.equal(entry.options.order, 25, '插话撤回条目 order 应紧邻官方队列面板(20)之后')
+  assert.ok(entries.some((item) => item.options.id === 'session-manager-history'), '历史浮层条目被挤掉')
+})
+
+test('Given 会话绑定存在, When dock inject, Then updateQueue 路由到 binding.session.updateQueue', async () => {
+  const calls = []
+  const binding = {
+    session: {
+      updateQueue: async (itemId, action) => {
+        calls.push({ itemId, action })
+        return { ok: true }
+      },
+    },
+  }
+  const { entry } = findSteerEntry({ binding })
+  const props = entry.options.inject('s1')
+  assert.equal(typeof props.updateQueue, 'function', 'inject 未返回 updateQueue')
+  const result = await props.updateQueue('m1', { kind: 'remove' })
+  assert.deepEqual(calls, [{ itemId: 'm1', action: { kind: 'remove' } }], 'updateQueue 未按 remove 动作透传')
+  assert.deepEqual(result, { ok: true })
+})
+
+test('Given 会话绑定缺失, When dock inject, Then 返回空 props(干净禁用)', () => {
+  const { entry } = findSteerEntry()
+  assert.deepEqual(entry.options.inject('s1'), {}, '绑定缺失应返回空 props')
+  assert.deepEqual(entry.options.inject('missing'), {}, '未知会话应返回空 props')
+})
+
+test('Given 会话面无 updateQueue(旧宿主), When dock inject, Then 返回空 props(干净禁用)', () => {
+  const { entry } = findSteerEntry({ binding: { session: {} } })
+  assert.deepEqual(entry.options.inject('s1'), {}, '会话面无 updateQueue 应返回空 props')
+})
+
+// 纯函数切片:steerRowsOf / withdrawFailureText / withdrawSteer(无外部依赖,动作经注入)
+const PURE_START = CLIENT_SRC.indexOf('function steerRowsOf(')
+const PURE_END = CLIENT_SRC.indexOf('function SteerRecallDock(')
+assert.ok(PURE_START >= 0 && PURE_END > PURE_START, 'client.js 插话撤回纯函数切片定位失败')
+const pure = new Function(
+  CLIENT_SRC.slice(PURE_START, PURE_END)
+  + '; return { steerRowsOf: steerRowsOf, withdrawFailureText: withdrawFailureText, withdrawSteer: withdrawSteer }',
+)()
+
+const STEERING_ROW = { id: 'm1', placement: 'steering', preview: '帮我看下', text: '帮我看下' }
+
+test('steerRowsOf:仅保留 placement=steering,防非数组与非行形态', () => {
+  const queue = [
+    { id: 'q1', placement: 'queued' },
+    STEERING_ROW,
+    { id: 'c1', placement: 'context' },
+    STEERING_ROW,
+    null,
+  ]
+  assert.deepEqual(pure.steerRowsOf(queue), [STEERING_ROW, STEERING_ROW])
+  assert.deepEqual(pure.steerRowsOf([]), [])
+  assert.deepEqual(pure.steerRowsOf(undefined), [])
+})
+
+test('withdrawSteer 主路径:remove 成功后回填草稿并提示,返回 true', async () => {
+  const calls = []
+  const actions = {
+    updateQueue: async (itemId, action) => { calls.push({ itemId, action }); return { ok: true } },
+    setDraft: (text) => calls.push({ setDraft: text }),
+    notify: (text, opts) => calls.push({ notify: text, opts }),
+  }
+  const done = await pure.withdrawSteer(STEERING_ROW, actions)
+  assert.equal(done, true)
+  assert.deepEqual(calls, [
+    { itemId: 'm1', action: { kind: 'remove' } },
+    { setDraft: '帮我看下' },
+    { notify: '已撤回到输入框', opts: undefined },
+  ])
+})
+
+test('withdrawSteer 已被应用:queue-item-not-found 不回填草稿,专用文案报错', async () => {
+  const calls = []
+  const actions = {
+    updateQueue: async () => ({ ok: false, error: { code: 'session/queue-item-not-found', message: 'queued item is no longer pending' } }),
+    setDraft: (text) => calls.push({ setDraft: text }),
+    notify: (text, opts) => calls.push({ notify: text, opts }),
+  }
+  const done = await pure.withdrawSteer(STEERING_ROW, actions)
+  assert.equal(done, false)
+  assert.deepEqual(calls, [{ notify: '插话已被应用,无法撤回', opts: { kind: 'error' } }])
+})
+
+test('withdrawSteer 其他失败:透传错误消息且不回填草稿', async () => {
+  const calls = []
+  const actions = {
+    updateQueue: async () => ({ ok: false, error: { code: 'session/steer-unavailable', message: 'busy' } }),
+    setDraft: (text) => calls.push({ setDraft: text }),
+    notify: (text, opts) => calls.push({ notify: text, opts }),
+  }
+  const done = await pure.withdrawSteer(STEERING_ROW, actions)
+  assert.equal(done, false)
+  assert.deepEqual(calls, [{ notify: '撤回失败: busy', opts: { kind: 'error' } }])
+})
+
+test('withdrawSteer 传输层拒绝:按错误处理且不回填草稿', async () => {
+  const calls = []
+  const actions = {
+    updateQueue: async () => { throw new Error('network down') },
+    setDraft: (text) => calls.push({ setDraft: text }),
+    notify: (text, opts) => calls.push({ notify: text, opts }),
+  }
+  const done = await pure.withdrawSteer(STEERING_ROW, actions)
+  assert.equal(done, false)
+  assert.deepEqual(calls, [{ notify: '撤回失败: network down', opts: { kind: 'error' } }])
+})
+
+test('withdrawSteer 摘除成功但回填抛错:兜底展示原文,不报成功', async () => {
+  const calls = []
+  const actions = {
+    updateQueue: async () => ({ ok: true }),
+    setDraft: () => { throw new Error('shell released') },
+    notify: (text, opts) => calls.push({ notify: text, opts }),
+  }
+  const done = await pure.withdrawSteer(STEERING_ROW, actions)
+  assert.equal(done, false)
+  assert.deepEqual(calls, [{ notify: '草稿回填失败,原文: 帮我看下', opts: { kind: 'error' } }])
+})
+
+// ── 组件级门控:干净禁用规约的落地断言(整源加载 + 记录型 createElement 直接调组件) ──
+
+// createElement 桩记录调用树:h(type, props, ...children) -> {type, props, children}
+function loadComponent() {
+  const modules = []
+  const registered = []
+  const windowStub = { __ModuleLoader__: { load: (module) => modules.push(module) }, addEventListener: () => {} }
+  const element = (type, props, ...children) => ({ type, props, children })
+  const reactStub = {
+    useState: (value) => [value, () => {}],
+    useEffect: () => {},
+    useRef: (value) => ({ current: value }),
+    createElement: element,
+  }
+  const requireStub = (name) => {
+    if (name === '@mzzsfy/dsh-toast/client') return { show: () => 0 }
+    return reactStub
+  }
+  const factory = new Function('window', 'require', 'document', CLIENT_SRC + '\n;return null')
+  factory(
+    windowStub,
+    requireStub,
+    { createElement: () => ({ style: {}, remove() {} }), head: { appendChild: () => {} }, body: { appendChild: () => {} } },
+  )
+  const mod = modules[0].factory(requireStub)
+  const sessions = { binding: () => undefined, list: { subscribe: () => () => {}, getSnapshot: () => ({ ids: [], byId: {} }) } }
+  const workspaces = { list: { subscribe: () => () => {}, getSnapshot: () => undefined } }
+  const ctx = {
+    get: (name) => (name === 'sessions' ? sessions : name === 'workspaces' ? workspaces : {}),
+    effect: () => {},
+    slots: {
+      inject: (name, register) => register(),
+      register: (options, component) => registered.push({ options, component }),
+    },
+  }
+  mod.apply(ctx)
+  const entry = registered.find((item) => item.options.id === 'session-manager-steer')
+  assert.ok(entry, '组件级测试未捕获插话撤回条目')
+  return entry.component
+}
+
+const DOCK_COMPONENT = loadComponent()
+const NO_ACTIONS = { setDraft: () => {} }
+const OK_UPDATE = async () => ({ ok: true })
+
+// useSession 桩:两次 selector 读取共用同一快照(与官方 SessionSnapshotSelector 单快照同构)
+function dockWith(snapshot) {
+  const useSession = (selector) => selector(snapshot)
+  return (props) => DOCK_COMPONENT({ session: {}, useSession, inputActions: NO_ACTIONS, updateQueue: OK_UPDATE, ...props })
+}
+
+test('SteerRecallDock 干净禁用:依赖任一缺失即返回 null', () => {
+  const dock = dockWith({ queue: [STEERING_ROW], subagent: null })
+  assert.equal(dock({ session: undefined }), null, 'session 缺失应不渲染')
+  assert.equal(dock({ inputActions: undefined }), null, 'inputActions 缺失应不渲染')
+  assert.equal(dock({ updateQueue: undefined }), null, 'updateQueue 缺失应不渲染')
+})
+
+test('SteerRecallDock 干净禁用:subagent 非 continuable 即返回 null,启用时零占位宿主', () => {
+  const locked = dockWith({ queue: [STEERING_ROW], subagent: { address: { mode: 'prompt' } } })
+  assert.equal(locked({}), null, 'queueMutable 为假应不渲染')
+  const host = dockWith({ queue: [], subagent: null })({})
+  assert.equal(host.type, 'div')
+  assert.equal(host.props.className, 'sm-steer-host', '启用时应渲染 display:none 宿主承载注入逻辑')
+})
+
+// 注入契约(源码级守卫):选择器/标记/清理必须存在,官方 DOM 结构漂移时静默降级
+test('SteerRecallDock 注入契约:语义标记选择器、按钮标记与卸载清理齐备', () => {
+  assert.ok(CLIENT_SRC.includes('[data-pending-steering]'), '应定位官方气泡语义标记')
+  assert.ok(CLIENT_SRC.includes('[class$="_actions"]'), '应按 CSS module 类名后缀定位官方图标排')
+  assert.ok(CLIENT_SRC.includes("data-sm-steer-recall"), '应有自家按钮标记防重复注入')
+  assert.ok(CLIENT_SRC.includes('new MutationObserver'), '应经 MutationObserver 跟随气泡出现')
+  assert.ok(CLIENT_SRC.includes('official.className'), '应克隆官方按钮类名保证样式原生')
+  assert.ok(CLIENT_SRC.includes('observer.disconnect()'), '卸载应断开观察')
+})

package/test/core.test.mjs

@@ -9,6 +9,8 @@ import {
   DAY_MS,
   DEFAULT_AUTO_ARCHIVE_DAYS,
   DELETE_MESSAGES,
+  HISTORY_ALIGN_LEGACY_MAX_ARTIFACT_BYTES,
+  HISTORY_ALIGN_MODERN_MAX_ARTIFACT_BYTES,
   TOAST_MAX_TITLES,
   aggregateDeleteOutcome,
   aggregateInputs,
@@ -21,6 +23,7 @@ import {
   filterArchiveRows,
   groupArchiveRowsByWorkspace,
   isSessionRunning,
+  maxArtifactBytesForHost,
   mergeDeletedEntry,
   pageArchiveRows,
   projectArchiveRows,
@@ -515,3 +518,78 @@ test('历史输入聚合:limit 裁剪与单条截断', () => {
   ], { limit: 1, maxChars: 3 })
   assert.deepEqual(merged, [{ text: 'xy', at: 2 }])
 })
+
+// ── 历史输入:每会话首条保护(挤出不做永久丢弃)──
+
+test('历史输入聚合:超 limit 挤出时每个会话最早条目仍保留', () => {
+  const merged = aggregateInputs([
+    { text: '开场提示词', at: 1, sid: 's-old' },
+    { text: '继续', at: 2, sid: 's-old' },
+    { text: '新会话开场', at: 3, sid: 's-new' },
+    { text: '收尾', at: 4, sid: 's-new' },
+  ], { limit: 2, maxChars: 100 })
+  assert.deepEqual(merged, [
+    { text: '收尾', at: 4, sid: 's-new' },
+    { text: '新会话开场', at: 3, sid: 's-new' },
+    { text: '开场提示词', at: 1, sid: 's-old' },
+  ])
+})
+
+test('历史输入聚合:首条已在 limit 内不多余追加,结果仍为时间倒序', () => {
+  const merged = aggregateInputs([
+    { text: 'a', at: 1, sid: 's1' },
+    { text: 'b', at: 2, sid: 's2' },
+  ], { limit: 10, maxChars: 100 })
+  assert.deepEqual(merged, [{ text: 'b', at: 2, sid: 's2' }, { text: 'a', at: 1, sid: 's1' }])
+})
+
+test('历史输入聚合:首条保护在去重后集合上计算,与 limit 内文本重复不产生双条目', () => {
+  // s-old 的首条文本与 s-new 的某条相同:去重保留最新,归属 s-new,不再重复追加
+  const merged = aggregateInputs([
+    { text: '继续', at: 1, sid: 's-old' },
+    { text: '继续', at: 9, sid: 's-new' },
+    { text: '其他', at: 5, sid: 's-new' },
+  ], { limit: 1, maxChars: 100 })
+  assert.deepEqual(merged, [{ text: '继续', at: 9, sid: 's-new' }, { text: '其他', at: 5, sid: 's-new' }])
+})
+
+test('历史输入聚合:无 sid 条目不触发首条保护', () => {
+  const merged = aggregateInputs([
+    { text: 'old', at: 1 },
+    { text: 'new', at: 2 },
+  ], { limit: 1, maxChars: 100 })
+  assert.deepEqual(merged, [{ text: 'new', at: 2 }])
+})
+
+test('历史输入聚合:首条保护同样受 maxChars 截断', () => {
+  const merged = aggregateInputs([
+    { text: 'abcdef', at: 1, sid: 's1' },
+    { text: 'xy', at: 2, sid: 's2' },
+  ], { limit: 1, maxChars: 3 })
+  assert.deepEqual(merged, [{ text: 'xy', at: 2, sid: 's2' }, { text: 'abc', at: 1, sid: 's1' }])
+})
+
+// ── 巨产物跳过线:宿主版本黑名单 ──
+
+test('巨产物跳过线:0.1.1 与 0.1.2 系列(含 prerelease)按旧线', () => {
+  for (const version of ['0.1.1', '0.1.1-rc.2', '0.1.2', '0.1.2-rc.1', '0.1.2-alpha.2']) {
+    assert.equal(maxArtifactBytesForHost(version), HISTORY_ALIGN_LEGACY_MAX_ARTIFACT_BYTES, version)
+  }
+})
+
+test('巨产物跳过线:0.1.3 起与未知未来版本按新线', () => {
+  for (const version of ['0.1.3', '0.1.5', '0.1.5-rc.1', '0.2.0', '1.0.0']) {
+    assert.equal(maxArtifactBytesForHost(version), HISTORY_ALIGN_MODERN_MAX_ARTIFACT_BYTES, version)
+  }
+})
+
+test('巨产物跳过线:版本缺失或非法保守回退旧线', () => {
+  for (const version of [null, undefined, '', 'garbage', '0.1']) {
+    assert.equal(maxArtifactBytesForHost(version), HISTORY_ALIGN_LEGACY_MAX_ARTIFACT_BYTES, String(version))
+  }
+})
+
+test('巨产物跳过线:新旧线常量与实测依据自洽', () => {
+  assert.equal(HISTORY_ALIGN_LEGACY_MAX_ARTIFACT_BYTES, 8 * 1024 * 1024)
+  assert.equal(HISTORY_ALIGN_MODERN_MAX_ARTIFACT_BYTES, 16 * 1024 * 1024)
+})

package/test/index.test.mjs

@@ -1639,12 +1639,14 @@ test('历史输入路由:运行中会话参与对齐(实时追加),缓存上限
       },
     })
     const res = await requestUntil(handlers, '?sessionId=s1&scope=workspace',
-      (body) => body.aligned && body.inputs.length === HISTORY_INPUT_LIMIT)
+      (body) => body.aligned && body.inputs.length === HISTORY_INPUT_LIMIT + 1)
     const texts = res.body.inputs.map((item) => item.text)
-    assert.equal(texts.length, HISTORY_INPUT_LIMIT)
+    // 运行中会话输入量远超上限:limit 之外仅追加该会话去重后最早一条(s1 首条已在 limit 内)
+    assert.equal(texts.length, HISTORY_INPUT_LIMIT + 1)
     assert.ok(texts.includes('历史输入'), '最新既有输入保留')
     assert.ok(texts.includes('运行输入' + (HISTORY_INPUT_LIMIT + 49)), '次新运行输入保留')
-    assert.ok(!texts.includes('运行输入0'), '最旧输入被上限裁剪')
+    assert.ok(texts.includes('运行输入0'), '运行中会话最早输入受首条保护')
+    assert.ok(!texts.includes('运行输入1'), '首条之外的旧输入仍被上限裁剪')
     assert.ok(readCounts.get('running1') >= 1, '运行中会话被对齐解压')
     const sessionRes = await requestUntilAligned(handlers, '?sessionId=running1&scope=session')
     assert.ok(sessionRes.body.inputs.length > 0, 'session 范围可取运行中会话自身输入')