dsh-retrace 0.4.18 → 0.4.20

package/lib/adapter/dsh.js

@@ -12,6 +12,10 @@
 import { readdirSync, accessSync } from 'node:fs'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
+// 官方 foldSurface:重放得与写入端完全一致的 surface nodes(replace 插 marker、
+// 遮蔽移除节点 → nodes 非 seq 单调;span 计算必须用它,否则 start/end indexOf
+// 会 not found/倒置 → S4/S8 拒 → 撤回死锁,ISSUE-20260907113201)。peerDep 提供。
+import { foldSurface } from '@deepseek-ai/dsh-session'
 
 /** 找 DSH 会话文件路径(遍历 ~/.dsh/sessions 各工作区)。 */
 export function sessionFilePath(sessionId) {
@@ -49,12 +53,22 @@ async function readEventsFromFile(filePath) {
 
 /**
  * 从全量事件计算遮蔽范围(业务逻辑,基于通用事件,与 DSH 无关)。
+ *
+ * 2026-09-07 修复(ISSUE-20260907113201-3f9e4f12):nodes 不再从 events 顺序收集
+ * (seq 递增的虚拟 nodes),改为**官方 foldSurface 重放得真实 surface nodes**——
+ * 官方 replace 会把 marker(新 seq)插入遮蔽范围开头、移除被遮蔽节点 → nodes 非
+ * seq 单调。旧算法按 seq 递增假设算 span,写入时官方 nodes 里 indexOf(start/end)
+ * 可能 not found(目标已被遮蔽)或倒置(startIdx>endIdx,marker 插入) → S4/S8 拒 →
+ * 撤回死锁(evidence 快照实测:target 710693 span[710693..711448] → index 442>441)。
+ * 新算法 nodes = 官方 foldSurface 结果 → span 的 start/end 与写入端完全一致,
+ * not found/倒置不可能;target 已被遮蔽(不在 nodes)= 返回 null(target-shadowed)。
+ *
  * @param {Array} events - 全量事件(通用格式)。
  * @param {number|string} target - seq 或 messageId。
- * @param {'round'|'tail'} [mode] - round=遮蔽目标轮;tail=遮蔽目标之后(编辑 fromScratch)。
+ * @param {'round'|'tail'} [mode] - round=遮蔽目标轮;tail=遮蔽目标位置之后全部(recall/fromScratch)。
  */
 export function computeSpan(events, target, mode = 'round') {
-  if (!Array.isArray(events)) return null
+  if (!Array.isArray(events) || events.length === 0) return null
   let seq = typeof target === 'number' ? target : -1
   if (seq === -1) {
     for (let i = events.length - 1; i >= 0; i--) {
@@ -64,18 +78,27 @@ export function computeSpan(events, target, mode = 'round') {
     }
   }
   if (seq === -1 || !events[seq]) return null
-  // surface 节点 = user/assistant/tool 消息(近似 surface 节点,与官方 foldSurface 一致)
-  const nodes = []
-  for (const ev of events) {
-    if (ev && (ev.type === 'user/message' || ev.type === 'assistant/message' || ev.type === 'tool/result')) nodes.push(ev.seq)
+  // 官方 foldSurface 重放 = 与写入端一致的当前 surface(含 marker 插入效应、排除被遮蔽节点)
+  let nodes
+  try {
+    const folded = foldSurface(events)
+    nodes = folded?.nodes
+  } catch {
+    return null
   }
+  if (!Array.isArray(nodes) || nodes.length === 0) return null
+  const index = nodes.indexOf(seq)
+  if (index === -1) return null // 目标已被遮蔽/不在 surface → 调用方报 target-shadowed
   if (mode === 'tail') {
-    const shadowedSeqs = nodes.filter((s) => s >= seq)
+    // tail:从目标所在轮首遮蔽到 surface 尾(撤回 = 移除整轮 input+output + 其后全部,
+    // R2 语义;目标若是轮内 assistant/tool 则回退到轮首 user,防孤立输入)。
+    let startPos = index
+    for (let i = index; i >= 0; i--) { if (isRoundBoundary(events[nodes[i]])) { startPos = i; break } }
+    const shadowedSeqs = nodes.slice(startPos)
     if (shadowedSeqs.length === 0) return null
     return { start: shadowedSeqs[0], end: shadowedSeqs[shadowedSeqs.length - 1], shadowedSeqs }
   }
-  const index = nodes.indexOf(seq)
-  if (index === -1) return null
+  // round:目标轮(在官方 nodes 位置序上找轮边界;marker 是 assistant/message 非轮边界)
   let startIdx = index
   for (let i = index; i >= 0; i--) { if (isRoundBoundary(events[nodes[i]])) { startIdx = i; break } }
   let endIdx = nodes.length - 1
@@ -116,3 +139,86 @@ export const dshAdapter = {
     return max
   },
 }
+
+// ─────────────────────────────────────────────────────────────────────────────
+// 语义短码推导(2026-09-02)——工作区 createdAt 序号 + 父链,与修复线
+// gen-session-codes.mjs 同规则(表的新鲜版,不冲突)。
+// 短码 = 工作区2 + 序号3 + 父工作区2 + 父序号3;根父 = FF000。
+// 只读会话文件帧1(header),全量 ~110 会话 ≈ 30ms,懒加载缓存。
+// ─────────────────────────────────────────────────────────────────────────────
+
+/** 工作区目录名 → 2 位缩写(与 gen-session-codes.mjs 同逻辑: --Users-maxwell-opena-- → op)。 */
+function workspaceAbbr(workspace) {
+  const name = String(workspace).replace('--Users-maxwell-', '').replace(/--$/, '')
+  const parts = name.split('-').filter(Boolean)
+  if (parts.length >= 2) return (parts[0][0] + parts[1][0]).toLowerCase()
+  return name.slice(0, 2).toLowerCase()
+}
+
+/** 派生短码表:扫全部工作区会话 header,按 createdAt 排序编号,含父链。 */
+export async function deriveBadgeTable() {
+  const { readSessionHeader } = await import('dsh-log-contract')
+  const root = join(homedir(), '.dsh', 'sessions')
+  const rows = [] // { id, ws, createdAt, parent }
+  for (const workspace of readdirSync(root)) {
+    const wsDir = join(root, workspace)
+    let sids
+    try { sids = readdirSync(wsDir) } catch { continue }
+    for (const sid of sids) {
+      const header = readSessionHeader(join(wsDir, sid, 'session.jsonl.zstd'))
+      if (!header || typeof header.id !== 'string') continue
+      rows.push({
+        id: header.id,
+        ws: workspaceAbbr(workspace),
+        createdAt: header.createdAt ?? 0,
+        parent: typeof header.parentSession === 'string' ? header.parentSession : null,
+      })
+    }
+  }
+  // 工作区内按 createdAt 排序 → 序号(与 gen-session-codes 一致)
+  const byWs = {}
+  for (const r of rows) (byWs[r.ws] ??= []).push(r)
+  const seqOf = new Map() // sessionId → { ws, seq }
+  for (const ws of Object.keys(byWs)) {
+    byWs[ws].sort((a, b) => a.createdAt - b.createdAt)
+    byWs[ws].forEach((r, i) => seqOf.set(r.id, { ws, seq: i + 1 }))
+  }
+  const WS = 2
+  const SEQ = 3
+  const pad = (n) => String(n).padStart(SEQ, '0')
+  const codes = {}
+  for (const r of rows) {
+    const self = seqOf.get(r.id)
+    if (!self) continue
+    const selfCode = `${self.ws}${pad(self.seq)}`
+    const parentInfo = r.parent ? seqOf.get(r.parent) : null
+    codes[r.id] = parentInfo
+      ? `${selfCode}${parentInfo.ws}${pad(parentInfo.seq)}`
+      : `${selfCode}FF${'0'.repeat(SEQ)}`
+  }
+  return codes
+}
+
+let deriveCache = null
+let derivePromise = null
+
+/** 语义短码(推导):懒加载缓存;会话不在表(如已删/新加入但未扫)返回 null。 */
+export async function semanticBadgeOf(sessionId) {
+  const id = String(sessionId ?? '')
+  if (deriveCache !== null) return deriveCache[id] ?? null
+  derivePromise ??= deriveBadgeTable().then((codes) => {
+    deriveCache = codes
+    return codes
+  }).catch(() => {
+    deriveCache = {}
+    return deriveCache
+  })
+  const codes = await derivePromise
+  return codes[id] ?? null
+}
+
+/** 刷新推导缓存(新会话创建/删除后调用,后台)。 */
+export function invalidateBadgeDerive() {
+  deriveCache = null
+  derivePromise = null
+}

package/lib/dynamic-host.js

@@ -206,8 +206,17 @@ return {
           if (span.length === 0) return null
           return { start: span[0], end: span[span.length - 1], shadowedSeqs: span }
         }
-        // tail 模式:遮蔽 startSeq 之后所有 surface 节点(不依赖稀疏 events)
-        const shadowedSeqs = nodes.filter((s) => s >= startSeq)
+        // tail 模式:从目标所在轮首遮蔽到 surface 尾(撤回 = 移除整轮 input+output + 其后
+        // 全部;目标若是轮内 assistant/tool 则回退到轮首 user,防孤立输入)。位置连续段——
+        // marker 插入使 nodes 非 seq 单调,filter(s>=startSeq) 会漏/错;host 视图尽力,
+        // 主路径 = index.js 注入 spanFromFile 官方 foldSurface nodes,ISSUE-20260907113201。
+        const index = nodes.indexOf(startSeq)
+        if (index === -1) return null // 已被遮蔽/不在 surface → target-shadowed
+        let startPos = index
+        for (let i = index; i >= 0; i--) {
+          if (isRoundBoundary(events[nodes[i]])) { startPos = i; break }
+        }
+        const shadowedSeqs = nodes.slice(startPos)
         if (shadowedSeqs.length === 0) return null
         return {
           start: shadowedSeqs[0],
@@ -321,7 +330,10 @@ return {
         await ensureIdle(agents.get(sessionId))
         const seq = findMessageSeq(session, messageId)
         if (seq === -1) throw editorError('message-not-found', 'Message not found in this session.')
-        const span = args?.span ?? roundSpanFrom(session, seq)
+        // 2026-09-07:撤回语义 = 遮蔽目标轮及之后全部(编辑=从此处分叉,bfb965e4/3f9e4f12
+        // issue)——fallback 用 tail;主路径由 index.js 注入 spanFromFile(官方 foldSurface nodes)。
+        // 大范围遮蔽由快照点守卫引导分支(太旧消息的正确出口)。
+        const span = args?.span ?? shadowSpanFrom(session, seq, { mode: 'tail' })
         if (!span) throw editorError('target-shadowed', 'This message is no longer part of the active conversation.')
         const markerEvent = await writeMarker(session, span, 'recall', seq, messageTextOf(session, seq))
         await flushSafely(session)

package/lib/host-core.js

@@ -196,8 +196,17 @@ export function createEditorApi(ctx, sessions, agents, log = () => {}, hooks = {
       if (span.length === 0) return null
       return { start: span[0], end: span[span.length - 1], shadowedSeqs: span }
     }
-    // tail 模式:遮蔽 startSeq 之后所有 surface 节点(不依赖稀疏 events)
-    const shadowedSeqs = nodes.filter((s) => s >= startSeq)
+    // tail 模式:从目标所在轮首遮蔽到 surface 尾(撤回 = 移除整轮 input+output + 其后
+    // 全部;目标若是轮内 assistant/tool 则回退到轮首 user,防孤立输入)。位置连续段——
+    // marker 插入使 nodes 非 seq 单调,filter(s>=startSeq) 会漏/错;host 视图尽力,
+    // 主路径 = index.js 注入 spanFromFile 官方 foldSurface nodes,ISSUE-20260907113201。
+    const index = nodes.indexOf(startSeq)
+    if (index === -1) return null // 已被遮蔽/不在 surface → target-shadowed
+    let startPos = index
+    for (let i = index; i >= 0; i--) {
+      if (isRoundBoundary(events[nodes[i]])) { startPos = i; break }
+    }
+    const shadowedSeqs = nodes.slice(startPos)
     if (shadowedSeqs.length === 0) return null
     return {
       start: shadowedSeqs[0],
@@ -311,7 +320,10 @@ export function createEditorApi(ctx, sessions, agents, log = () => {}, hooks = {
     await ensureIdle(agents.get(sessionId))
     const seq = findMessageSeq(session, messageId)
     if (seq === -1) throw editorError('message-not-found', 'Message not found in this session.')
-    const span = args?.span ?? roundSpanFrom(session, seq)
+    // 2026-09-07:撤回语义 = 遮蔽目标轮及之后全部(编辑=从此处分叉,bfb965e4/3f9e4f12
+    // issue)——fallback 用 tail;主路径由 index.js 注入 spanFromFile(官方 foldSurface nodes)。
+    // 大范围遮蔽由快照点守卫引导分支(太旧消息的正确出口)。
+    const span = args?.span ?? shadowSpanFrom(session, seq, { mode: 'tail' })
     if (!span) throw editorError('target-shadowed', 'This message is no longer part of the active conversation.')
     const markerEvent = await writeMarker(session, span, 'recall', seq, messageTextOf(session, seq))
     await flushSafely(session)

package/lib/http.js

@@ -254,11 +254,13 @@ export function createRetraceHttpHandler(ctx, { sessions, agents, seam, rollback
       }
       // 情形② step 号:writer 的 readMaxStep 已在 index.js 装配时注入(文件全量算)。
       // 2026-09-01:编辑操作前从文件算遮蔽(绕开 host 稀疏 session.events,用户方案)
+      // 2026-09-09:recall mode 改 tail(遮蔽目标轮及之后全部)——与 index.js harness 入口
+      // 同语义(独立审查 ❌-1:HTTP 入口此前漏改仍 round,两入口分叉违反"编辑走哪个入口都生效")
       if ((op === 'recall' || op === 'editAndResend' || op === 'regenerate') && !args?.span) {
         try {
           const target = typeof args?.seq === 'number' ? args.seq : args?.messageId
           if (target !== undefined && target !== null) {
-            const mode = op === 'editAndResend' && args?.fromScratch ? 'tail' : 'round'
+            const mode = op === 'recall' || (op === 'editAndResend' && args?.fromScratch) ? 'tail' : 'round'
             const span = await dshAdapter.spanFromFile(sessionId, target, mode)
             if (span) args = { ...args, span }
           }

package/lib/index.js

@@ -27,7 +27,7 @@ import { createMarkerGuard } from './prewrite-guard.js'
 import { createWatchdog } from './watchdog.js'
 import { attachExitWarning } from './interrupt-guard.js'
 import { sessionBadge as fnvBadge } from './badge.js'
-import { dshAdapter } from './adapter/dsh.js'
+import { dshAdapter, semanticBadgeOf } from './adapter/dsh.js'
 import { createDshMarkerWriter } from './adapter/dsh-writer.js'
 import { readFileSync, readdirSync, accessSync } from 'node:fs'
 import { join } from 'node:path'
@@ -43,7 +43,31 @@ let badgeTable = null
 try {
   badgeTable = JSON.parse(readFileSync(BADGE_TABLE_PATH, 'utf8')).codes ?? null
 } catch { /* 表缺失时 FNV 兜底 */ }
-function sessionBadge(sessionId) {
+/**
+ * 会话短码(2026-09-02 v2,三级)——解决"新 fork 会话不在短码表只有 FNV 兜底"：
+ * ① archive 短码表(修复线维护,固定);
+ * ② 实时推导(工作区 createdAt 序号+父链,与 gen-session-codes.mjs 同规则,
+ *    表的新鲜超集——1f4d986e 这类新会话也能得 op071op065);
+ * ③ FNV-1a 确定性兜底(任何环境可复现,人机交互最低保障)。
+ * ②③ 是 async(推导需扫 header);同步调用点(forkmap 等)用 syncBadge。
+ */
+let deriveBooted = false
+async function sessionBadge(sessionId) {
+  const semantic = badgeTable?.[sessionId]
+  if (typeof semantic === 'string' && semantic.length > 0) return semantic
+  if (!deriveBooted) {
+    deriveBooted = true
+    const derived = await semanticBadgeOf(sessionId)
+    if (derived) return derived
+  } else {
+    const derived = await semanticBadgeOf(sessionId)
+    if (derived) return derived
+  }
+  return fnvBadge(sessionId)
+}
+
+/** 同步短码(表 + FNV;推导留给异步调用点)。 */
+function syncBadge(sessionId) {
   const semantic = badgeTable?.[sessionId]
   if (typeof semantic === 'string' && semantic.length > 0) return semantic
   return fnvBadge(sessionId)
@@ -114,27 +138,46 @@ export function apply(ctx) {
      * mode='round' 遮蔽目标轮;mode='tail' 遮蔽目标之后(编辑 fromScratch)。
      */
     // spanFromFile 从 lib/file-span.js 引入(读文件全量算遮蔽)
-    // 自动固定标题(2026-09-01):任何 retrace 操作发生 = 会话活跃,
-    // 确保 title 带短码(用户体感:标题固定,不依赖打开 ForkView/RetraceView)。
-    function ensureBadgeTitle(sessionId) {
+    // 标题固定 + 短码(2026-09-02 v2):任何 retrace 操作发生 = 会话活跃,
+    // 用**官方 sessionTitle.rename** 写 `[短码] 原标题`(user source title)→
+    // 官方自动改名被永久关闭(onUserMessage 见 user source 不再生成)+ 侧边栏/
+    // 标题栏投影立即刷新。不再用 session.append(append 不更新 title 投影,
+    // 且 0.4.17 前从未让用户看到短码——只依赖 ForkView 打开的旧路已弃)。
+    async function ensureBadgeTitle(sessionId) {
       try {
-        const session = ctx.sessions?.get?.(String(sessionId ?? ''))
+        const sid = String(sessionId ?? '')
+        const session = ctx.sessions?.get?.(sid)
         if (!session) return
-        const badge = sessionBadge(String(sessionId))
+        const badge = await sessionBadge(sid)
         if (!badge) return
         let currentTitle = ''
         for (let i = session.events.length - 1; i >= 0; i--) {
           if (session.events[i]?.type === 'session/title') { currentTitle = session.events[i].data?.title ?? ''; break }
         }
-        if (!currentTitle) currentTitle = String(sessionId).slice(0, 16)
-        const tagged = `[${badge}] `
-        if (currentTitle.startsWith(tagged)) return
-        session.append('session/title', { title: tagged + currentTitle, source: { kind: 'user' } })
+        // 无标题时用 cwd 基名(比 sessionId 前 16 位可读)
+        if (!currentTitle) {
+          const cwd = session.header?.cwd ?? ''
+          currentTitle = cwd.split('/').filter(Boolean).pop() || String(sid).slice(0, 16)
+        }
+        // 去掉旧版可能已拼的任意 [xxx] 前缀(只去 badge 本身避免误删内容)
+        const clean = currentTitle.replace(/^\[[a-z0-9]{6,}\]\s*/, '')
+        const tagged = `[${badge}] ${clean}`
+        if (currentTitle === tagged || currentTitle.startsWith(`[${badge}] `)) return
+        pinTitle(session, tagged)
       } catch { /* 标题写入失败不影响操作 */ }
     }
+    /** 官方 rename pin:user source title → 关闭自动改名 + 投影刷新。 */
+    function pinTitle(session, title) {
+      const titles = ctx.get?.('sessionTitle')
+      if (session && titles && typeof titles.rename === 'function') {
+        try { titles.rename(session, title); return true } catch { /* fallback append */ }
+      }
+      session?.append?.('session/title', { title, source: { kind: 'user' } })
+      return true
+    }
     // 2026-09-01:操作前从文件算遮蔽(绕开 host 稀疏 session.events,用户方案)
     const withFileSpan = (op, modeOf) => async (args) => {
-      ensureBadgeTitle(args?.sessionId)
+      await ensureBadgeTitle(args?.sessionId)
       // 情形② step 号:writer 的 readMaxStep 已在装配时注入(index.js createDshMarkerWriter
       // 闭包,从文件全量算)——不再经 args 传递(3e2262a 下沉后 writer 是唯一消费方)。
       try {
@@ -149,24 +192,106 @@ export function apply(ctx) {
       } catch (error) { log(`retrace: spanFromFile wrapper error: ${String(error).slice(0, 120)}`) }
       return api[op](args)
     }
+    /**
+     * 批量 pin 全部已驻留会话(2026-09-02 v2):用官方 rename 写 `[短码] 原标题`。
+     * 启动时/新会话驻留时调用——用户打开 DSH 侧边栏即可看到短码,不依赖
+     * 打开 ForkView 或先编辑。返回结果数组。
+     */
+    async function pinAllResident() {
+      const results = []
+      const sessionStore = ctx.sessions
+      if (!sessionStore || (typeof sessionStore.list !== 'function' && typeof sessionStore.values !== 'function')) {
+        return { ok: false, error: { code: 'unavailable', message: 'session store not enumerable' } }
+      }
+      try {
+        const sessions = typeof sessionStore.list === 'function' ? sessionStore.list() : [...sessionStore.values()]
+        for (const session of sessions) {
+          const sessionId = session?.id ?? session?.sessionId
+          if (!sessionId) continue
+          try {
+            const badge = await sessionBadge(sessionId)
+            if (!badge) continue
+            let currentTitle = ''
+            for (let i = session.events.length - 1; i >= 0; i--) {
+              if (session.events[i]?.type === 'session/title') {
+                currentTitle = session.events[i].data?.title ?? ''
+                break
+              }
+            }
+            if (!currentTitle) {
+              const cwd = session.header?.cwd ?? ''
+              currentTitle = cwd.split('/').filter(Boolean).pop() || sessionId.slice(0, 16)
+            }
+            const clean = currentTitle.replace(/^\[[a-z0-9]{6,}\]\s*/, '')
+            const tagged = `[${badge}] ${clean}`
+            if (currentTitle === tagged || currentTitle.startsWith(`[${badge}] `)) {
+              results.push({ sessionId, badge, alreadyTagged: true })
+              continue
+            }
+            pinTitle(session, tagged)
+            results.push({ sessionId, badge, alreadyTagged: false })
+          } catch (error) {
+            results.push({ sessionId, badge: null, error: String(error) })
+          }
+        }
+        return { ok: true, value: { total: results.length, results } }
+      } catch (error) {
+        return { ok: false, error: { code: 'internal', message: String(error) } }
+      }
+    }
+    /**
+     * 启动批量 pin:DSH 会话渐进驻留,定期重试直到覆盖(幂等可重复,alreadyTagged 跳过)。
+     * 0.4.19 缺陷(用户实测前发现):`bootPin(99)` 被 `retries>=8` 挡住 → 30s 重跑永不执行;
+     * 启动 24s 窗口内会话未驻留 → 永久放弃 → 短码永不显示(全天 0 条 bootPin 日志)。
+     * 修法:每次(成功或失败)都安排下一次,共 MAX_ATTEMPTS 次(30s×20 ≈ 启动后 10 分钟
+     * 窗口,覆盖渐进驻留);错误打日志不静默。
+     */
+    function bootPin(attempts = 0) {
+      const MAX_ATTEMPTS = 20
+      const schedule = () => {
+        if (attempts < MAX_ATTEMPTS) setTimeout(() => bootPin(attempts + 1), 30000)
+      }
+      const sessionStore = ctx.sessions
+      const hasSessions = sessionStore && (
+        (typeof sessionStore.list === 'function' && sessionStore.list().length > 0) ||
+        (typeof sessionStore.values === 'function' && sessionStore.values().length > 0)
+      )
+      if (!hasSessions) {
+        schedule()
+        return
+      }
+      pinAllResident()
+        .then((result) => {
+          log(`retrace: bootPin(${attempts}) → ${result?.value?.total ?? 0} 个驻留会话标题已处理`)
+          schedule()
+        })
+        .catch((error) => {
+          log(`retrace: bootPin error: ${String(error).slice(0, 160)}`)
+          schedule()
+        })
+    }
+    bootPin(0)
     const disposers = [
-      harness.handle('retrace.recall', withFileSpan('recall', () => 'round')),
+      // 2026-09-07:recall 语义 = 遮蔽目标轮及之后全部(编辑=从此处分叉,bfb965e4/
+      // 3f9e4f12 issue 要求)——不再只遮蔽目标轮(缺陷①断层);tail 在官方 foldSurface
+      // nodes 上按位置切(ISSUE-20260907113201 修复),大范围遮蔽由快照点守卫引导分支。
+      harness.handle('retrace.recall', withFileSpan('recall', () => 'tail')),
       harness.handle('retrace.editAndResend', withFileSpan('editAndResend', (a) => (a?.fromScratch ? 'tail' : 'round'))),
       harness.handle('retrace.regenerate', withFileSpan('regenerate', () => 'round')),
       // 会话短码（2026-08-31）：session id → 确定性 10 位短码，人机交互识别用。
-      harness.handle('retrace.sessionBadge', (args) => {
+      harness.handle('retrace.sessionBadge', async (args) => {
         const sessionId = String(args?.sessionId ?? '')
-        return { ok: true, value: { sessionId, badge: sessionBadge(sessionId) } }
+        return { ok: true, value: { sessionId, badge: await sessionBadge(sessionId) } }
       }),
       // 会话短码写入标题（2026-09-01）：给会话 title 组装「[短码]原标题」，
       // 不改标题内容本身，只在标题前加短码标识。
-      harness.handle('retrace.setBadgeTitle', (args) => {
+      harness.handle('retrace.setBadgeTitle', async (args) => {
         const sessionId = String(args?.sessionId ?? '')
         if (!sessionId) return { ok: false, error: { code: 'bad-request', message: 'sessionId required' } }
         const session = ctx.sessions?.get?.(sessionId)
         if (!session) return { ok: false, error: { code: 'not-found', message: 'session not found' } }
         try {
-          const badge = sessionBadge(sessionId)
+          const badge = await sessionBadge(sessionId)
           // 读当前 title（最后一个 session/title 事件或 header.title）
           let currentTitle = ''
           for (let i = session.events.length - 1; i >= 0; i--) {
@@ -179,8 +304,9 @@ export function apply(ctx) {
           // 检查是否已含短码（避免重复写入）
           const tagged = `[${badge}] `
           if (currentTitle.startsWith(tagged)) return { ok: true, value: { title: currentTitle, badge, alreadyTagged: true } }
-          const newTitle = tagged + currentTitle
-          session.append('session/title', { title: newTitle, source: { kind: 'user' } })
+          const clean = currentTitle.replace(/^\[[a-z0-9]{6,}\]\s*/, '')
+          const newTitle = tagged + clean
+          pinTitle(session, newTitle)
           return { ok: true, value: { title: newTitle, badge, alreadyTagged: false } }
         } catch (error) {
           return { ok: false, error: { code: 'internal', message: String(error) } }
@@ -188,7 +314,7 @@ export function apply(ctx) {
       }),
       // 用户自定义会话名称（2026-09-01）：`[短码] 用户输入` 写入 user source title。
       // 官方语义：user source title 固定会话名，后续自动生成（title-llm）被禁用。
-      harness.handle('retrace.setUserTitle', (args) => {
+      harness.handle('retrace.setUserTitle', async (args) => {
         const sessionId = String(args?.sessionId ?? '')
         const title = String(args?.title ?? '').trim()
         if (!sessionId) return { ok: false, error: { code: 'bad-request', message: 'sessionId required' } }
@@ -196,52 +322,16 @@ export function apply(ctx) {
         const session = ctx.sessions?.get?.(sessionId)
         if (!session) return { ok: false, error: { code: 'not-found', message: 'session not found' } }
         try {
-          const badge = sessionBadge(sessionId)
+          const badge = await sessionBadge(sessionId)
           // 用户输入已含短码则直接用，否则拼接
           const tagged = title.startsWith(`[${badge}]`) ? title : `[${badge}] ${title}`
-          session.append('session/title', { title: tagged, source: { kind: 'user' } })
+          pinTitle(session, tagged)
           return { ok: true, value: { title: tagged, badge } }
         } catch (error) {
           return { ok: false, error: { code: 'internal', message: String(error) } }
         }
       }),
-      // 批量初始化会话名称（2026-09-01）：所有已驻留会话的 title 拼上短码。
-      // 用户体感：侧边栏/对话标题直接显示 `[短码] 名称`，不用进分叉图才看到。
-      harness.handle('retrace.initBadgeTitles', () => {
-        const results = []
-        const sessionStore = ctx.sessions
-        if (!sessionStore || typeof sessionStore.list !== 'function' && typeof sessionStore.values !== 'function') {
-          return { ok: false, error: { code: 'unavailable', message: 'session store not enumerable' } }
-        }
-        try {
-          const sessions = typeof sessionStore.list === 'function' ? sessionStore.list() : [...sessionStore.values()]
-          for (const session of sessions) {
-            const sessionId = session?.id ?? session?.sessionId
-            if (!sessionId) continue
-            try {
-              const badge = sessionBadge(sessionId)
-              if (!badge) continue
-              let currentTitle = ''
-              for (let i = session.events.length - 1; i >= 0; i--) {
-                if (session.events[i]?.type === 'session/title') {
-                  currentTitle = session.events[i].data?.title ?? ''
-                  break
-                }
-              }
-              if (!currentTitle) currentTitle = sessionId.slice(0, 16)
-              const tagged = `[${badge}] `
-              if (currentTitle.startsWith(tagged)) { results.push({ sessionId, badge, alreadyTagged: true }); continue }
-              session.append('session/title', { title: tagged + currentTitle, source: { kind: 'user' } })
-              results.push({ sessionId, badge, alreadyTagged: false })
-            } catch (error) {
-              results.push({ sessionId, badge: null, error: String(error) })
-            }
-          }
-          return { ok: true, value: { total: results.length, results } }
-        } catch (error) {
-          return { ok: false, error: { code: 'internal', message: String(error) } }
-        }
-      }),
+      harness.handle('retrace.initBadgeTitles', () => pinAllResident()),
     ]
     return () => disposers.forEach((dispose) => dispose())
   })()

package/package.json

@@ -1,17 +1,10 @@
 {
   "name": "dsh-retrace",
   "description": "Retrace · 回溯 — Recall, edit-and-resend, regenerate, and conversation/artifact versioning (timeline, rollback, fork map) for DeepSeek Harness — Web and Desktop",
-  "version": "0.4.18",
-  "packageManager": "pnpm@11.7.0",
+  "version": "0.4.20",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
-  "scripts": {
-    "build": "node scripts/generate-dynamic.mjs && node scripts/build-client.mjs",
-    "check": "node scripts/check-syntax.mjs && node scripts/check-dynamic.mjs",
-    "test": "vitest run",
-    "prepublishOnly": "pnpm check && pnpm build && pnpm test"
-  },
   "exports": {
     ".": {
       "default": "./lib/index.js"
@@ -85,7 +78,7 @@
     "react": "^18.2.0"
   },
   "dependencies": {
-    "dsh-log-contract": "^0.3.7",
+    "dsh-log-contract": "^0.3.10",
     "zod": "^4.4.3"
   },
   "repository": {
@@ -102,5 +95,10 @@
   },
   "bin": {
     "retrace": "bin/retrace.mjs"
+  },
+  "scripts": {
+    "build": "node scripts/generate-dynamic.mjs && node scripts/build-client.mjs",
+    "check": "node scripts/check-syntax.mjs && node scripts/check-dynamic.mjs",
+    "test": "vitest run"
   }
-}
+}