@mzzsfy/dsh-session-manager 0.8.1 → 0.9.1

package/test/parity.test.mjs

@@ -211,17 +211,6 @@ test('源码契约:client 分页粒度常量与 core ARCHIVE_PAGE_SIZE 同值',
   assert.ok(guard.test(CLIENT_SRC), 'client 分页粒度常量与 core 漂移')
 })
 
-test('源码契约:client fetchInputs 必须解包 host 响应信封 { inputs }', () => {
-  // host 与 client 对信封各自测试自洽时,信封形状漂移只会以运行时 TypeError 暴露;
-  // 此守卫锁定解包点存在,防消费侧把信封对象当数组使用
-  const guard = /Array\.isArray\((\w+)\.inputs\)/
-  assert.ok(guard.test('Array.isArray(payload.inputs)'), '守卫正则必须命中合规样本')
-  const fetchStart = CLIENT_SRC.indexOf('function fetchInputs(')
-  const fetchBody = fetchStart >= 0 ? CLIENT_SRC.slice(fetchStart, CLIENT_SRC.indexOf('}', fetchStart)) : ''
-  assert.ok(fetchBody.includes('api(INPUTS_URL'), '未找到 fetchInputs 的 host 请求')
-  assert.ok(guard.test(fetchBody), 'fetchInputs 缺少 payload.inputs 数组解包')
-})
-
 test('parity 文案:client 确认态文案与 host MESSAGES.unsupportedBackend 同值', () => {
   const match = INDEX_SRC.match(/unsupportedBackend: '([^']+)'/)
   assert.ok(match, 'index.js 缺少 unsupportedBackend 文案')

package/test/trash.test.mjs

@@ -2,11 +2,11 @@
 
 import test from 'node:test'
 import assert from 'node:assert/strict'
-import { mkdtemp, writeFile, rm, access } from 'node:fs/promises'
+import { mkdtemp, mkdir, writeFile, readFile, rm, access } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import path from 'node:path'
 
-import { TRASH_ENV_NAME, trashCommandFor, trashPath } from '../src/trash.mjs'
+import { TRASH_ENV_NAME, moveToQuarantine, restoreFromQuarantine, trashCommandFor, trashPath } from '../src/trash.mjs'
 
 test('Windows 走 PowerShell VisualBasic 回收站,路径经环境变量传递', () => {
   const cmd = trashCommandFor('win32', 'C:\\logs\\a.jsonl')
@@ -71,3 +71,74 @@ test('trashPath 向执行器传递超时配置', async () => {
   await trashPath('C:\\x\\a.jsonl', { platform: 'linux', run, timeoutMs: 5 * 1000 })
   assert.equal(captured[1].timeout, 5 * 1000)
 })
+
+// Given 回收区目录不存在与同名基名, When moveToQuarantine, Then 目录整体搬入回收区
+// 且返回唯一暂存路径(原路径消失,暂存路径存在)
+test('moveToQuarantine:目录整体搬入回收区并返回暂存路径(真实 rename)', { skip: process.platform !== 'win32' && process.platform !== 'linux' && process.platform !== 'darwin' }, async () => {
+  const base = await mkdtemp(path.join(tmpdir(), 'dsh-quarantine-'))
+  const quarantineDir = path.join(base, 'held')
+  const artifactDir = path.join(base, 'sess-1')
+  await mkdir(path.join(artifactDir, 'inner'), { recursive: true })
+  await writeFile(path.join(artifactDir, 'inner', 'a.jsonl'), '{"header":1}\n')
+  try {
+    const heldPath = await moveToQuarantine(artifactDir, quarantineDir)
+    assert.ok(heldPath.startsWith(quarantineDir), '暂存路径应在回收区目录内')
+    await assert.rejects(access(artifactDir), '原路径应消失')
+    const moved = await readFile(path.join(heldPath, 'inner', 'a.jsonl'), 'utf8')
+    assert.equal(moved, '{"header":1}\n')
+  } finally {
+    await rm(base, { recursive: true, force: true })
+  }
+})
+
+// Given rename 因跨设备失败(EXDEV), When moveToQuarantine, Then 回退为复制后删除原路径
+test('moveToQuarantine:EXDEV 回退复制+删除(注入 fs)', async () => {
+  const calls = []
+  const fakeFs = {
+    rename: async (from, to) => {
+      calls.push(['rename', from, to])
+      throw Object.assign(new Error('cross-device'), { code: 'EXDEV' })
+    },
+    cp: async (from, to) => { calls.push(['cp', from, to]) },
+    rm: async (target) => { calls.push(['rm', target]) },
+    mkdir: async () => { calls.push(['mkdir']) },
+  }
+  const heldPath = await moveToQuarantine('/data/sess-1', '/home/.dsh/held', { fs: fakeFs, now: () => 1234 })
+  assert.equal(heldPath, path.join('/home/.dsh/held', 'sess-1-1234'))
+  assert.deepEqual(calls, [
+    ['mkdir'],
+    ['rename', '/data/sess-1', heldPath],
+    ['cp', '/data/sess-1', heldPath],
+    ['rm', '/data/sess-1'],
+  ])
+})
+
+// Given 回收区暂存的目录与空缺的原位置, When restoreFromQuarantine, Then 目录回到原位置且暂存消失
+test('restoreFromQuarantine:移回原位置且暂存消失(真实 rename)', { skip: process.platform !== 'win32' && process.platform !== 'linux' && process.platform !== 'darwin' }, async () => {
+  const base = await mkdtemp(path.join(tmpdir(), 'dsh-quarantine-'))
+  const quarantineDir = path.join(base, 'held')
+  const originalDir = path.join(base, 'sess-2')
+  await mkdir(path.join(originalDir, 'inner'), { recursive: true })
+  await writeFile(path.join(originalDir, 'inner', 'a.jsonl'), '{"header":1}\n')
+  try {
+    const heldPath = await moveToQuarantine(originalDir, quarantineDir)
+    await restoreFromQuarantine(heldPath, originalDir)
+    await assert.rejects(access(heldPath), '暂存路径应消失')
+    const restored = await readFile(path.join(originalDir, 'inner', 'a.jsonl'), 'utf8')
+    assert.equal(restored, '{"header":1}\n')
+  } finally {
+    await rm(base, { recursive: true, force: true })
+  }
+})
+
+// Given rename 因原位置已被占用而失败, When restoreFromQuarantine, Then 错误原样抛出由调用方响应
+test('restoreFromQuarantine:原位置已存在时失败上抛(注入 fs)', async () => {
+  const occupied = Object.assign(new Error('not empty'), { code: 'ENOTEMPTY' })
+  const fakeFs = {
+    rename: async () => { throw occupied },
+    cp: async () => { throw new Error('不应回退复制') },
+    rm: async () => { throw new Error('不应删除') },
+    mkdir: async () => {},
+  }
+  await assert.rejects(restoreFromQuarantine('/held/s1', '/data/s1', { fs: fakeFs }), (error) => error.code === 'ENOTEMPTY')
+})

package/src/history-cache.mjs

@@ -1,127 +0,0 @@
-// 历史输入工作区缓存:每工作区一个 JSON 文件(~/.dsh/historyPrompt/<工作区>-<hash>.json),
-// 记录该工作区聚合后的人类输入(带 sid 溯源)。浮层请求直接读文件(毫秒级)立即返回,
-// 对齐在后台解压最新产物与缓存合并写回——解压成本不落在用户等待路径上。
-// extracts 段持久化每会话的提取结果与其产物 stat 指纹(mtimeMs+size):
-// 对齐时先 stat 比对指纹,产物没变的会话不再解压——判断完全基于磁盘,跨重启生效。
-// 文件名 = 工作区路径末段(可辨认)+ 路径哈希前缀(防不同目录同名冲突)
-
-import { createHash } from 'node:crypto'
-import { mkdir, readFile, readdir, stat, writeFile, rename } from 'node:fs/promises'
-import { dirname, join, sep } from 'node:path'
-
-function workspaceFile(dir, cwd) {
-  const leaf = cwd.split(/[\\/]/).filter(Boolean).pop() || 'root'
-  const hash = createHash('sha1').update(cwd).digest('hex').slice(0, 8)
-  return join(dir, `${leaf}-${hash}.json`)
-}
-
-export function ensureCacheDir(dir) {
-  return mkdir(dir, { recursive: true })
-}
-
-function normalize(parsed, cwd) {
-  if (!parsed || parsed.cwd !== cwd || !Array.isArray(parsed.entries)) return null
-  return {
-    cwd,
-    entries: parsed.entries,
-    extracts: parsed.extracts && typeof parsed.extracts === 'object' ? parsed.extracts : {},
-  }
-}
-
-export async function readWorkspaceCache(dir, cwd) {
-  try {
-    return normalize(JSON.parse(await readFile(workspaceFile(dir, cwd), 'utf8')), cwd)
-  } catch {
-    return null
-  }
-}
-
-// 原子写:先写临时文件再改名,进程中断不会留下半截 JSON
-export async function writeWorkspaceCache(dir, cwd, cache) {
-  await ensureCacheDir(dir)
-  const target = workspaceFile(dir, cwd)
-  const tmp = target + '.tmp'
-  await writeFile(tmp, JSON.stringify({ cwd, entries: cache.entries, extracts: cache.extracts }, null, 0), 'utf8')
-  await rename(tmp, target)
-}
-
-// global 浮层轮询用指纹缓存:每 3s 轮询都全量读取并 JSON.parse 所有工作区缓存文件,
-// 单文件 entries 可达数百条,持续打开浮层时是秒级重复大 IO+CPU。以 (mtimeMs,size)
-// 指纹复用上次解析结果,产物未变的文件不再读盘;写入侧经临时文件改名,mtime 必变,
-// 指纹天然失效。模块级 Map 以全路径为键(防多目录同名文件串扰),条目数有界。
-const globalCachePollState = new Map()
-
-export async function listWorkspaceCachesCached(dir) {
-  let names
-  try {
-    names = await readdir(dir)
-  } catch {
-    // 目录缺失/不可读:仅清本目录条目(分隔符锚定,防误清兄弟目录),条目自愈
-    for (const key of globalCachePollState.keys()) {
-      if (key.startsWith(dir + sep)) globalCachePollState.delete(key)
-    }
-    return []
-  }
-  const live = new Set()
-  const caches = await Promise.all(names
-    .filter((name) => name.endsWith('.json') && name !== PROMPTS_FILE)
-    .map(async (name) => {
-      const file = join(dir, name)
-      live.add(file)
-      let fingerprint
-      try {
-        const info = await stat(file)
-        fingerprint = { mtimeMs: info.mtimeMs, size: info.size }
-      } catch {
-        globalCachePollState.delete(file)
-        return null
-      }
-      const hit = globalCachePollState.get(file)
-      if (hit !== undefined && hit.fp.mtimeMs === fingerprint.mtimeMs && hit.fp.size === fingerprint.size) {
-        return hit.parsed
-      }
-      try {
-        const parsed = JSON.parse(await readFile(file, 'utf8'))
-        if (!parsed || typeof parsed.cwd !== 'string' || !Array.isArray(parsed.entries)) {
-          globalCachePollState.delete(file)
-          return null
-        }
-        globalCachePollState.set(file, { fp: fingerprint, parsed })
-        return parsed
-      } catch {
-        globalCachePollState.delete(file)
-        return null
-      }
-    }))
-  for (const key of globalCachePollState.keys()) {
-    if (!live.has(key)) globalCachePollState.delete(key)
-  }
-  return caches.filter((cache) => cache && typeof cache.cwd === 'string' && Array.isArray(cache.entries))
-}
-
-// 常用提示词:全局单文件(不按工作区),记录用户显式收藏的输入文本。
-// 收藏是用户意志,与自动对齐的历史缓存互不覆写
-const PROMPTS_FILE = 'prompts.json'
-
-function normalizePrompts(parsed) {
-  if (!parsed || !Array.isArray(parsed.items)) return []
-  return parsed.items
-    .filter((item) => item && typeof item.text === 'string' && item.text.length > 0)
-    .map((item) => ({ text: item.text, at: typeof item.at === 'number' ? item.at : 0 }))
-}
-
-export async function readPrompts(dir) {
-  try {
-    return normalizePrompts(JSON.parse(await readFile(join(dir, PROMPTS_FILE), 'utf8')))
-  } catch {
-    return []
-  }
-}
-
-export async function writePrompts(dir, items) {
-  await ensureCacheDir(dir)
-  const target = join(dir, PROMPTS_FILE)
-  const tmp = target + '.tmp'
-  await writeFile(tmp, JSON.stringify({ items }, null, 0), 'utf8')
-  await rename(tmp, target)
-}

package/test/client-steer.test.mjs

@@ -1,266 +0,0 @@
-// 插话撤回(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/history-cache.test.mjs

@@ -1,84 +0,0 @@
-// global 浮层轮询指纹缓存 BDD:stat 指纹命中不重复读盘,产物变更即失效,
-// 删除/损坏文件与目录缺失不残留缓存条目。
-
-import { test } from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtemp, writeFile, utimes, rm, readdir, mkdir } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-const { listWorkspaceCachesCached } = await import('../src/history-cache.mjs')
-
-async function makeDir(t) {
-  const dir = await mkdtemp(join(tmpdir(), 'sm-fp-cache-'))
-  t.after(() => rm(dir, { recursive: true, force: true }))
-  return dir
-}
-
-async function writeCache(dir, name, cwd, entries, mtime) {
-  const file = join(dir, name)
-  await writeFile(file, JSON.stringify({ cwd, entries }), 'utf8')
-  if (mtime !== undefined) await utimes(file, mtime, mtime)
-  return file
-}
-
-test('指纹命中:产物未变时复用解析结果,内容对象同引用', async (t) => {
-  const dir = await makeDir(t)
-  await writeCache(dir, 'a-1.json', 'C:\\a', [{ sid: 's1', text: 'x' }])
-  const first = await listWorkspaceCachesCached(dir)
-  assert.equal(first.length, 1)
-  assert.equal(first[0].cwd, 'C:\\a')
-  // When 再次读取(文件未动)
-  const second = await listWorkspaceCachesCached(dir)
-  // Then 指纹命中,返回缓存中的同一解析对象
-  assert.equal(second[0], first[0])
-})
-
-test('指纹失效:文件内容变更后重读,新内容可见', async (t) => {
-  const dir = await makeDir(t)
-  const stamp = new Date()
-  const file = await writeCache(dir, 'b-1.json', 'C:\\b', [{ sid: 's1', text: 'old' }], stamp)
-  const first = await listWorkspaceCachesCached(dir)
-  assert.equal(first[0].entries[0].text, 'old')
-  // When 追加条目并推进 mtime(写入侧经临时文件改名,mtime 必变)
-  await writeFile(file, JSON.stringify({ cwd: 'C:\\b', entries: [{ sid: 's1', text: 'old' }, { sid: 's2', text: 'new' }] }), 'utf8')
-  const later = new Date(stamp.getTime() + 2000)
-  await utimes(file, later, later)
-  const second = await listWorkspaceCachesCached(dir)
-  // Then 新内容可见
-  assert.equal(second[0].entries.length, 2)
-  assert.equal(second[0].entries[1].text, 'new')
-})
-
-test('卫生:文件删除与目录缺失清空对应缓存', async (t) => {
-  const dir = await makeDir(t)
-  const file = await writeCache(dir, 'c-1.json', 'C:\\c', [])
-  await listWorkspaceCachesCached(dir)
-  // When 删除文件后再读
-  await rm(file)
-  const afterRemove = await listWorkspaceCachesCached(dir)
-  // Then 结果为空(目录仍在,缓存条目清除)
-  assert.deepEqual(afterRemove, [])
-  // When 目录整个消失(缓存目录被手工清理)
-  await rm(dir, { recursive: true, force: true })
-  const afterDirGone = await listWorkspaceCachesCached(dir)
-  // Then 返回空数组不抛
-  assert.deepEqual(afterDirGone, [])
-  // 目录恢复后缓存可重建
-  await mkdir(dir, { recursive: true })
-  assert.deepEqual(await readdir(dir), [])
-  await writeCache(dir, 'd-1.json', 'C:\\d', [{ sid: 's9', text: 'fresh' }])
-  const rebuilt = await listWorkspaceCachesCached(dir)
-  assert.equal(rebuilt.length, 1)
-  assert.equal(rebuilt[0].entries[0].text, 'fresh')
-})
-
-test('过滤:损坏文件与 prompts.json 不进结果', async (t) => {
-  const dir = await makeDir(t)
-  await writeFile(join(dir, 'broken.json'), '{not json', 'utf8')
-  await writeFile(join(dir, 'prompts.json'), JSON.stringify({ items: [] }), 'utf8')
-  await writeCache(dir, 'ok-1.json', 'C:\\ok', [])
-  const caches = await listWorkspaceCachesCached(dir)
-  assert.equal(caches.length, 1)
-  assert.equal(caches[0].cwd, 'C:\\ok')
-})