@a9i5k4/dsh-auto-memory 2.2.3 → 2.2.5

package/lib/index.js

@@ -17,7 +17,7 @@
  *   - 路由:/api/dsh-auto-memory/{state,list,file,recall,config,reflect}(loopback-only)
  */
 
-import { readFile, writeFile, mkdir, readdir, stat, rm, copyFile, appendFile } from 'node:fs/promises'
+import { readFile, writeFile, mkdir, readdir, stat, rm, copyFile, appendFile, rename } from 'node:fs/promises'
 import { createReadStream, existsSync, readFileSync, writeFileSync, mkdirSync, renameSync, rmSync, statSync } from 'node:fs'
 import { exec as cpExec } from 'node:child_process'
 import { promisify } from 'node:util'
@@ -43,6 +43,8 @@ import { createMemoryHubPre } from './memory-hub.js'
 import { pickConsolidationTextPre } from './intent-clean.js'
 import { createStorageManagerPre } from './storage-manage.js'
 import { rankWorkspacesByMemoryRecencyPre } from './ws-overview-rank.js'
+import { scanPluginSubagentSessions, recycleSessions, PLUGIN_LABEL_PREFIX, decodeZstdFrames } from './subagent-gc.js'
+import { parseModelWindowsPre, pickWindowPre, findOfficialContextWindowPre, findSessionModelPre } from './water-window.js'
 import { buildSourceCatalog, CorpusRegistry, canonicalize } from './m4-corpus.js'
 import * as nodeZlib from 'node:zlib'
 import { AsyncLocalStorage } from 'node:async_hooks'
@@ -159,6 +161,7 @@ export const API = {
   'semantic-deep-detect': '/api/dsh-auto-memory/semantic-deep-detect',
   'handoff-state': '/api/dsh-auto-memory/handoff-state',
   'handoff-continue': '/api/dsh-auto-memory/handoff-continue',
+  'subagent-gc': '/api/dsh-auto-memory/subagent-gc',
   'semantic-download': '/api/dsh-auto-memory/semantic-download',
   'semantic-emit': '/api/dsh-auto-memory/semantic-emit',
   'shadow-recent': '/api/dsh-auto-memory/shadow-recent',
@@ -218,12 +221,31 @@ const DEFAULT_CONFIG = {
   handoffLedgerChars: 800,
   /** M-CM4 水位感知:窗口 token 数。0=自动——从 settings.yaml 的 agent-default-model 解析对应模型的 contextWindow(失败回退 131072);手动设值即覆盖自动检测。 */
   waterLevelWindowTokens: 0,
-  /** 水位建议阈值(0.1-1.5):ratio 越阈值时注入交接建议。 */
-  waterLevelThreshold: 0.8,
+  /** 水位建议阈值(0.1-1.5):ratio 越阈值时注入交接建议。
+   *  2026-09-08 由 0.8 下调到 0.75:harness 官方自动压缩阈值是 80%,阈值贴着 80% 会在交接动作完成前先被官方压缩掉,
+   *  留 5% 余量(约 1M 窗口的 50K token)才来得及走完「写账本 → 建新会话 → 注入材料」。 */
+  waterLevelThreshold: 0.75,
   /** 水位建议注入(无人值守时始终静默)。 */
   waterLevelAdvisory: true,
   /** 水位越阈时自动写一篇系统骨架账本(每会话一次;模型仍应自己写正式交接)。 */
   waterLevelAutoHandoff: true,
+  /** 自动接续(默认开):水位≥阈值 且 harness 权威 running==false(轮次边界,取代旧"两轮水位持平")时弹确认卡。 */
+  autoContinueEnabled: true,
+  /** 自动接续水位阈值(0.5-0.95);2026-09-08 与 waterLevelThreshold 同步下调到 0.75(官方自动压缩阈值 80%,必须留余量)。 */
+  autoContinueThreshold: 0.75,
+  /** 确认卡倒计时秒数(30-40s 无操作 = 挂机 → 自动接续兜底)。 */
+  autoContinueConfirmSeconds: 35,
+  /** 接续前刷新仪式(默认开):先让旧 Agent 刷新 PLAN.md + 交接账本,host 再用最新材料组装交接。 */
+  autoContinueRefreshRitual: true,
+  /** 刷新仪式等待上限(秒);超时用现有材料 fail-soft 继续接续。 */
+  autoContinueRefreshTimeoutSeconds: 90,
+  /** 自动接续冷却(分钟):一次接续后多久内不再触发。 */
+  autoContinueCooldownMinutes: 30,
+  /** 子代理痕迹回收(2026-09-08,默认开):本插件 spawn 的一次性子代理(auto-memory-*)在任务结束后立即把其会话目录与投影缓存移入备份目录。
+   *  背景:实测全机 686 个子代理会话中 638 个来自本插件,数量上千后拖慢会话列表加载。 */
+  subagentGcEnabled: true,
+  /** 子代理痕迹兜底 GC 保留天数:超过该天数仍残留的本插件一次性痕迹会在每日巡检时回收(0=不按时间、只靠任务结束即删)。 */
+  subagentGcKeepDays: 3,
   /** 暂离阈值(分钟):距上次活动超过该值视为暂离,回归时自动弹出记忆窗口并欢迎。默认 60。 */
   awayMinutes: 60,
   /** 无人值守/托管模式(默认关):面向无人值守批量任务。开启后剥离所有"会话性/行为性"注入——
@@ -1623,14 +1645,20 @@ class MemoryEngine {
   }
 
   /** M-CM4·自动窗口:agent-default-model(provider+model)→ settings.yaml 对应模型的 contextWindow;失败回退保守值。60s 缓存。 */
-  async resolveWaterWindow() {
+  /** M-CM4·自动窗口:会话真实模型(request/header 的 provider/model,优先)→ agent-default-model(兜底)→ settings.yaml 对应模型的 contextWindow;失败回退保守值。60s 缓存。 */
+  async resolveWaterWindow(providerOverride = '', modelOverride = '') {
     try {
       const override = Number(this.config.waterLevelWindowTokens) || 0
       if (override > 0) return { window: override, source: 'manual' }
       const now = Date.now()
-      if (this._waterWindowCache && now - this._waterWindowCache.at < 60000) return this._waterWindowCache.value
+      const cacheKey = String(providerOverride || '') + '/' + String(modelOverride || '')
+      if (this._waterWindowCache && now - this._waterWindowCache.at < 60000 && this._waterWindowCache.key === cacheKey) return this._waterWindowCache.value
       const text = await this.readTextSafe(path.join(dshHome(), 'settings.yaml'))
-      let value = null, model = null, provider = null
+      let value = 0
+      let model = String(modelOverride || '')
+      let provider = String(providerOverride || '')
+      let defModel = ''
+      let defProvider = ''
       if (text) {
         const lines = text.split(/\r?\n/)
         const ai = lines.findIndex((l) => /^agent-default-model:/.test(l))
@@ -1638,55 +1666,118 @@ class MemoryEngine {
           for (let i = ai + 1; i < Math.min(lines.length, ai + 6); i++) {
             const m = lines[i].match(/^ {2}(provider|model): *(.+?) *$/)
             if (!m) break
-            if (m[1] === 'provider') provider = m[2].trim()
-            if (m[1] === 'model') { model = m[2].trim(); break }
+            if (m[1] === 'provider') defProvider = m[2].trim()
+            if (m[1] === 'model') { defModel = m[2].trim(); break }
           }
         }
-        if (model) {
-          const windowsByRoute = {}
-          let currentProvider = ''
-          let currentId = null
-          for (let i = 0; i < lines.length; i++) {
-            const pm = lines[i].match(/^ {4}([^ #][^:]*): *$/)
-            if (pm) { currentProvider = pm[1]; currentId = null; continue }
-            const im = lines[i].match(/^ *- id: *(.+?) *$/)
-            if (im) { currentId = im[1]; continue }
-            const cm = lines[i].match(/^ +contextWindow: *([0-9]+) *$/)
-            if (cm && currentId) { const route = currentProvider + '/' + currentId; if (windowsByRoute[route] === undefined) windowsByRoute[route] = Number(cm[1]) }
-          }
-          if (windowsByRoute[(provider || '') + '/' + model] !== undefined) value = windowsByRoute[provider + '/' + model]
-          else { for (const route of Object.keys(windowsByRoute)) if (route.endsWith('/' + model)) { value = windowsByRoute[route]; break } }
+        // 2.2.4 修复:settings.yaml 的 llm-deepseek 段是 flow 风格 YAML(`{ models: [ { id: x, contextWindow: 1000000, … } ] }`),
+        // 旧解析器只认 block 风格 → 整段解析失败、窗口退化为 fallback。改为纯函数解析(block + flow 双支持)。
+        const windows = parseModelWindowsPre(text)
+        // 2026-09-08:优先按「会话自己的模型」查窗口——用户在 GUI 切过模型后,agent-default-model 与新会话默认值
+        // 并不等于当前会话实际模型(实测会话跑 deepseek-official/deepseek-v4.1-flash,默认模型却是 opencode-go/deepseek-v4-flash)。
+        const lookupProvider = provider || defProvider
+        const lookupModel = model || defModel
+        if (lookupModel) value = pickWindowPre(windows, lookupProvider, lookupModel)
+        if (value > 0) { provider = lookupProvider; model = lookupModel }
+        else if (defModel && defModel !== lookupModel) {
+          const alt = pickWindowPre(windows, defProvider, defModel)
+          if (alt > 0) { value = alt; provider = defProvider; model = defModel }
         }
       }
-      const result = value !== null
+      const result = value > 0
         ? { window: value, source: 'auto' + (provider ? ':' + provider : '') + (model ? '/' + model : ''), model: model || '' }
-        : { window: 131072, source: 'fallback', model: model || '' }
-      this._waterWindowCache = { at: now, value: result }
+        : { window: 131072, source: 'fallback', model: model || defModel || '' }
+      this._waterWindowCache = { at: now, key: cacheKey, value: result }
       return result
     } catch (e) { return { window: 131072, source: 'fallback', error: String(e && e.message) } }
   }
 
+  /** 会话级水位记录(2026-09-08):水位此前是**全局单值**,只在有 agent 轮次时更新;
+   *  于是切到别的会话时,卡片显示的是「上一个会话的数」或重启后的 0,且模型名只能拿默认模型凑。
+   *  现在:①checkWaterLevel 每次测量写入 per-session 表;②查询时按 sessionId 取;
+   *  ③没有记录就从该会话日志(磁盘)推导窗口与模型——切会话即可刷新,不需要先发消息。 */
+  rememberWaterRecord(sid, rec) {
+    if (!sid || !rec) return
+    if (!this._waterBySession) this._waterBySession = new Map()
+    this._waterBySession.set(this.waterKey(sid), rec)
+    if (this._waterBySession.size > 40) {
+      const first = this._waterBySession.keys().next()
+      if (!first.done) this._waterBySession.delete(first.value)
+    }
+  }
+
+  /** 会话 id 归一化:agent.session.id 与 GUI 快照 current 可能带/不带 `session-` 前缀,统一去掉后作键。 */
+  waterKey(sid) {
+    return String(sid || '').replace(/^session-/, '')
+  }
+
+  /** 取该会话最近 10 分钟内的实测记录(无则 null)。 */
+  waterRecordFor(sid) {
+    if (!sid) return null
+    const m = this._waterBySession
+    const rec = m && typeof m.get === 'function' ? m.get(this.waterKey(sid)) : null
+    return rec && Date.now() - (Number(rec.at) || 0) < 600000 ? rec : null
+  }
+
+  /** 从会话日志(磁盘)推导窗口与模型:不需要 agent,切换会话即可得到正确的模型名与窗口。 */
+  async waterWindowForSession(sid) {
+    const empty = { window: 0, source: '', model: '', provider: '', contextWindow: 0 }
+    if (!sid) return empty
+    if (!this._waterDeriveCache) this._waterDeriveCache = new Map()
+    const cached = this._waterDeriveCache.get(String(sid))
+    if (cached && Date.now() - cached.at < 300000) return cached.value
+    let value = empty
+    try {
+      const dir = await this.locateSessionDir(String(sid))
+      if (dir) {
+        const raw = await readFile(path.join(dir, 'session.jsonl.zstd')).catch(() => null)
+        const events = raw ? decodeZstdFrames(raw).split('\n').map((l) => { try { return JSON.parse(l) } catch (e) { return null } }).filter(Boolean) : []
+        const info = findSessionModelPre(events)
+        const wi = await this.resolveWaterWindow(info.provider, info.model)
+        value = {
+          window: info.contextWindow > 0 ? info.contextWindow : (Number(wi.window) || 0),
+          source: info.contextWindow > 0 ? 'official-context' : (wi.source || ''),
+          model: info.model || wi.model || '',
+          provider: info.provider,
+          contextWindow: info.contextWindow,
+        }
+      }
+    } catch (e) {}
+    this._waterDeriveCache.set(String(sid), { at: Date.now(), value })
+    if (this._waterDeriveCache.size > 40) {
+      const first = this._waterDeriveCache.keys().next()
+      if (!first.done) this._waterDeriveCache.delete(first.value)
+    }
+    return value
+  }
+
   /** M-CM6-A·水位 v2:计量优先级=ctx.tokenMeter.measure(官方计量,与聊天框 context ring 同源,免疫重启/压缩/chunk 洪流)→ 启发式估算(降级);
    *  窗口优先级=waterLevelWindowTokens 手动覆盖 > 官方 request/context 容量 > settings.yaml auto/fallback。越阈值或检测到 compaction 事件→advisory+自动写抽取性骨架账本。 */
   async checkWaterLevel(agent) {
     try {
       if (this.config.handoffEnabled === false) return
-      const winInfo = await this.resolveWaterWindow()
+      // 会话真实模型 + 官方容量:同一份事件扫描结果按会话缓存 5 分钟
+      // (该事件只在请求头变化时追加,实测 2999 条事件里仅 2 条且位于会话开头,旧实现只扫最近 256 条 → 长会话永远扫不到)。
+      let sessModel = { provider: '', model: '', contextWindow: 0 }
+      try {
+        const sid = agent && agent.session && agent.session.id ? String(agent.session.id) : ''
+        const cached = this._officialWindowCache
+        if (cached && sid && cached.sid === sid && Date.now() - cached.at < 300000 && cached.info) {
+          sessModel = cached.info
+        } else {
+          sessModel = findSessionModelPre(sessionEventsOf(agent && agent.session))
+          this._officialWindowCache = { sid, at: Date.now(), info: sessModel }
+        }
+      } catch (eWin) {}
+      // 窗口解析按「会话真实模型」查表(2026-09-08):此前恒用 settings.yaml 的 agent-default-model,
+      // 用户切过模型后卡片会标出另一个模型的名字(实测会话跑 deepseek-official/deepseek-v4.1-flash,却标 opencode-go/deepseek-v4-flash)。
+      const winInfo = await this.resolveWaterWindow(sessModel.provider, sessModel.model)
       let win = Number(winInfo && winInfo.window) || 0
       let winSource = (winInfo && winInfo.source) || ''
-      if (win > 0 && !/^manual/.test(winSource)) {
-        // 官方容量:最新一条 request/context 事件的 contextWindow(路由容量,last-wins)
-        try {
-          const evts = sessionEventsOf(agent && agent.session)
-          for (let i = evts.length - 1; i >= Math.max(0, evts.length - 256); i--) {
-            const ev = evts[i]
-            if (ev && ev.type === 'request/context') {
-              const cw = Number(ev && ev.data && ev.data.contextWindow)
-              if (Number.isFinite(cw) && cw > 0) { win = cw; winSource = 'official-context' }
-              break
-            }
-          }
-        } catch (eWin) {}
+      if (win > 0 && !/^manual/.test(winSource) && sessModel.contextWindow > 0) {
+        // 官方容量:request/context 的 contextWindow(路由权威值,last-wins)
+        win = sessModel.contextWindow
+        winSource = 'official-context'
       }
       if (win <= 0) return
       const rt = this.runtimeFor(agent)
@@ -1719,7 +1810,9 @@ class MemoryEngine {
           }
         }
       } catch (e) {}
-      const ratio = Math.min(estTokens / win, 1.5)
+      // 旧实现硬截断到 1.5 → 任何超额水位都显示成 150%,掩盖真实占用(用户实测 761692/131072 被显示为 150%)。
+      // 现在如实上报,仅做防溢出的 99 倍上限。
+      const ratio = win > 0 && Number.isFinite(estTokens) ? Math.min(estTokens / win, 99) : 0
       rt.waterLevel = ratio
       rt.waterLevelTokens = estTokens
       this.state.waterLevelRatio = ratio
@@ -1727,9 +1820,14 @@ class MemoryEngine {
       this.state.waterLevelWindow = win
       this.state.waterLevelSource = winSource
       this.state.waterLevelMeter = meterLayer
-      this.state.waterLevelModel = winInfo.model || ''
+      this.state.waterLevelModel = sessModel.model || winInfo.model || ''
       this.state.waterLevelAt = Date.now()
-      const threshold = Math.max(Number(this.config.waterLevelThreshold) || 0.8, 0.1)
+      const threshold = Math.max(Number(this.config.waterLevelThreshold) || 0.75, 0.1)
+      // 会话级记录:切会话时 /handoff-state?sessionId= 直接取这份,不再显示别的会话的数
+      this.rememberWaterRecord(agent && agent.session && agent.session.id ? String(agent.session.id) : '', {
+        ratio, tokens: estTokens, window: win, source: winSource, meter: meterLayer,
+        model: this.state.waterLevelModel || '', threshold, at: Date.now(), live: true,
+      })
       const over = ratio >= threshold || (ratio >= 0.5 && compacted)
       if (!over) return
       if (!rt.waterLevelAdvised || compacted) {
@@ -1774,10 +1872,44 @@ class MemoryEngine {
     return tokens
   }
 
+  /** 当前(最近活跃)会话 id;无 agent 时返回 ''。 */
+  currentSessionId() {
+    try {
+      const agent = this._lastAgent
+      return agent && agent.session && agent.session.id ? String(agent.session.id) : ''
+    } catch (e) { return '' }
+  }
+
+  /** 修A(2026-09-08):解析会话所属 workspaceId。官方 api-session-controller create() 只在传 workspaceId 时
+   *  调 workspace.attachSession()(index.js:566-588),只传 cwd 仅设工作目录 → 新会话永远落「未分组工作区」。
+   *  归属判定走 workspaceRegistry(与官方 forkWorkspace index.js:874 同款),服务缺失/无归属返回 ''(client 回退 cwd)。 */
+  resolveWorkspaceIdForSession(sessionId, cwd) {
+    try {
+      // 惰性解析:apply 时服务可能尚未就绪(strict get 会返回 undefined),每次调用再取一次兜底
+      let reg = this._workspaceRegistry
+      if (!reg && this._ctxRef && typeof this._ctxRef.get === 'function') {
+        try { reg = this._ctxRef.get('workspaceRegistry') } catch (e) {}
+      }
+      if (!reg || typeof reg.list !== 'function') return ''
+      return workspaceIdForSession(reg.list(), sessionId, cwd)
+    } catch (e) { return '' }
+  }
+
+  /** 接续前刷新仪式指令(③,2026-09-08):交给 client 用 remote.session.prompt 发回旧会话,
+   *  让旧 Agent 在材料组装前把 PLAN.md 与交接账本刷到最新。 */
+  refreshRitualPrompt() {
+    return [
+      '[接续前刷新仪式] 即将把本会话交接给新会话。请在本轮内只做下面两件事,不要执行其他操作、不要推进任务:',
+      '1. 调用 memory_note(kind=plan, content=<项目白板的最新完整全貌:项目全貌/当前目标/下一步,旧版会自动归档>) 重写 PLAN.md;',
+      '2. 调用 memory_note(kind=handoff, content=<四段式交接账本:## 任务状态 / ## 目标 / ## 已试方案与失败原因 / ## 进度与下一步,每段≤5行,下一步必须是可以直接执行的第一步,带文件路径或命令>) 写一篇新账本。',
+      '完成后只回复一句「已刷新」,不要再调用其他工具。',
+    ].join(String.fromCharCode(10))
+  }
+
   /** M-CM6-B v2·旧会话上下文包(2026-09-08):定位当前(旧)会话持久化文件(~/.dsh/sessions/<ws>/<sid>/session.jsonl[.zstd]),
-   *  zstd 解压抽取 header(cwd/agentPreset)、最新 request/context(provider/model)、user+assistant 消息全量转写;
-   *  转写落盘 handoff/prev-session-*.md → 新会话 AI 用 read 工具即可随时读取旧会话全部内容(原始 .zstd AI 读不了,这是关键桥)。
-   *  返回 {sessionId, transcriptPath, provider, model, agentPreset, cwd, tailText} 或部分为空(任何一步失败都 fail-soft)。 */
+   *  zstd 解压抽取 header(cwd/agentPreset)、最新 request/header 的 data.header.config(provider/model/reasoningEffort)、
+   *  user+assistant+工具 消息全量转写;转写落盘 handoff/prev-session-*.md → 新会话 AI 用 read 工具即可随时读取旧会话全部内容。
+   *  返回 {sessionId, transcriptPath, provider, model, reasoningEffort, agentPreset, cwd, tailText, msgCount} 或部分为空(fail-soft)。 */
   async buildPrevSessionPack() {
     try {
       const agent = this._lastAgent
@@ -1802,25 +1934,14 @@ class MemoryEngine {
         text = buf.toString('utf8')
       }
       const lines = text.split('\n').filter((l) => l.trim())
-      let preset = '', cwd = ''
-      try { const h = JSON.parse(lines[0]); if (h && typeof h === 'object') { preset = String(h.agentPreset || ''); cwd = String(h.cwd || '') } } catch (e) {}
-      let provider = '', model = ''
-      const msgs = []
-      for (const l of lines) {
-        let ev
-        try { ev = JSON.parse(l) } catch (e) { continue }
-        const t = ev && ev.type
-        if (t === 'request/context') {
-          const d = (ev && ev.data) || {}
-          if (d.model) { provider = String(d.provider || provider); model = String(d.model) }
-        } else if (t === 'user/message' || t === 'assistant/message') {
-          const m = messageOfEvent(ev)
-          if (m && m.role && Array.isArray(m.content)) {
-            const txt = textOfContent(m.content)
-            if (txt) msgs.push({ role: m.role, text: txt })
-          }
-        }
-      }
+      // 修B(2026-09-08):模型/思考档位取自 request/header 的 data.header.config(官方投影同源),request/context 仅回退。
+      const folded = foldSessionLogEvents(lines)
+      const preset = folded.preset
+      const cwd = folded.cwd
+      const provider = folded.provider
+      const model = folded.model
+      const reasoningEffort = folded.reasoningEffort
+      const msgs = folded.msgs
       const p = await this.resolvePaths(undefined)
       const NL = String.fromCharCode(10)
       const stamp = new Date().toISOString().slice(11, 19).replace(/:/g, '')
@@ -1843,9 +1964,9 @@ class MemoryEngine {
       }
       await mkdir(p.handoffDir, { recursive: true })
       await writeFile(outPath, body.join(NL), 'utf8')
-      const tail = msgs.slice(-8).map((m) => m.role + ': ' + m.text.slice(0, 300)).join(NL + '---' + NL)
-      diag('prev-session pack built: sid=' + sid + ' msgs=' + msgs.length + ' -> ' + outPath)
-      return { sessionId: sid, transcriptPath: outPath, provider, model, agentPreset: preset, cwd: cwd || p.ws, tailText: tail }
+      const tail = msgs.slice(-20).map((m) => m.role + ': ' + m.text.slice(0, 700)).join(NL + '---' + NL)
+      diag('prev-session pack built: sid=' + sid + ' msgs=' + msgs.length + ' model=' + (model || '-') + '@' + (provider || '-') + ' effort=' + (reasoningEffort || '-') + ' -> ' + outPath)
+      return { sessionId: sid, transcriptPath: outPath, provider, model, reasoningEffort, agentPreset: preset, cwd: cwd || p.ws, tailText: tail, msgCount: msgs.length }
     } catch (e) { diag('buildPrevSessionPack error: ' + (e && e.message)); return null }
   }
 
@@ -1867,13 +1988,32 @@ class MemoryEngine {
       }
       const pack = await this.buildPrevSessionPack()
       if (!plan && !ledger && !pack) return { ok: false, error: 'no handoff material (PLAN/账本/旧会话均为空)' }
+      // 材料时间戳与新鲜度(分层压缩:过期提示)
+      const fmtMt = (ms) => { try { return ms ? new Date(Number(ms)).toISOString().replace('T', ' ').slice(0, 19) + 'Z' : '(未知)' } catch (e) { return '(未知)' } }
+      const planMt = await stat(p.planPath).then((s) => Number(s.mtimeMs)).catch(() => 0)
+      let ledgerName = '', ledgerMt = 0
+      try {
+        const names = (await readdir(p.handoffDir).catch(() => [])).filter((n) => /^handoff-\d{8}-\d{6}(-[a-z])?\.md$/.test(n))
+        for (const n of names) {
+          const st = await stat(path.join(p.handoffDir, n)).catch(() => null)
+          const mt = st ? Number(st.mtimeMs) : 0
+          if (mt >= ledgerMt) { ledgerMt = mt; ledgerName = n }
+        }
+      } catch (eL) {}
+      const staleNote = planMt && ledgerMt && planMt < ledgerMt ? '(白板比账本旧——以账本为准)' : ''
+      // 修A(2026-09-08):解析旧会话所属工作区,交给 client 用 workspaceId 建新会话(官方只有 workspaceId 分支会 attachSession)。
+      const prevSid = (pack && pack.sessionId) || this.currentSessionId()
+      const wsForSession = (pack && pack.cwd) || p.ws
+      const workspaceId = this.resolveWorkspaceIdForSession(prevSid, wsForSession)
       const parts = [
         '接续上一会话的任务。请先读完下面的交接材料恢复上下文,然后直接继续推进未完成事项,不要重新开始。',
+        '材料分层:第0层=指令+白板(全局图景);第1层=交接账本(四段式,最新);第2层=近期线程(最近 20 条,单条上限 700 字,保留角色与工具标记);第3层=完整转写(按需 read)。',
       ]
-      if (plan) parts.push('### 白板 PLAN.md(节选)' + NL + plan.slice(0, 3000))
-      if (ledger) parts.push('### 交接账本(' + ledgerFrom + ')' + NL + ledger.slice(0, 8000))
+      if (plan) parts.push('【第0层 · 白板 PLAN.md(节选)】更新于 ' + fmtMt(planMt) + staleNote + NL + plan.slice(0, 3000))
+      if (ledger) parts.push('【第1层 · 交接账本 ' + (ledgerName || ledgerFrom) + '】写于 ' + fmtMt(ledgerMt) + ' (' + ledgerFrom + ')' + NL + ledger.slice(0, 8000))
       if (pack) {
-        const guide = ['### 旧会话上下文包(主动读取指引)']
+        if (pack.tailText) parts.push('【第2层 · 近期线程(最近 ' + Math.min(20, Number(pack.msgCount) || 20) + ' 条 / 共 ' + (pack.msgCount || 0) + ' 条)】' + NL + pack.tailText)
+        const guide = ['【第3层 · 完整转写与检索(按需)】']
         if (pack.transcriptPath) {
           guide.push('- 旧会话(' + pack.sessionId + ')的完整对话转写已写入: ' + pack.transcriptPath)
           guide.push('- **接续前先用 read 工具读取该转写文件**,以完全理解旧会话的讨论、结论与未竟事项;任务推进中也可随时回读。')
@@ -1881,26 +2021,38 @@ class MemoryEngine {
           guide.push('- 旧会话 ID: ' + pack.sessionId + '(转写文件生成失败,可用 memory_recall 检索)')
         }
         guide.push('- 历史会话全文检索: memory_recall(scope=\'sessions\', query=\'关键词\') 可跨全部历史会话查证细节。')
-        if (pack.tailText) guide.push('#### 最近对话摘录(最后 8 条)' + NL + pack.tailText)
-        if (pack.model) guide.push('- 状态沿用: 模型 ' + pack.model + (pack.provider ? ' @ ' + pack.provider : '') + ' 已在新会话自动选回(失败则回退路由默认);工作区 cwd 与权限绑定沿用 ' + (pack.cwd || p.ws) + ';插件配置(无人值守/水位/交接等)为全局配置,自动继承。')
-        if (pack.agentPreset) guide.push('- 旧会话 agentPreset: ' + pack.agentPreset + '(preset 不随创建传递,如需同款预设请手动选择;注意 code→ptc 改名的历史会话需用户级兼容预设)。')
+        if (pack.model) guide.push('- 状态沿用: 模型 ' + pack.model + (pack.provider ? ' @ ' + pack.provider : '') + (pack.reasoningEffort ? '(思考档位 ' + pack.reasoningEffort + ')' : '') + ' 已在新会话自动选回(失败则回退路由默认);工作区 ' + (workspaceId ? '按 workspaceId 绑定 ' + workspaceId : '按 cwd 绑定 ' + wsForSession) + ';插件配置(无人值守/水位/交接等)为全局配置,自动继承。')
+        if (pack.agentPreset) guide.push('- 旧会话 agentPreset: ' + pack.agentPreset + '(已随创建传递;注意 code→ptc 改名的历史会话需用户级兼容预设)。')
         parts.push(guide.join(NL))
       }
+      // 接续序号:统计 handoff 目录里已有的 prev-session 包数量 +1(每次一键/自动接续产出一个)
+      let contSeq = 1
+      try { const prevs = (await readdir(p.handoffDir).catch(() => [])).filter((f) => /^prev-session-.*\.md$/.test(f)); contSeq = prevs.length + 1 } catch (eS) {}
+      const wsBase = String((pack && pack.cwd) || p.ws || '').split(/[\\/]/).filter(Boolean).pop() || ''
       return {
         ok: true,
         carryText: parts.join(NL + NL).slice(0, 18000),
         planPath: p.planPath,
         ws: (pack && pack.cwd) || p.ws,
+        workspaceId: workspaceId,
         provider: (pack && pack.provider) || '',
         model: (pack && pack.model) || '',
+        reasoningEffort: (pack && pack.reasoningEffort) || '',
+        agentPreset: (pack && pack.agentPreset) || '',
+        wsBase: wsBase,
+        contSeq: contSeq,
         prevSessionId: (pack && pack.sessionId) || '',
         transcriptPath: (pack && pack.transcriptPath) || '',
+        planMtime: planMt,
+        ledgerName: ledgerName,
+        ledgerMtime: ledgerMt,
+        msgCount: (pack && pack.msgCount) || 0,
       }
     } catch (e) { return { ok: false, error: String(e && e.message ? e.message : e) } }
   }
 
   /** M-CM1 白板面板数据:PLAN 当前版+归档版本列表+账本列表;fileQ 非空时返回指定文件文本(严格白名单,限 handoff 目录内)。 */
-  async handoffPanelData(fileQ) {
+  async handoffPanelData(fileQ, sessionId) {
     if (this.config.handoffEnabled === false) return { enabled: false }
     const handoffDir = this.state.handoffDir || (await this.resolvePaths(undefined)).handoffDir
     const planPath = this.state.planPath || path.join(handoffDir, 'PLAN.md')
@@ -1926,29 +2078,57 @@ class MemoryEngine {
       if (st && st.isFile()) ledgers.push({ name: n, mtime: Number(st.mtimeMs) })
     }
     ledgers.sort((a, b) => b.mtime - a.mtime)
-    if (!this.state.waterLevelWindow && this.config.handoffEnabled !== false) {
-      try {
-        const wi = await this.resolveWaterWindow()
-        this.state.waterLevelWindow = Number(wi && wi.window) || 0
-        this.state.waterLevelSource = (wi && wi.source) || ''
-        this.state.waterLevelModel = (wi && wi.model) || ''
-      } catch (e) {}
-    }
-    return {
-      enabled: true, planPath,
-      plan: await this.readTextSafe(planPath),
-      planVersions: versions.slice(0, 30),
-      ledgers: ledgers.slice(0, 60),
-      waterLevel: {
+    // 水位:优先返回「该会话」的记录(实测 → 磁盘推导);未指定 sessionId 时退回全局单值(兼容旧调用方)
+    let water = null
+    if (sessionId) {
+      const rec = this.waterRecordFor(sessionId)
+      if (rec) {
+        water = {
+          ratio: Number(rec.ratio) || 0, tokens: Number(rec.tokens) || 0, window: Number(rec.window) || 0,
+          source: rec.source || '', meter: rec.meter || '', model: rec.model || '',
+          threshold: Number(this.config.waterLevelThreshold) || 0.75, at: Number(rec.at) || 0, live: true,
+        }
+      } else {
+        const wi = await this.waterWindowForSession(sessionId)
+        water = {
+          ratio: 0, tokens: 0, window: Number(wi.window) || 0, source: wi.source || '', meter: '',
+          model: wi.model || '', threshold: Number(this.config.waterLevelThreshold) || 0.75, at: 0, live: false,
+        }
+      }
+    } else {
+      if (!this.state.waterLevelWindow && this.config.handoffEnabled !== false) {
+        try {
+          const wi = await this.resolveWaterWindow()
+          this.state.waterLevelWindow = Number(wi && wi.window) || 0
+          this.state.waterLevelSource = (wi && wi.source) || ''
+          this.state.waterLevelModel = (wi && wi.model) || ''
+        } catch (e) {}
+      }
+      water = {
         ratio: Number(this.state.waterLevelRatio) || 0,
         tokens: Number(this.state.waterLevelTokens) || 0,
         window: Number(this.state.waterLevelWindow) || 0,
         source: this.state.waterLevelSource || '',
         meter: this.state.waterLevelMeter || '',
         model: this.state.waterLevelModel || '',
-        threshold: Number(this.config.waterLevelThreshold) || 0.8,
+        threshold: Number(this.config.waterLevelThreshold) || 0.75,
         at: Number(this.state.waterLevelAt) || 0,
-      },
+        live: Number(this.state.waterLevelAt) > 0,
+      }
+    }
+    const planMt = await stat(planPath).then((s) => Number(s.mtimeMs)).catch(() => 0)
+    const sid = this.currentSessionId()
+    return {
+      enabled: true, planPath,
+      plan: await this.readTextSafe(planPath),
+      planMtime: planMt,
+      planVersions: versions.slice(0, 30),
+      ledgers: ledgers.slice(0, 60),
+      // ③接续前刷新仪式(2026-09-08):client 拿到 sessionId+prompt 后先让旧 Agent 刷新白板/账本,再取接续材料。
+      refresh: this.config.autoContinueRefreshRitual === false || !sid
+        ? { sessionId: '', prompt: '' }
+        : { sessionId: sid, prompt: this.refreshRitualPrompt() },
+      waterLevel: water,
     }
   }
 
@@ -2707,7 +2887,7 @@ class MemoryEngine {
       lines.push('\n[交接续命] 当前会话未绑定工作区(项目记忆不可用)。全局最近交接账本: ' + s.globalLedgerPath + ' —— 需要续接上次任务时,直接读取该文件恢复上下文;工作区绑定后白板/账本即恢复正常注入。')
     }
     // M-CM4/M-CM5 水位建议:越阈注入交接+派子代理建议(advisory;10 分钟新鲜度;无人值守静默)
-    if (cfg.waterLevelAdvisory !== false && !this.isUnattendedNow() && (s.waterLevelRatio || 0) >= (Number(cfg.waterLevelThreshold) || 0.8) && Date.now() - (s.waterLevelAt || 0) < 600000) {
+    if (cfg.waterLevelAdvisory !== false && !this.isUnattendedNow() && (s.waterLevelRatio || 0) >= (Number(cfg.waterLevelThreshold) || 0.75) && Date.now() - (s.waterLevelAt || 0) < 600000) {
       lines.push('\n' + L('snapshotWaterTitle') + '\n' + L('snapshotWaterBody', { pct: Math.round((s.waterLevelRatio || 0) * 100) }))
     }
     let used = 0
@@ -3843,6 +4023,93 @@ class MemoryEngine {
       if (controller.signal.aborted && run && typeof run.dispose === 'function') {
         try { await run.dispose() } catch (e2) {}
       }
+      // 子代理痕迹回收(2026-09-08):本插件的一次性子代理(auto-memory-*)结束即把会话目录移入备份,
+      // 避免 ~/.dsh/sessions 下插件痕迹堆积拖慢宿主会话列表。失败静默,由每日兜底巡检补收。
+      if (run && run.agent) { try { await this.recycleSubagentSession(run.agent) } catch (e3) {} }
+    }
+  }
+
+  /** 子代理痕迹回收(2026-09-08):本插件 spawn 的一次性子代理结束后,把其会话目录与投影缓存移入备份目录。
+   *  只动 origin=subagent 的会话;任何失败静默(留给每日兜底巡检),绝不影响子代理结果返回。 */
+  async recycleSubagentSession(agent) {
+    try {
+      if (this.config.subagentGcEnabled === false) return { ok: false, reason: 'disabled' }
+      const session = agent && agent.session
+      const header = session && session.header
+      const sid = session && (session.id || (header && header.id)) ? String(session.id || header.id) : ''
+      if (!sid) return { ok: false, reason: 'no-id' }
+      if (!header || header.origin !== 'subagent') return { ok: false, reason: 'not-subagent' }
+      const dir = await this.locateSessionDir(sid, header)
+      if (!dir) return { ok: false, reason: 'not-located' }
+      const wsDir = path.basename(path.dirname(dir))
+      const backupRoot = path.join(dshHome(), 'subagent-gc-backup')
+      const dest = path.join(backupRoot, wsDir, sid)
+      await mkdir(path.dirname(dest), { recursive: true })
+      await rename(dir, dest)
+      // 投影缓存同步移走,避免孤儿条目长期占用索引
+      try {
+        const cacheFile = path.join(dshHome(), 'storages', 'session_projcache', 'sessions', sid)
+        if (existsSync(cacheFile)) {
+          const cacheDest = path.join(backupRoot, '_projcache', sid)
+          await mkdir(path.dirname(cacheDest), { recursive: true })
+          await rename(cacheFile, cacheDest)
+        }
+      } catch (e2) {}
+      diag('subagent gc: recycled session ' + sid)
+      return { ok: true, sid }
+    } catch (e) {
+      diag('subagent gc failed: ' + (e && e.message ? e.message : String(e)))
+      return { ok: false, reason: e && e.message ? e.message : String(e) }
+    }
+  }
+
+  /** 定位会话持久化目录:优先官方 sessionPersistence.locate,回退按会话 id 扫描 sessions 根。 */
+  async locateSessionDir(sid, header) {
+    try {
+      const sp = this.ctx && typeof this.ctx.get === 'function' ? this.ctx.get('sessionPersistence') : null
+      const loc = sp && typeof sp.locate === 'function' ? sp.locate(header) : null
+      if (loc && loc.path) {
+        const dir = path.dirname(String(loc.path))
+        if (existsSync(dir)) return dir
+      }
+    } catch (e) {}
+    try {
+      const root = path.join(dshHome(), 'sessions')
+      const wss = await readdir(root).catch(() => [])
+      for (const ws of wss) {
+        const dir = path.join(root, ws, sid)
+        if (existsSync(dir)) return dir
+      }
+    } catch (e) {}
+    return ''
+  }
+
+  /** 子代理痕迹兜底巡检(每日一次):回收超过保留期仍残留的本插件一次性痕迹。 */
+  async subagentGcSweep(force) {
+    try {
+      if (this.config.subagentGcEnabled === false) return { ok: false, reason: 'disabled' }
+      const today = this.memToday()
+      if (!force && this._subagentGcDay === today) return { ok: true, skipped: 'done-today' }
+      this._subagentGcDay = today
+      const sessionsRoot = path.join(dshHome(), 'sessions')
+      const keepDays = Math.max(0, Number(this.config.subagentGcKeepDays) || 0)
+      const scan = await scanPluginSubagentSessions({ sessionsRoot, labelPrefix: PLUGIN_LABEL_PREFIX, keepMs: 0 })
+      const now = Date.now()
+      // 无论保留期多长,最近 10 分钟的一律不动(可能与正在运行的子代理竞争)
+      const floorMs = Math.max(keepDays * 24 * 3600 * 1000, 10 * 60 * 1000)
+      const eligible = scan.candidates.filter((c) => now - c.mtimeMs >= floorMs)
+      if (!eligible.length) return { ok: true, scanned: scan.scanned, recycled: 0 }
+      const res = await recycleSessions({
+        candidates: eligible,
+        backupRoot: path.join(dshHome(), 'subagent-gc-backup'),
+        projcacheRoot: path.join(dshHome(), 'storages', 'session_projcache', 'sessions'),
+        apply: true,
+      })
+      diag('subagent gc sweep: recycled=' + res.moved.length + ' failed=' + res.failed.length + ' bytes=' + res.bytes)
+      return { ok: true, scanned: scan.scanned, recycled: res.moved.length, failed: res.failed.length, bytes: res.bytes }
+    } catch (e) {
+      diag('subagent gc sweep failed: ' + (e && e.message ? e.message : String(e)))
+      return { ok: false, reason: e && e.message ? e.message : String(e) }
     }
   }
 
@@ -4940,6 +5207,76 @@ function hasStutter(text) {
   if (/([\u4e00-\u9fff\u3040-\u30ff])(?:[^\u4e00-\u9fff\u3040-\u30ff]{0,2}\1){4,}/.test(t)) return true
   return false
 }
+/** 折叠会话日志事件流(纯函数,供 buildPrevSessionPack 与 smoke 共用)。
+ *  2026-09-08 修B:模型/思考档位在 request/header 的 data.header.config.{provider,model,reasoningEffort}
+ *  (官方 api-session-controller/lib/index.js:2008-2012 applyModelSelectionProjection 同源),取最后一条;
+ *  request/context 只是旧日志的回退来源,单查它必然取不到(2.2.4 实测:新会话仍用默认模型)。
+ *  消息序列保留角色标记与工具标记(user/assistant/tool_call/tool_result),供第2层近期线程还原结构。 */
+function foldSessionLogEvents(lines) {
+  const out = { preset: '', cwd: '', provider: '', model: '', reasoningEffort: '', msgs: [] }
+  const list = Array.isArray(lines) ? lines : []
+  try {
+    const h = JSON.parse(list[0] || '')
+    if (h && typeof h === 'object') { out.preset = String(h.agentPreset || ''); out.cwd = String(h.cwd || '') }
+  } catch (e) {}
+  let hProvider = '', hModel = '', hEffort = '', cProvider = '', cModel = '', cEffort = ''
+  for (const l of list) {
+    let ev
+    try { ev = JSON.parse(l) } catch (e) { continue }
+    const t = ev && ev.type
+    if (t === 'request/header') {
+      const cfg = (ev.data && ev.data.header && ev.data.header.config) || {}
+      if (cfg.model) {
+        hProvider = String(cfg.provider || '')
+        hModel = String(cfg.model)
+        hEffort = cfg.reasoningEffort === undefined || cfg.reasoningEffort === null ? '' : String(cfg.reasoningEffort)
+      }
+    } else if (t === 'request/context') {
+      const d = (ev && ev.data) || {}
+      if (d.model) {
+        cProvider = String(d.provider || '')
+        cModel = String(d.model)
+        const eff = d.reasoningEffort || d.reasoning || d.reasoningEffortLevel
+        cEffort = eff ? String(eff) : ''
+      }
+    } else if (t === 'user/message' || t === 'assistant/message') {
+      const m = messageOfEvent(ev)
+      if (m && m.role && Array.isArray(m.content)) {
+        const txt = textOfContent(m.content)
+        if (txt) out.msgs.push({ role: m.role, text: txt })
+      }
+    } else if (t === 'tool/call') {
+      const d = (ev && ev.data) || {}
+      const nm = String(d.name || 'tool')
+      const argsRaw = typeof d.arguments === 'string' ? d.arguments : JSON.stringify(d.arguments == null ? null : d.arguments)
+      out.msgs.push({ role: 'tool_call', text: nm + '(' + String(argsRaw || '').slice(0, 400) + ')' })
+    } else if (t === 'tool/result') {
+      const m = messageOfEvent(ev)
+      const txt = m && Array.isArray(m.content) ? textOfContent(m.content) : ''
+      if (txt) out.msgs.push({ role: 'tool_result', text: txt.slice(0, 400) })
+    }
+  }
+  if (hModel) { out.provider = hProvider; out.model = hModel; out.reasoningEffort = hEffort }
+  else { out.provider = cProvider; out.model = cModel; out.reasoningEffort = cEffort }
+  return out
+}
+
+/** 从 workspaceRegistry.list() 的结果解析某会话所属 workspaceId(纯函数,供 smoke 驱动)。
+ *  2026-09-08 修A:官方 create 只在传 workspaceId 时调 workspace.attachSession(),只传 cwd 仅设工作目录
+ *  → 新会话永远落「未分组」。归属判定与官方 forkWorkspace(index.js:874)同款:workspace.sessionIds 含该会话;
+ *  再按目录兜底(该路径已被某工作区认领,官方 indexLiveSessions 也按路径补账)。返回 '' = 解析不到,调用方回退 cwd。 */
+function workspaceIdForSession(workspaces, sessionId, cwd) {
+  if (!Array.isArray(workspaces) || !sessionId) return ''
+  const direct = workspaces.find((w) => w && Array.isArray(w.sessionIds) && w.sessionIds.includes(sessionId))
+  if (direct && direct.id) return String(direct.id)
+  if (cwd) {
+    const norm = (v) => String(v || '').replace(/[\\/]+$/, '').toLowerCase()
+    const byPath = workspaces.find((w) => w && w.path && norm(w.path) === norm(cwd))
+    if (byPath && byPath.id) return String(byPath.id)
+  }
+  return ''
+}
+
 /** 从 session 提取消息。surface 不是完整可靠的 user 来源,因此失败时回退完整事件日志。 */
 function messageOfEvent(ev) {
   if (!ev) return null
@@ -5476,6 +5813,9 @@ export function apply(ctx, config) {
   engine._agentSvc = ctx.get('agent') || undefined
   // 模型目录(设置页「总结/问候默认模型」抽屉数据源);软获取,缺失时抽屉回退手动输入
   engine._llm = ctx.get('llm') || undefined
+  // 工作区注册表(修A,2026-09-08):接续时解析旧会话所属 workspaceId——官方 create 只在传 workspaceId 时绑定工作区
+  engine._workspaceRegistry = ctx.get('workspaceRegistry') || undefined
+  engine._ctxRef = ctx   // 惰性重取服务用(apply 时可能尚未就绪)
 
   // 生命周期刷新
   const refreshAll = (agent) => {
@@ -6008,7 +6348,7 @@ export function apply(ctx, config) {
         if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
         try {
           const url = new URL(req.url, 'http://127.0.0.1')
-          return writeJson(res, 200, await engine.handoffPanelData(url.searchParams.get('file')))
+          return writeJson(res, 200, await engine.handoffPanelData(url.searchParams.get('file'), url.searchParams.get('sessionId')))
         } catch (e) { return writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
       },
     },
@@ -6026,6 +6366,40 @@ export function apply(ctx, config) {
         } catch (e) { return writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
       },
     },
+    {
+      kind: 'exact',
+      path: API['subagent-gc'],
+      handler: async (req, res) => {
+        // 子代理痕迹回收(loopback):GET=预览(只扫描,不移动文件),POST=执行回收(移入备份目录,可回滚)。
+        if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
+        try {
+          const method = req.method || 'GET'
+          if (method === 'GET') {
+            const scan = await scanPluginSubagentSessions({
+              sessionsRoot: path.join(dshHome(), 'sessions'),
+              labelPrefix: PLUGIN_LABEL_PREFIX,
+              keepMs: 0,
+            })
+            const byLabel = {}
+            for (const c of scan.candidates) byLabel[c.label] = (byLabel[c.label] || 0) + 1
+            return writeJson(res, 200, {
+              ok: true,
+              mode: 'preview',
+              enabled: engine.config.subagentGcEnabled !== false,
+              keepDays: Number(engine.config.subagentGcKeepDays) || 0,
+              scanned: scan.scanned,
+              subagentSessions: scan.subagents,
+              candidates: scan.candidates.length,
+              bytes: scan.bytes,
+              byLabel,
+            })
+          }
+          if (method !== 'POST') return writeJson(res, 405, { error: 'method not allowed' })
+          const r = await engine.subagentGcSweep(true)
+          return writeJson(res, r.ok === false ? 400 : 200, r)
+        } catch (e) { return writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
+      },
+    },
     {
       kind: 'exact',
       path: API['semantic-download'],
@@ -6792,7 +7166,7 @@ export function apply(ctx, config) {
     })()
   }, 5 * 60 * 1000)
   // 心跳独立 15 秒一次(对齐 polling-lease 心跳节奏),证明轮询机制活着
-  const heartbeatTimer = setInterval(() => { void writeHeartbeat(); try { engine.tickTime() } catch (e) {} }, 15000)
+  const heartbeatTimer = setInterval(() => { void writeHeartbeat(); try { engine.tickTime() } catch (e) {}; try { void engine.subagentGcSweep() } catch (e) {} }, 15000)
   void writeHeartbeat() // 立即心跳一次:重启后马上可见轮询存活
 
   // ---------- 注册与清理 ----------
@@ -6831,4 +7205,4 @@ export function apply(ctx, config) {
 }
 
 /** 导出卫生守卫与脏 token 检查器(供 smoke-test / 回归测试直接调用)。 */
-export { sanitizeForWrite, dirtyScanForFiles, mojibakeDensity, tailHas, hasStutter, WRITE_GATE_REASON }
+export { sanitizeForWrite, dirtyScanForFiles, mojibakeDensity, tailHas, hasStutter, WRITE_GATE_REASON, foldSessionLogEvents, workspaceIdForSession }