@a9i5k4/dsh-auto-memory 2.3.1 → 2.4.1

package/lib/index.js

@@ -23,6 +23,7 @@ import { exec as cpExec } from 'node:child_process'
 import { promisify } from 'node:util'
 const execP = promisify(cpExec)
 import { homedir } from 'node:os'
+import { randomUUID } from 'node:crypto'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { MemoryDocumentStore } from './memory-writer.js'
@@ -44,7 +45,7 @@ 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 { parseModelWindowsPre, pickWindowPre, findOfficialContextWindowPre, findSessionModelPre, scanPressureSignalsPre } from './water-window.js'
 import { buildSourceCatalog, CorpusRegistry, canonicalize } from './m4-corpus.js'
 import * as nodeZlib from 'node:zlib'
 import { AsyncLocalStorage } from 'node:async_hooks'
@@ -161,6 +162,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',
+  'handoff-permission': '/api/dsh-auto-memory/handoff-permission',
   'auto-continue-state': '/api/dsh-auto-memory/auto-continue-state',
   'auto-continue-decide': '/api/dsh-auto-memory/auto-continue-decide',
   'subagent-gc': '/api/dsh-auto-memory/subagent-gc',
@@ -173,6 +175,25 @@ export const API = {
   models: '/api/dsh-auto-memory/models',
 }
 
+/**
+ * 记忆文件**容量上限**(字符,非字节)。超过即触发一次自动整理(先 AI 折叠、后退整条归档),
+ * 整理后仍超才拒绝写入 —— 正常情况下"新记忆永不堵在外面"。
+ * 只影响"多久整理一次",不直接决定每轮注入体积(那是 injectBudgetChars 的职责,两者互不相干)。
+ */
+const DEFAULT_NOTE_CAPACITY_CHARS = 12000
+const DEFAULT_USER_CAPACITY_CHARS = 12000
+/**
+ * 整理保护窗口:最近写入的这么多字符**不参与回收**(软下限)。
+ * 硬底线是"至少保留最新 1 条记录":若保护窗口自身就超过上限,允许对其折叠成要点(但不整条删除),
+ * 否则会在"最近内容本身就很大"时重新死锁(旧实现正是这么堵死的)。
+ */
+const COMPACT_PROTECT_RECENT_CHARS = 2000
+/** 折叠产物的大小上限(字符),避免"折叠结果 + 保留内容"仍然超容量。 */
+const COMPACT_FOLD_MAX_CHARS = 1500
+/** 同一层两次 **AI 折叠** 之间的最小间隔(ms);**按层独立计时**,互不牵连。
+ *  注意:节流只作用于"折叠"这一步,不阻止"整条归档"——否则短时间内反复超容量时仍会拒绝写入。 */
+const COMPACT_THROTTLE_MS = 10 * 60 * 1000
+
 const DEFAULT_CONFIG = {
   /** 用户级记忆目录(绝对路径或 ~ 开头)。 */
   userMemoryDir: '~/.dsh/memory',
@@ -193,6 +214,20 @@ const DEFAULT_CONFIG = {
   subagentModel: '',
   /** subagent 模型所属 provider(设置页模型抽屉点选时与 subagentModel 成对写入;留空=spawn/首个注册项,兼容旧配置)。 */
   subagentProvider: '',
+  /**
+   * subagent 推理强度(DSH 0.1.5 的 agentOptions.reasoningEffort);留空=跟随模型默认。
+   * 合法值 off|low|high|max(DeepSeek 适配器口径);off 关闭思维链,high 为默认,max 最深。
+   * 非该集合的值会被静默忽略(见 subAgentOptions),避免 UNSUPPORTED_REASONING_EFFORT 触发子代理熔断。
+   */
+  subagentReasoningEffort: '',
+  /**
+   * 项目笔记 / 用户级记忆的**容量上限**(字符)。超过即自动整理(先 AI 折叠成要点,失败退回整条归档),
+   * 整理后仍超才拒绝写入 —— 新记忆不会被堵在外面。默认 12000(实测一个"信息量大"的工作日约写入 8700 字符,
+   * 12k 留出约 1.4 倍余量,避免同一天反复折叠)。与「注入预算」injectBudgetChars 是两回事:
+   * 容量上限管文件本体大小,注入预算管每轮往提示里塞多少摘要。
+   */
+  noteCapacityChars: DEFAULT_NOTE_CAPACITY_CHARS,
+  userCapacityChars: DEFAULT_USER_CAPACITY_CHARS,
   /** M3a 只读记忆索引开关(默认关闭;开启后仅构建只读索引与调试快照,不修改任何 Markdown)。 */
   memoryFileIndexEnabled: false,
   /** M3b 稳定 Anchor 写入开关(默认关闭=全部旧 Markdown 写法逐字节不变;开启后记忆写路径经 anchor-aware 事务,CALENDAR.md 始终除外)。 */
@@ -471,6 +506,27 @@ function diag(msg) {
   } catch (e) {}
 }
 
+/**
+ * 子代理 agentOptions(DSH 0.1.5)。
+ * 官方把「每个 agent 的模型与推理强度」统一收进 AgentOptions{provider?,model?,reasoningEffort?,maxTokens?},
+ * 由 SubagentStartRequest.agentOptions 下发(provider 侧需 capabilities.agentOptions === true,
+ * in-process 的 spawn/fork 支持,ACP/Codex/ClaudeCode 不支持)。属主可选,故空配置返回 null。
+ * reasoningEffort 是 branded string,运行时由适配器校验:DeepSeek 适配器实收 off|low|high|max(默认 high),
+ * 传其它值会在联网前抛 UNSUPPORTED_REASONING_EFFORT —— 因此这里做白名单过滤,非法值直接不下发。
+ * @param {object} config 插件配置(subagentModel / subagentReasoningEffort)
+ * @returns {{model?: string, reasoningEffort?: string}|null}
+ */
+function subAgentOptions(config) {
+  try {
+    const out = {}
+    const model = String((config && config.subagentModel) || '').trim()
+    const effort = String((config && config.subagentReasoningEffort) || '').trim().toLowerCase()
+    if (model) out.model = model
+    if (effort && /^(off|low|high|max)$/.test(effort)) out.reasoningEffort = effort
+    return Object.keys(out).length ? out : null
+  } catch (e) { return null }
+}
+
 // ---------- 会话隔离层(M0/M1: SessionRuntimeStore,消灭进程级全局状态) ----------
 // ---------- M2 ContextObserver 常量与有界结构(只观察,不检索,不注入) ----------
 /** EventEnvelope 结构版本(系统地图 N-01/C-01 契约)。 */
@@ -811,7 +867,7 @@ class MemoryEngine {
     this._subagentInflight = 0 // 子代理并发闸门(启动瞬间多路 spawn 叠加是卡顿根因之一)
     this._subagentCircuit = null // 配置性错误熔断 { until, reason }(UNKNOWN_MODEL 等,重试无意义)
     this._smartRecallFlight = undefined
-    this._budgets = undefined // 每日写入预算:用户级4000/项目级3000字/天(所有会话共享,跨天重置)
+    this._lastCompactAt = { user: 0, note: 0 } // 每层独立的整理节流时间戳(旧实现是单变量,压过用户级会连带节流项目级)
     // M2: 进程级观察统计(无 owner 而无法归属 runtime 的事件只在这里留痕,绝不落入 default runtime)
     this._observerStats = { ingestedEnvelopes: 0, segmentsCreated: 0, droppedNoOwner: 0, disabledObservations: 0, seedTruncatedEvents: 0 }
     this.external = new ExternalMemory(this)
@@ -1830,6 +1886,18 @@ class MemoryEngine {
       }
       if (win <= 0) return
       const rt = this.runtimeFor(agent)
+      // ① 压力硬信号(2026-09-10 实机取证)
+      // provider 的 "requested tokens" **含路由预留的输出预算**,消息实际额度 = window − maxTokens
+      // (实测:消息 666,044 + 预留 384,000 = 1,050,044 > 上限 1,048,576 → 400 CONTEXT_WINDOW_EXCEEDED)。
+      // 同时那条 400 的错误文本是**唯一权威口径**(真实窗口 / 消息实占 / 预留),拿它自我校准。
+      let events = []
+      let sig = { reservedTokens: 0, overflow: null, compactionSeq: 0 }
+      try {
+        events = sessionEventsOf(agent && agent.session) || []
+        sig = scanPressureSignalsPre(events)
+      } catch (eSig) {}
+      const reserve = Number(sessModel.maxTokens) || Number(sig.reservedTokens) || 0
+      const effectiveWin = (reserve > 0 && reserve < win * 0.9) ? (win - reserve) : win
       let estTokens = 0
       let meterLayer = 'heuristic'
       try {
@@ -1847,43 +1915,76 @@ class MemoryEngine {
         const messages = extractSessionMessages(agent) || []
         estTokens = this.estimateSessionTokens(messages)
       }
-      // compaction 事件感知:harness 刚发生 compaction/summary|prune → 无论水位,立即补写交接材料
+      // ⚠️ 2026-09-10 更正:先前这里加过「本地计量偏乐观 2×」的校准系数 —— **判错了,已撤除**。
+      // 证据:压缩前最后一条 usage 的 totalTokens=660,728,而 provider 8 秒后报 "666044 in the messages",
+      // 两者差 0.8% —— 本地取数(usage / tokenMeter)本来就是准的。先前看到的 316,610 是**压缩之后**的值。
+      // 真正不可达的只有阈值:0.75 × 1,000,000 = 750,000 > 消息实上限 664,576(= 1,048,576 − 预留 384,000)。
+      // compaction / 溢出事件感知:harness 刚压缩过、或 provider 刚报窗口超限 → 无论比例多少,立即补写材料并接续
       let compacted = false
+      let overflowed = false
       try {
-        const events = sessionEventsOf(agent && agent.session)
-        for (let i = Math.max(0, events.length - 64); i < events.length; i++) {
-          const t = events[i] && events[i].type
-          if (t === 'compaction/summary' || t === 'compaction/prune') {
-            const seq = Number(events[i].seq) || i + 1
-            if (seq > (Number(rt.lastCompactionSeen) || 0)) { compacted = true; rt.lastCompactionSeen = seq }
-          }
+        const sid0 = agent && agent.session && agent.session.id ? String(agent.session.id) : ''
+        const cseq = Number(sig.compactionSeq) || 0
+        const oseq = sig.overflow ? Number(sig.overflow.seq) || 0 : 0
+        // 首次观测该会话(含宿主刚重启、或插件刚挂到既有会话)只**建立基线**:把启动前就已经存在的
+        // compaction/溢出记为「已见」。否则每次 dsh web 重启都会把历史压缩当成刚发生 →
+        // 硬触发立刻 armed 并接续(2026-09-10 实机踩到:17:50 重启后 0.7 分钟即 armed,而水位只有 48%)。
+        if (rt.waterCompactBaselineSid !== sid0) {
+          rt.waterCompactBaselineSid = sid0
+          rt.lastCompactionSeen = cseq
+          rt.lastOverflowSeen = oseq
+        } else {
+          if (cseq > (Number(rt.lastCompactionSeen) || 0)) { compacted = true; rt.lastCompactionSeen = cseq }
+          if (oseq > (Number(rt.lastOverflowSeen) || 0)) { overflowed = true; rt.lastOverflowSeen = oseq }
         }
       } catch (e) {}
       // 旧实现硬截断到 1.5 → 任何超额水位都显示成 150%,掩盖真实占用(用户实测 761692/131072 被显示为 150%)。
       // 现在如实上报,仅做防溢出的 99 倍上限。
-      const ratio = win > 0 && Number.isFinite(estTokens) ? Math.min(estTokens / win, 99) : 0
-      rt.waterLevel = ratio
+      const ratio = effectiveWin > 0 && Number.isFinite(estTokens) ? Math.min(estTokens / effectiveWin, 99) : 0
+      const threshold = Math.max(Number(this.config.waterLevelThreshold) || 0.75, 0.1)
+      // 硬触发:官方已经压缩过/已撞过窗口墙 —— 这一刻必须接续,不依赖比例是否算得准。
+      const hard = compacted || overflowed
+      const armRatio = hard ? Math.max(ratio, threshold) : ratio
+      rt.waterLevel = armRatio
       rt.waterLevelTokens = estTokens
-      this.state.waterLevelRatio = ratio
+      // 2026-09-10:pre-step 的 arm 走的是 runtime 字段(见 checkWaterLevelAtStep → armAutoContinue),
+      // 这里只写了 ratio/tokens、漏写 window/source,于是确认卡显示「512,311 / 0 token」(实测)。
+      // 与 state 同源同值,一处漏写两处都缺 —— 必须成对维护。
+      rt.waterLevelWindow = effectiveWin
+      rt.waterLevelSource = winSource
+      this.state.waterLevelRatio = armRatio
       this.state.waterLevelTokens = estTokens
-      this.state.waterLevelWindow = win
+      this.state.waterLevelWindow = effectiveWin
       this.state.waterLevelSource = winSource
       this.state.waterLevelMeter = meterLayer
       this.state.waterLevelModel = sessModel.model || winInfo.model || ''
       this.state.waterLevelAt = Date.now()
-      const threshold = Math.max(Number(this.config.waterLevelThreshold) || 0.75, 0.1)
+      this.state.waterLevelMeasuredTokens = estTokens
+      this.state.waterLevelReserve = reserve
+      // 双口径(2026-09-10):官方小圈的分母是**声明窗口**(win),我们的分母是**可用额度**(effectiveWin),
+      // 两者在本机差 384,000(预留输出)。用户看到「才 50% 就接续」正是因为只看到小圈那个数 ——
+      // 把 ring 一并上报,界面就能同时显示「占可用额度 x% · 官方小圈 y%」,不再各说各话。
+      this.state.waterLevelRing = (win > 0 && Number.isFinite(estTokens)) ? (estTokens / win) : 0
+      // provider 自报的硬上限只有撞过墙(400 文本)才拿得到;拿得到就把「真实可写上限」也算出来,
+      // 让界面能显示「距硬墙还剩多少 token」(本机 = 1,048,576 − 384,000 = 664,576)。
+      const hardWin = Number(sig.overflow && sig.overflow.windowTokens) || 0
+      this.state.waterLevelWall = hardWin > 0 ? Math.max(0, hardWin - reserve) : 0
+      this.state.waterLevelHardTrigger = hard ? (compacted ? 'compaction' : 'overflow') : ''
       // 会话级记录:切会话时 /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,
+        ratio: armRatio, measuredRatio: ratio, tokens: estTokens, measuredTokens: estTokens, window: effectiveWin,
+        windowRaw: win, reserve, source: winSource, meter: meterLayer, model: this.state.waterLevelModel || '',
+        threshold, hardTrigger: this.state.waterLevelHardTrigger, at: Date.now(), live: true,
       })
-      const over = ratio >= threshold || (ratio >= 0.5 && compacted)
+      const over = armRatio >= threshold
       if (!over) return
-      if (!rt.waterLevelAdvised || compacted) {
+      if (!rt.waterLevelAdvised || compacted || overflowed) {
         rt.waterLevelAdvised = true
-        diag('water level advisory: ratio=' + ratio.toFixed(2) + ' tokens=' + estTokens + '/' + win + ' src=' + (winSource || '?') + ' meter=' + meterLayer + (compacted ? ' compaction-detected' : ''))
+        diag('water level advisory: ratio=' + ratio.toFixed(2) + (hard ? '→' + armRatio.toFixed(2) + '(hard:' + this.state.waterLevelHardTrigger + ')' : '') +
+          ' tokens=' + estTokens + '/' + effectiveWin + '(win=' + win + ' reserve=' + reserve + ')' +
+          ' src=' + (winSource || '?') + ' meter=' + meterLayer + (compacted ? ' compaction-detected' : ''))
       }
-      if (this.config.waterLevelAutoHandoff !== false && (!rt.waterLevelAutoHandoffDone || compacted)) {
+      if (this.config.waterLevelAutoHandoff !== false && (!rt.waterLevelAutoHandoffDone || compacted || overflowed)) {
         rt.waterLevelAutoHandoffDone = true
         const p = await this.resolvePaths(agent)
         // 骨架 v2:抽取性压缩——只从「已策展源」取材(沉淀子代理提炼过的今日日志尾部+反思摘要+项目笔记头部),去重限行,不做原始转储
@@ -1914,8 +2015,12 @@ class MemoryEngine {
    *  阈值 thresholdRatio=0.8 对「路由请求 token」;插件此前只在 turn-stopping 测量,一旦某一轮把水位从阈值下推到 0.8 以上,
    *  官方会在该轮的 pre-step 就压缩完,交接白板/账本根本来不及写(实测:20:11 轮末测得 768158/1000000=0.77 时,会话日志里
    *  已有 2 次 compaction/start+summary)。这里在 pre-step 也做同一测量,让交接与官方压缩站在同一条边界上。
-   *  节流:同一 agent 至少间隔 minGapMs(默认 5s),避免每个 step 都扫会话事件/读 tokenMeter。 */
-  checkWaterLevelAtStep(agent, minGapMs = 5000) {
+   *  2026-09-10 修正:**取消 5 秒节流(默认 minGapMs 改为 0)**。旧默认 5000 使"两次 pre-step 间隔 <5 秒即整段跳过"
+   *  (不测量、不 arm),而官方压缩挂在**每个** pre-step 上、没有任何节流 —— 模型越快、单步越短,被跳过的概率越高,
+   *  于是官方永远抢先压缩、接续从不触发(实测 DeepSeek-V41-Flash 下单步常低于 5 秒,用户亦观察到官方上下文条
+   *  每次工具调用后就更新)。本函数开销很小(`tokenMeter.measure()` + 最近 64 条会话事件扫描),省这点开销不值当;
+   *  minGapMs 仅保留给测试注入。如需控频应改 `checkWaterLevel` 自身,而不是在这里整段跳过。 */
+  checkWaterLevelAtStep(agent, minGapMs = 0) {
     try {
       if (this.config.handoffEnabled === false) return
       if (!agent || !this.hasReliableSessionIdentity(agent)) return
@@ -1935,6 +2040,54 @@ class MemoryEngine {
     } catch (e) { diag('checkWaterLevelAtStep error: ' + (e && e.message)) }
   }
 
+  /** 已接续闩锁(2026-09-10):同一个会话**只允许被接续一次**。
+   *  旧实现只有 30 分钟冷却:冷却一过,用户切回那个旧会话、水位仍然高 → 再次 arm → 再次建会话,
+   *  表现为「切回旧窗口,它还想接续」(实测用户报障)。闩锁以会话 id 为键、落盘到
+   *  ~/.dsh/memory/auto-continue-done.json(重启后依旧生效),接续**失败不落闩**(允许重试)。 */
+  continuedSessionsFile() { return path.join(dshHome(), 'memory', 'auto-continue-done.json') }
+
+  loadContinuedSessions() {
+    if (this._continuedSessions instanceof Set) return this._continuedSessions
+    const set = new Set()
+    try {
+      const obj = JSON.parse(readFileSync(this.continuedSessionsFile(), 'utf8'))
+      const arr = Array.isArray(obj) ? obj : ((obj && Array.isArray(obj.sessions)) ? obj.sessions : [])
+      for (const it of arr) {
+        const k = this.waterKey(typeof it === 'string' ? it : ((it && it.from) || ''))
+        if (k) set.add(k)
+      }
+    } catch (e) {}
+    this._continuedSessions = set
+    return set
+  }
+
+  isContinuedSession(sid) {
+    const k = this.waterKey(sid)
+    return k ? this.loadContinuedSessions().has(k) : false
+  }
+
+  markContinuedSession(sid, toSid) {
+    const k = this.waterKey(sid)
+    if (!k) return false
+    const set = this.loadContinuedSessions()
+    if (set.has(k)) return false
+    set.add(k)
+    try {
+      const file = this.continuedSessionsFile()
+      mkdirSync(path.dirname(file), { recursive: true })
+      let arr = []
+      try {
+        const obj = JSON.parse(readFileSync(file, 'utf8'))
+        arr = Array.isArray(obj) ? obj : ((obj && Array.isArray(obj.sessions)) ? obj.sessions : [])
+      } catch (e0) {}
+      arr.push({ from: k, to: this.waterKey(toSid), at: Date.now() })
+      if (arr.length > 200) arr = arr.slice(-200)
+      writeFileSync(file, JSON.stringify({ sessions: arr, updatedAt: Date.now() }, null, 2), 'utf8')
+    } catch (e) { diag('markContinuedSession write failed: ' + ((e && e.message) || e)) }
+    diag('auto-continue latch: session ' + k + ' marked continued' + (toSid ? ' -> ' + this.waterKey(toSid) : ''))
+    return true
+  }
+
   /** M-CM6-C·宿主兜底自动接续(2026-09-08,2.2.6):浏览器端 AutoContinueHost 被后台节流/关闭时,
    *  宿主自身在倒计时到期后直接建新会话。协议:turn-stopping 且水位≥阈值 → arm 倒计时(confirmSeconds,
    *  默认 35s,写入 _autoContState)→ 浏览器轮询 GET auto-continue-state 显示确认卡(同意=POST decide
@@ -1951,6 +2104,8 @@ class MemoryEngine {
       const cooldownMin = Number(this.config.autoContinueCooldownMinutes) || 30
       if (st.lastRunAt && now - st.lastRunAt < cooldownMin * 60000) return
       const sid = String(agent.session.id || agent.session.header?.id || '')
+      // 已接续闩锁(2026-09-10):该会话已经从它接续过一次 → 永远不再 arm(与 30 分钟冷却无关)
+      if (this.isContinuedSession(sid)) return
       // 拒绝语义:时间窗 10 分钟内不再 arm(近似客户端「拒绝=跳过本边界」;窗口过后按新边界重新评估)
       if (st.rejectedEdgeAt && now - st.rejectedEdgeAt < 10 * 60 * 1000) return
       if (st.armed && Date.now() < st.armed.expiresAt) return         // 已有进行中的倒计时
@@ -1965,6 +2120,10 @@ class MemoryEngine {
         tokens: Number(wl.tokens) || 0,
         window: Number(wl.window) || 0,
         source: String(wl.source || ''),
+        // 双口径(2026-09-10):小圈读数(声明窗口为分母)与距硬墙剩余,供确认卡显示
+        // (state 可能尚未建立 —— 例如测试夹具或极早的 arm,取不到就不显示,不得因此让 arm 失败)
+        ring: Number(this.state && this.state.waterLevelRing) || 0,
+        wall: Number(this.state && this.state.waterLevelWall) || 0,
         // 2.2.7:pre-step 侧 arm 的倒计时到期时,若回合仍活跃则推迟(避免打断进行中的对话)
         awaitIdle: !!(opts && opts.awaitIdle),
         deferCount: 0,
@@ -2007,7 +2166,12 @@ class MemoryEngine {
     try {
       const sc = this._sessionController || (() => { try { this._sessionController = this._ctxRef?.get?.('sessionController') || undefined } catch (e) {} return this._sessionController })()
       if (!sc || typeof sc.create !== 'function') throw new Error('sessionController service unavailable(宿主无法建会话;请重启 dsh web 或保持页面打开)')
-      const d = await this.buildContinueCarry()
+      const oldSid = armed && armed.sessionId ? String(armed.sessionId) : ''
+      // 刷新仪式(2026-09-10):先让旧会话把白板 PLAN 与账本刷到最新,再组装交接材料 ——
+      // 与 client 路径同序(先仪式后材料)。失败/超时都 fail-soft,照常接续。
+      let ritual = null
+      try { ritual = await this.hostRefreshRitual(oldSid) } catch (eRf) { diag('host ritual error: ' + ((eRf && eRf.message) || eRf)) }
+      const d = await this.buildContinueCarry(oldSid)
       if (!d || !d.ok) throw new Error((d && d.error) || 'no handoff material')
       const created = await sc.create({
         ...(d.workspaceId ? { workspaceId: d.workspaceId } : { cwd: d.ws }),
@@ -2015,19 +2179,48 @@ class MemoryEngine {
       })
       const newId = String((created && (created.sessionId || created.id)) || '')
       if (!newId) throw new Error('create returned no sessionId')
+      // 接续序号标题(2026-09-10):浏览器路径一直有(「接续 #N · 工作区」),宿主兜底路径漏了 ——
+      // 兜底接续出来的会话在侧栏是无名会话,用户无法一眼看出它是「延续会话」还是新开的
+      // (实测 18:07 建出的 session-9cc01f76 日志里根本没有 session/title 事件)。
+      if (d.contSeq && typeof sc.rename === 'function') {
+        const title = '接续 #' + String(d.contSeq) + (d.wsBase ? ' · ' + d.wsBase : '')
+        try { await sc.rename({ sessionId: newId, title }) } catch (eT) { diag('host auto-continue rename: ' + ((eT && eT.message) || eT)) }
+      }
       if (d.provider && d.model && typeof sc.selectModel === 'function') {
         try { await sc.selectModel({ sessionId: newId, provider: d.provider, model: d.model, ...(d.reasoningEffort ? { reasoningEffort: d.reasoningEffort } : {}) }) } catch (eM) { diag('host auto-continue selectModel: ' + (eM && eM.message)) }
       }
       if (typeof sc.prompt === 'function') {
         const signal = typeof AbortSignal !== 'undefined' && AbortSignal.timeout ? AbortSignal.timeout(120000) : undefined
-        await sc.prompt({ sessionId: newId, content: [{ type: 'text', text: d.carryText }], mode: 'queue' }, signal)
-      }
+        // DSH 0.1.5 起 SessionPromptRequest.requestId 为必填(客户端铸造的用户消息身份,落到 source.rpcId)。
+        // 缺失时会在 createUserMessage 处抛普通 Error,被官方包装成误导性的 session/agent-busy "prompt rejected"
+        // (实测:建出的新会话只有头部即停更,交接材料从未送达)。官方自己的客户端也做 requestId ?? randomUUID()。
+        const reqId = (typeof randomUUID === 'function')
+          ? randomUUID()
+          : ('dam-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 10))
+        await sc.prompt({ sessionId: newId, requestId: reqId, content: [{ type: 'text', text: d.carryText }], mode: 'queue' }, signal)
+      }
+      // 权限继承(2026-09-10):官方 create 不收权限,新会话会落 settings 的 permission.defaultPreset,
+      // 接续后用户每一步都要批准(静默运行被打断)。agent 在 prompt 之后才建,故在此按延迟重试取 agent.session 再套旧预设;
+      // 旧会话优先按 id 从 agents 注册表取(_lastAgent 重启后可能为空),fail-soft 不影响接续结果。
+      const perm = await this.inheritPermissionForContinue(oldSid, newId)
+      const ritualNote = (ritual && ritual.ok) ? 'updated' : ((ritual && ritual.reason) || 'skipped')
+      // 落闩:旧会话已接续过,此后不再被 arm(即使 30 分钟冷却已过)
+      try { this.markContinuedSession(oldSid, newId) } catch (eL) {}
       st.lastRunAt = Date.now()
-      st.lastOk = { sessionId: newId, model: d.model || '', reasoningEffort: d.reasoningEffort || '', workspaceId: d.workspaceId || '' }
-      diag('auto-continue host-executed: new session ' + newId + ' model=' + (d.model || 'default'))
-      return { ok: true, sessionId: newId, model: d.model || '', reasoningEffort: d.reasoningEffort || '' }
+      st.lastOk = { sessionId: newId, model: d.model || '', reasoningEffort: d.reasoningEffort || '', workspaceId: d.workspaceId || '', permissionPreset: (perm && perm.ok && perm.preset) ? perm.preset : '', refreshRitual: ritualNote }
+      diag('auto-continue host-executed: new session ' + newId + ' model=' + (d.model || 'default') + ' perm=' + ((perm && perm.ok && perm.preset) || ('(' + ((perm && perm.reason) || 'n/a') + ')')) + ' ritual=' + ritualNote)
+      return { ok: true, sessionId: newId, model: d.model || '', reasoningEffort: d.reasoningEffort || '', permissionPreset: (perm && perm.ok && perm.preset) ? perm.preset : '', refreshRitual: ritualNote }
     } catch (e) {
-      st.error = String(e && e.message ? e.message : e)
+      // 官方把 prompt 失败统一包成 session/agent-busy + message "prompt rejected",真实原因只藏在 details/value 里。
+      // 不透出就会得到一句无法排查的 "prompt rejected"(2026-09-10 实测踩坑)。
+      let reason = ''
+      try {
+        const det = (e && (e.details || e.data)) || {}
+        reason = String(det.reason || det.value || det.cause || '')
+        if (!reason && e && e.cause) reason = String((e.cause && e.cause.message) || e.cause)
+      } catch (_) {}
+      const code = String((e && (e.code || e.name)) || '')
+      st.error = String(e && e.message ? e.message : e) + (reason ? ' — ' + reason : '') + (code && code !== 'Error' ? ' [' + code + ']' : '')
       diag('hostAutoContinue error: ' + st.error)
       return { ok: false, error: st.error }
     } finally {
@@ -2036,26 +2229,34 @@ class MemoryEngine {
     }
   }
 
-  /** 浏览器轮询视图:armed 倒计时 / 最近一次执行结果 / 拒绝边界 / 错误。 */
-  autoContinueState() {
+  /** 浏览器轮询视图:armed 倒计时 / 最近一次执行结果 / 拒绝边界 / 错误。
+   *  selfSid(2026-09-10):本状态是**全局单值**,而 armed 只属于某一个会话 —— 不过滤的话,
+   *  别的会话的窗口也会弹「本会话水位已达 x%」(实测:用户切回旧窗口看到属于它的卡片后就以为清不掉)。
+   *  传了 selfSid 且不匹配 → armed 视为 null(取不到 selfSid 时不过滤,fail-open,卡片照常显示)。 */
+  autoContinueState(selfSid) {
     const st = this._autoContState || (this._autoContState = {})
-    const armed = st.armed ? {
+    const selfKey = this.waterKey(selfSid || '')
+    const armedRaw = st.armed ? {
       edgeAt: st.armed.edgeAt,
       sessionId: st.armed.sessionId,
       ratio: st.armed.ratio,
       tokens: st.armed.tokens,
       window: st.armed.window,
+      ring: Number(st.armed.ring) || 0,
+      wall: Number(st.armed.wall) || 0,
       expiresAt: st.armed.expiresAt,
       leftMs: Math.max(0, st.armed.expiresAt - Date.now()),
     } : null
+    const armedMine = !selfKey || !armedRaw || !armedRaw.sessionId || this.waterKey(armedRaw.sessionId) === selfKey
     return {
       enabled: this.config.autoContinueEnabled !== false && this.config.handoffEnabled !== false,
       threshold: Number(this.config.autoContinueThreshold) || 0.75,
-      armed,
+      armed: armedMine ? armedRaw : null,
       executing: !!st.executing,
       rejectedEdgeAt: st.rejectedEdgeAt || 0,
       lastRunAt: st.lastRunAt || 0,
-      lastOk: st.lastOk || null,
+      // at:客户端据此给「已完成」提示加 10 分钟有效期 —— 旧实现没有时间戳,提示会一直挂在所有窗口上
+      lastOk: st.lastOk ? { sessionId: st.lastOk.sessionId, model: st.lastOk.model, reasoningEffort: st.lastOk.reasoningEffort, workspaceId: st.lastOk.workspaceId, permissionPreset: st.lastOk.permissionPreset, refreshRitual: st.lastOk.refreshRitual, at: st.lastRunAt || 0 } : null,
       error: st.error || '',
     }
   }
@@ -2099,6 +2300,83 @@ class MemoryEngine {
     } catch (e) { return '' }
   }
 
+  /**
+   * 最近活跃会话 id 的**磁盘回退**(2026-09-10)。
+   * `_lastAgent` 是纯内存态,宿主重启后要等下一次 pre-step 才重建,而刷新仪式的
+   * `handoff-state.refresh.sessionId` 正好依赖它 —— 重启后立刻点接续会拿到空串,
+   * 客户端据此静默 `skipped`,旧会话收不到刷新指令(实机踩到:旧会话 16:20 后再无写入)。
+   * 回退按会话日志 mtime 取最新,**只认 `session-` 前缀的普通会话目录**:裸 uuid 目录是子代理会话,
+   * 把刷新仪式注进子代理等于白做(还会污染它的上下文),所以宁可返回 '' 让上层明确报"无可刷新目标"。
+   * 5 秒缓存避免面板轮询反复扫盘。
+   */
+  recentSessionIdFallback() {
+    try {
+      const now = Date.now()
+      if (this._sidFallbackAt && now - this._sidFallbackAt < 5000) return this._sidFallbackId || ''
+      this._sidFallbackAt = now
+      const root = path.join(dshHome(), 'sessions')
+      let best = ''
+      let bestMs = 0
+      for (const wsDir of readdirSync(root, { withFileTypes: true })) {
+        if (!wsDir.isDirectory()) continue
+        const wsPath = path.join(root, wsDir.name)
+        let entries = []
+        try { entries = readdirSync(wsPath, { withFileTypes: true }) } catch (_) { continue }
+        for (const ent of entries) {
+          if (!ent.isDirectory()) continue
+          if (!/^session-/.test(ent.name)) continue
+          let ms = 0
+          for (const f of ['session.v3.jsonl.zstd', 'session.jsonl.zstd']) {
+            try { const st = statSync(path.join(wsPath, ent.name, f)); if (st.mtimeMs > ms) ms = st.mtimeMs } catch (_) {}
+          }
+          if (ms > bestMs) { bestMs = ms; best = ent.name }
+        }
+      }
+      this._sidFallbackId = best
+      if (this._sidFallbackId) diag('session id fallback(memory-empty) → ' + this._sidFallbackId)
+      return this._sidFallbackId
+    } catch (_) { return '' }
+  }
+
+  /**
+   * 权限预设继承(2026-09-10):官方 `session.create` 的入参只有
+   * `{workspaceId, cwd, sessionId, agentPreset}`,**没有权限字段** —— 新会话一律走
+   * `PermissionPresetService.pinInitialPermission()` 落 settings 里的 `permission.defaultPreset`。
+   * 于是接续出来的新会话丢掉旧会话的完全权限,用户的静默运行每一步都要批准(实机踩到)。
+   * 这里在读侧 `current(session)` / 写侧 `set(session, name)` 上补一步继承;两者都需要 **Session 对象**,
+   * 官方 webhook 是经 `handle.agent.session` 拿到的,插件同样经 agent 取(拿不到就 fail-soft,不阻塞接续)。
+   */
+  async inheritPermissionPreset(oldAgent, newSid, opts = {}) {
+    try {
+      const ctxRef = this._ctxRef
+      const pp = ctxRef && typeof ctxRef.get === 'function' ? ctxRef.get('permissionPresets') : null
+      if (!pp || typeof pp.current !== 'function' || typeof pp.set !== 'function') return { ok: false, reason: 'no-permission-service' }
+      const oldSession = oldAgent && oldAgent.session
+      if (!oldSession) return { ok: false, reason: 'no-old-session' }
+      let preset = ''
+      try { preset = String(pp.current(oldSession) || '') } catch (eC) { return { ok: false, reason: 'current-failed:' + ((eC && eC.message) || eC) } }
+      if (!preset) return { ok: false, reason: 'empty-preset' }
+      if (preset === 'custom') return { ok: false, reason: 'custom-preset-not-switchable' }
+      const attempts = Array.isArray(opts.attempts) && opts.attempts.length ? opts.attempts : [0, 700, 1600]
+      for (const delay of attempts) {
+        if (delay > 0) await new Promise((r) => setTimeout(r, delay))
+        let ag = null
+        try {
+          const reg = typeof ctxRef.get === 'function' ? ctxRef.get('agents') : null
+          ag = (reg && typeof reg.get === 'function') ? reg.get(newSid) : null
+        } catch (_) {}
+        if (!ag || !ag.session) continue
+        try {
+          pp.set(ag.session, preset)
+          diag('auto-continue permission inherited: ' + preset + ' → ' + newSid)
+          return { ok: true, preset }
+        } catch (eS) { diag('auto-continue permission set failed: ' + ((eS && eS.message) || eS)) }
+      }
+      diag('auto-continue permission inherit skipped: no live agent for ' + newSid)
+      return { ok: false, reason: 'no-agent-for-new-session' }
+    } catch (e) { return { ok: false, reason: String((e && e.message) || e) } }
+  }
+
   /** 修A(2026-09-08):解析会话所属 workspaceId。官方 api-session-controller create() 只在传 workspaceId 时
    *  调 workspace.attachSession()(index.js:566-588),只传 cwd 仅设工作目录 → 新会话永远落「未分组工作区」。
    *  归属判定走 workspaceRegistry(与官方 forkWorkspace index.js:874 同款),服务缺失/无归属返回 ''(client 回退 cwd)。 */
@@ -2125,20 +2403,110 @@ class MemoryEngine {
     ].join(String.fromCharCode(10))
   }
 
+  /** 按会话 id 取活动 agent(官方 agents 注册表)。取不到返回 null —— 权限/仪式都靠它拿 Session 对象。 */
+  agentForSessionId(sid) {
+    const id = String(sid || '')
+    if (!id) return null
+    try {
+      const reg = (this._ctxRef && typeof this._ctxRef.get === 'function') ? this._ctxRef.get('agents') : null
+      const ag = (reg && typeof reg.get === 'function') ? reg.get(id) : null
+      return (ag && ag.session) ? ag : null
+    } catch (e) { return null }
+  }
+
+  /** 接续材料指纹(PLAN mtime + 最新账本名):刷新仪式靠它判断旧会话有没有真的产出新白板/账本。
+   *  只 stat 一个文件 + 一次 readdir,比 handoffPanelData 便宜得多(仪式要按秒轮询)。 */
+  async handoffMaterialStamp() {
+    try {
+      const dir = this.state.handoffDir || (await this.resolvePaths(undefined)).handoffDir
+      const planPath = this.state.planPath || path.join(dir, 'PLAN.md')
+      const planMt = await stat(planPath).then((s) => Number(s.mtimeMs)).catch(() => 0)
+      const names = await readdir(dir).catch(() => [])
+      const led = names.filter((n) => /^handoff-\d{8}-\d{6}(-[a-z])?\.md$/.test(n)).sort()
+      return String(planMt) + '|' + (led[led.length - 1] || '')
+    } catch (e) { return '' }
+  }
+
+  /** 宿主侧刷新仪式(2026-09-10):原先只有 client 路径做刷新,宿主兜底接续(浏览器关着/后台节流)
+   *  完全跳过 —— 旧会话收不到指令,新会话拿到的白板与账本就停在旧版。这里补齐同款顺序:
+   *  **先让旧会话刷白板+写账本,再组装材料**。
+   *  安全约束:只在 `armed.sessionId` 明确时注入(绝不猜会话);同一旧会话 10 分钟内只注入一次
+   *  (接续失败重试时不刷屏);全程 fail-soft —— 仪式失败照常接续,只记 diag。 */
+  async hostRefreshRitual(oldSid) {
+    const sid = String(oldSid || '')
+    if (!sid) return { ok: false, reason: 'no-old-session' }
+    if (this.config.autoContinueRefreshRitual === false) return { ok: false, reason: 'disabled' }
+    const st = this._autoContState || (this._autoContState = {})
+    const now = Date.now()
+    if (st.ritualForSid === sid && st.ritualAt && now - st.ritualAt < 10 * 60 * 1000) return { ok: false, reason: 'already-sent' }
+    const sc = this._sessionController || (() => { try { this._sessionController = this._ctxRef?.get?.('sessionController') || undefined } catch (e) {} return this._sessionController })()
+    if (!sc || typeof sc.prompt !== 'function') return { ok: false, reason: 'no-session-controller' }
+    st.ritualForSid = sid
+    st.ritualAt = now
+    try {
+      const before = await this.handoffMaterialStamp()
+      const reqId = (typeof randomUUID === 'function')
+        ? randomUUID()
+        : ('dam-r-' + Date.now().toString(36) + '-' + Math.random().toString(36).slice(2, 10))
+      const signal = typeof AbortSignal !== 'undefined' && AbortSignal.timeout ? AbortSignal.timeout(60000) : undefined
+      diag('host refresh ritual → old session ' + sid)
+      await sc.prompt({ sessionId: sid, requestId: reqId, content: [{ type: 'text', text: this.refreshRitualPrompt() }], mode: 'queue' }, signal)
+      const sec = Number(this.config.autoContinueRefreshTimeoutSeconds)
+      const timeoutMs = (sec >= 15 && sec <= 600 ? sec : 90) * 1000
+      const t0 = Date.now()
+      const pollMs = Number(this._ritualPollMs) > 0 ? Number(this._ritualPollMs) : 2500
+      while (Date.now() - t0 < timeoutMs) {
+        await new Promise((r) => setTimeout(r, pollMs))
+        const cur = await this.handoffMaterialStamp()
+        if (cur && cur !== before) { diag('host refresh ritual: material updated after ' + Math.round((Date.now() - t0) / 1000) + 's'); return { ok: true, waited: 'updated' } }
+      }
+      diag('host refresh ritual: timeout, continuing with current material')
+      return { ok: false, reason: 'timeout' }
+    } catch (e) {
+      diag('host refresh ritual failed: ' + ((e && e.message) || e))
+      return { ok: false, reason: String((e && e.message) || e) }
+    }
+  }
+
+  /** 给 client 路径用的权限继承入口(2026-09-10):client 自己调官方 session.create,
+   *  宿主侧只负责把旧会话的权限预设套到新会话上。旧 agent 优先按 fromSessionId 从注册表取
+   *  (_lastAgent 重启后可能为空),取不到再退回内存态。 */
+  async inheritPermissionForContinue(fromSessionId, toSessionId, opts = {}) {
+    const from = String(fromSessionId || '')
+    const to = String(toSessionId || '')
+    if (!to) return { ok: false, reason: 'no-new-session' }
+    const oldAgent = this.agentForSessionId(from)
+      || ((this._lastAgent && this._lastAgent.session && String(this._lastAgent.session.id) === from) ? this._lastAgent : null)
+    return this.inheritPermissionPreset(oldAgent, to, opts)
+  }
+
   /** M-CM6-B v2·旧会话上下文包(2026-09-08):定位当前(旧)会话持久化文件(~/.dsh/sessions/<ws>/<sid>/session.jsonl[.zstd]),
    *  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() {
+  async buildPrevSessionPack(preferSid) {
     try {
+      // 2026-09-10 实机取证:此前只认 this._lastAgent(最近活跃的 agent),而自动接续的旧会话是
+      // armed.sessionId —— 二者可以不是同一个会话(14:54:30 实测:armed=de10b34f,却把
+      // 1f621132 的转写与 provider/model/effort 当成接续材料,新会话还会被 selectModel 套错模型)。
+      // 现在改为:显式传入的旧会话优先;只有它取不到持久化文件时才退回 _lastAgent。
       const agent = this._lastAgent
-      const sid = agent && agent.session && agent.session.id ? String(agent.session.id) : ''
-      if (!sid) return null
+      const lastSid = agent && agent.session && agent.session.id ? String(agent.session.id) : ''
+      const want = String(preferSid || '')
+      const cands = []
+      if (want) cands.push(want)
+      if (lastSid && lastSid !== want) cands.push(lastSid)
+      if (!cands.length) return null
       const sessionsDir = path.join(dshHome(), 'sessions')
+      const wsDirs = await readdir(sessionsDir).catch(() => [])
+      let sid = cands[0]
       let file = null
-      for (const w of await readdir(sessionsDir).catch(() => [])) {
-        const resolved = await this.resolveSessionFile(path.join(sessionsDir, w, sid))
-        if (resolved) { file = resolved; break }
+      for (const cand of cands) {
+        for (const w of wsDirs) {
+          const resolved = await this.resolveSessionFile(path.join(sessionsDir, w, cand))
+          if (resolved) { file = resolved; sid = cand; break }
+        }
+        if (file) break
       }
       if (!file) return { sessionId: sid }
       const buf = await readFile(file)
@@ -2191,7 +2559,7 @@ class MemoryEngine {
    *  取当前工作区白板+最新账本;工作区未绑定/材料为空时降级用全局最近账本(findLatestGlobalHandoff)。
    *  v2:附带旧会话上下文包(转写文件路径+主动读取指令)与新会话状态沿用参数(cwd/provider/model)。
    *  返回 {ok, carryText, planPath, ws, provider, model, prevSessionId, transcriptPath};无任何材料时 ok:false。 */
-  async buildContinueCarry() {
+  async buildContinueCarry(preferSid) {
     try {
       if (this.config.handoffEnabled === false) return { ok: false, error: 'handoff disabled' }
       const p = await this.resolvePaths(undefined)
@@ -2203,7 +2571,7 @@ class MemoryEngine {
         const gl = await this.findLatestGlobalHandoff()
         if (gl) { ledger = await this.readTextSafe(gl); ledgerFrom = 'global' }
       }
-      const pack = await this.buildPrevSessionPack()
+      const pack = await this.buildPrevSessionPack(preferSid)
       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 '(未知)' } }
@@ -2367,7 +2735,8 @@ class MemoryEngine {
       }
     }
     const planMt = await stat(planPath).then((s) => Number(s.mtimeMs)).catch(() => 0)
-    const sid = this.currentSessionId()
+    // 刷新仪式的会话 id:内存态为空时走磁盘回退(宿主重启后 _lastAgent 未重建的窗口期)
+    const sid = this.currentSessionId() || this.recentSessionIdFallback()
     return {
       enabled: true, planPath,
       plan: await this.readTextSafe(planPath),
@@ -2761,249 +3130,292 @@ class MemoryEngine {
     } catch (_) { return false }
   }
 
-  // ---------- 每日写入预算 + 超限自动压缩(硬约束,但不拒绝新内容) ----------
+  // ---------- 记忆容量上限 + 超限自动整理(容量口径,单位=字符) ----------
   /**
-   * 用户级 ≤4000 字/天、项目级 ≤3000 字/天(所有会话共享一天预算,跨天重置)。
-   * 超限时不直接拒绝:先自动压缩"今天之前"的旧内容腾出空间(ensureBudget),压缩不可用时才拒绝。
+   * 2026-09-10 重做(方案 0+1+2+3):
+   * - **口径改为「文件容量」**:只要写入后总字符数 ≤ 上限就放行。旧口径按"当日写入量"计,
+   *   而压缩对象只有"今天之前"的记录 → 当天写得多就必然堵死(即便文件很小),且跨天才能自解。
+   * - **单位统一为字符**(`String.length`):旧实现记账用字符、压缩配额用字节(`rec.byteEnd - rec.markerByteStart`),
+   *   同一个 3000 在中文内容下差 ~1.44 倍;legacy 文本路径用字符、anchor 路径用字节,还会随 anchor 开关跳变。
+   * - **超限先整理**:优先"AI 折叠成要点",失败退回"整条归档";整理后仍超才拒绝(正常情况不会发生)。
    */
-  accountWrite(agent, layer, text) {
-    if (!this._budgets) this._budgets = new Map()
-    const today = this.memToday()
-    let b = this._budgets.get('today')
-    if (!b || b.date !== today) { b = { date: today, user: 0, note: 0 }; this._budgets.set('today', b) }
-    const limit = layer === 'user' ? 4000 : 3000
-    const next = b[layer] + String(text || '').length
-    if (next > limit) return { ok: false, used: b[layer], limit, remaining: Math.max(0, limit - b[layer]) }
-    b[layer] = next
-    return { ok: true, used: next, limit, remaining: limit - next }
+  capacityLimit(layer) {
+    const raw = Number(this.config[layer === 'user' ? 'userCapacityChars' : 'noteCapacityChars'])
+    if (Number.isFinite(raw) && raw >= 500) return Math.floor(raw)
+    return layer === 'user' ? DEFAULT_USER_CAPACITY_CHARS : DEFAULT_NOTE_CAPACITY_CHARS
+  }
+
+  /** 追加写入时的固定开销(换行 + `## YYYY-MM-DD` 标题行)。容量检查必须计入,否则低估约 15 字符。 */
+  appendOverheadChars() {
+    try { return ('\n## ' + this.memToday() + '\n').length } catch (_) { return 16 }
+  }
+
+  /** 容量检查:当前字符数 + 待写入字符数(含标题行与分隔换行) ≤ 上限则放行。 */
+  capacityCheck(layer, curChars, text) {
+    const limit = this.capacityLimit(layer)
+    const add = String(text == null ? '' : String(text)).length + this.appendOverheadChars()
+    const need = curChars + add
+    return { ok: need <= limit, limit, used: curChars, need, add }
+  }
+
+  /** 读某层当前字符数(优先内存态 `state.userText/notesText`,回退读盘)。 */
+  async layerCharCount(layer, p) {
+    const cached = layer === 'user' ? this.state.userText : this.state.notesText
+    if (typeof cached === 'string' && cached.length) return cached.length
+    try { return String((await this.readTextSafe(layer === 'user' ? p.userFile : p.notesPath)) || '').length } catch (_) { return 0 }
   }
 
-  /** 预算保障:超限时自动压缩旧内容腾位;压缩成功返回 compacted:true,否则 ok:false。 */
+  /**
+   * 容量保障:超限时自动整理腾位,并在**整理后复查实际文件大小**;仍超则按新的实际值再整理(最多 3 轮)。
+   *
+   * 2026-09-10 第二轮修正:旧实现只压一轮就复查,而单轮缺口是按"容纳本次写入"估算的 ——
+   * 折叠产物、`## 日期` 标题行开销等会让实际结果偏小,于是出现"压缩确实成功(折叠块已写入)、
+   * 复查却不过、工具还把成功标识 `folded` 当失败原因报出来"的怪象(实机踩到)。
+   * 现在每轮都用**重新测量的实际文件大小**算缺口,复查不过就再来一轮;失败时返回**真实**原因。
+   */
   async ensureBudget(agent, layer, text) {
-    const acct = this.accountWrite(agent, layer, text)
+    const p = await this.resolvePaths(agent)
+    let acct = this.capacityCheck(layer, await this.layerCharCount(layer, p), text)
     if (acct.ok) return { ok: true, acct }
-    const compacted = await this.compactLayer(agent, layer)
-    if (compacted) {
-      const acct2 = this.accountWrite(agent, layer, text)
-      if (acct2.ok) return { ok: true, acct: acct2, compacted: true }
+    let last = null
+    let compactedOnce = false
+    for (let round = 0; round < 3; round++) {
+      const cur = await this.layerCharCount(layer, p)
+      const need = cur + String(text == null ? '' : String(text)).length + this.appendOverheadChars()
+      last = await this.compactLayer(agent, layer, { needChars: need, round })
+      if (!last || !last.ok) break
+      compactedOnce = true
+      acct = this.capacityCheck(layer, await this.layerCharCount(layer, p), text)
+      if (acct.ok) return { ok: true, acct, compacted: true }
+    }
+    const reason = (!last || !last.ok)
+      ? ((last && last.reason) || 'compact-failed')
+      : (compactedOnce ? 'still-over-capacity' : 'compact-made-no-progress')
+    return { ok: false, acct, reason, retryAfterMs: (last && last.retryAfterMs) || 0 }
+  }
+
+  /**
+   * 整理失败时的**准确**报错。旧实现把三种完全不同的原因压成一句
+   * "(刚压缩过或 AI 不可用)" —— 实测会把使用者(和模型)直接带偏,故拆开:
+   * throttled(节流中,给秒数) / no-removable(无可回收) / dirty-file(锚点文件脏,fail-closed) / 其它。
+   */
+  budgetRefusalTextPre(res, layer) {
+    const name = layer === 'user' ? '用户级记忆' : '项目笔记'
+    const limit = (res && res.acct && res.acct.limit) || this.capacityLimit(layer)
+    const used = (res && res.acct && res.acct.used) || 0
+    const why = String((res && res.reason) || 'compact-failed')
+    const head = name + '已达容量上限(' + used + '/' + limit + ' 字符),自动整理未能腾出空间'
+    if (why === 'throttled') {
+      const sec = Math.max(1, Math.ceil((Number(res.retryAfterMs) || 0) / 1000))
+      return head + ':距上次整理不足 10 分钟(节流中),约 ' + sec + ' 秒后可重试。'
+    }
+    if (why === 'no-removable') {
+      return head + ':可回收内容为空(最新 1 条记录为硬底线,永不整条移除)。'
+        + '可调大 ' + (layer === 'user' ? 'userCapacityChars' : 'noteCapacityChars') + ',或用 action=replace 整体重写。'
+    }
+    if (why === 'dirty-file') {
+      return head + ':锚点文件校验未通过(脏文件,fail-closed 不做字符切片)。'
+        + '请检查是否被手工编辑破坏了 <!-- memory:mem_xxx --> 标记。'
+    }
+    if (why === 'still-over-capacity') {
+      return head + ':已自动整理,但整理后仍放不下本次内容(单次写入过大)。'
+        + '请把内容拆小分批写,或调大 ' + (layer === 'user' ? 'userCapacityChars' : 'noteCapacityChars') + '。'
     }
-    return { ok: false, acct }
+    if (why === 'compact-made-no-progress') {
+      return head + ':整理了但没有腾出空间。可调大 ' + (layer === 'user' ? 'userCapacityChars' : 'noteCapacityChars') + ',或用 action=replace 整体重写。'
+    }
+    return head + ':折叠与归档均未成功(' + why + ')。原内容未改动,可稍后重试。'
   }
 
-  /** 压缩层内"今天之前"的旧段落:AI 提炼要点替换,不可用时归档最早段落;10 分钟节流。 */
-  async compactLayer(agent, layer) {
+  /**
+   * 层内整理:超出容量时腾出空间。**先 AI 折叠成要点,失败退回整条归档**——两者都把原文写进归档保底。
+   *
+   * 2026-09-10 重做(方案 0+1+2+3)要点:
+   * - **单位统一为字符**:旧实现记账按字符、压缩配额按字节(`rec.byteEnd - rec.markerByteStart`),
+   *   同一个 3000 在中文内容下差 ~1.44 倍;legacy 文本路径用字符、anchor 路径用字节,还会随 anchor 开关跳变。
+   * - **保护窗口 + 硬底线**:最近写入的 `COMPACT_PROTECT_RECENT_CHARS` 字符不参与回收;硬底线=至少保留最新 1 条
+   *   (若保护窗口自身就超容量,允许对其折叠成要点,但不整条删除),否则会在"最近内容本身就很大"时重新死锁。
+   * - **节流按层独立**:`_lastCompactAt` 旧实现是单个变量,压过用户级会连带节流项目级。
+   * - **返回结构化结果**:让上层能给出准确报错(reason/retryAfterMs),不再把"节流中/无可压缩/AI 失败"混成一句。
+   * @returns {Promise<{ok:boolean, reason?:string, retryAfterMs?:number}>}
+   */
+  async compactLayer(agent, layer, opts = {}) {
     const now = Date.now()
-    if (this._lastCompactAt && now - this._lastCompactAt < 10 * 60 * 1000) return false
+    const state = (this._lastCompactAt && typeof this._lastCompactAt === 'object') ? this._lastCompactAt : (this._lastCompactAt = {})
+    const last = Number(state[layer]) || 0
+    // 节流只限制"昂贵的 AI 折叠",**不阻止"便宜的整条归档"** —— 否则短时间内反复超容量时
+    // 仍会拒绝写入,违背"新记忆永不堵在外面"。归档只是一次文件追加 + 一次原子替换,代价可忽略。
+    const allowFold = !(last && now - last < COMPACT_THROTTLE_MS)
     const p = await this.resolvePaths(agent)
-    // F1:anchor 开启 → 记录级压缩(整条保留/移除,经 store.replace;永不字符切片)。
-    // 目标文件无 sidecar('not-anchored')才回退旧文本路径。
+    const limit = this.capacityLimit(layer)
+    const curChars = await this.layerCharCount(layer, p)
+    // 直接算**缺口**:要腾出多少字符才够本次写入放下。
+    // 旧写法算的是"保留量目标 = limit - pending",方向反了 —— 当全部记录本来就小于该目标时会被判成
+    // "无可回收",而文件其实只差几十字符就超限(2026-09-10 实机踩到,报错文案即"可回收内容为空")。
+    const needChars = Number(opts.needChars || 0) || (curChars + 1)
+    const deficit = Math.max(1, needChars - limit)
+    const keepBudget = Math.max(COMPACT_PROTECT_RECENT_CHARS, limit - deficit - 1) // legacy 文本路径仍按"保留量"口径
+
     const store0 = this.docStore
     if (store0) {
       try {
-        const r = await this.compactAnchoredLayer(store0, layer === 'user' ? p.userFile : p.notesPath, layer, this.memToday(), p)
-        if (process.env.DSH_F1_DEBUG) console.error('[f1-diag] compactAnchoredLayer -> ' + (layer === 'user' ? p.userFile : p.notesPath) + ' => ' + r)
-        if (r !== 'not-anchored') return r === true
+        const r = await this.compactAnchoredLayer(store0, layer === 'user' ? p.userFile : p.notesPath, layer, this.memToday(), p, deficit, agent, allowFold)
+        if (r !== 'not-anchored') return r || { ok: false, reason: 'no-removable' }
       } catch (e) {
         console.error('[compacted-anchored] failed: ' + (e && e.message ? e.message : e))
-        return false
+        return { ok: false, reason: 'error:' + String((e && e.message) || e).slice(0, 80) }
       }
     }
-    const cur = (layer === 'user' ? this.state.userText : this.state.notesText) || ''
-    if (!cur.trim()) return true
-    const limit = layer === 'user' ? 4000 : 3000
-    const today = this.memToday()
-    // 按 "## 标题" 切段,今天段落保留,之前段落为压缩对象;文件头非 ## 内容归入头部段,不丢失
+    return await this.compactLegacyLayer(agent, layer, p, keepBudget, allowFold)
+  }
+
+  /**
+   * 无 anchor(sidecar 未启用)时的文本段整理。原逻辑内联在 compactLayer 中,2026-09-10 抽出。
+   * 同样取消"今日段无条件保留",改为**从尾往回**按 keepBudget 保留(含今日),最新一段是硬底线。
+   */
+  async compactLegacyLayer(agent, layer, p, keepBudget, allowFold) {
+    const cur = String((layer === 'user' ? this.state.userText : this.state.notesText) || '')
+    if (!cur.trim()) return { ok: true, reason: 'empty' }
     const segs = []
-    let curSeg = { title: '(文件头)', body: [], isToday: false }
+    let curSeg = { title: '(文件头)', body: [] }
     for (const ln of cur.split('\n')) {
       const m = ln.match(/^##\s+(.+)$/)
-      if (m) {
-        if (curSeg) segs.push(curSeg)
-        const title = m[1].trim()
-        curSeg = { title, body: [], isToday: /^\d{4}-\d{2}-\d{2}/.test(title) && title.slice(0, 10) === today }
-      } else if (curSeg) {
-        curSeg.body.push(ln)
-      }
-    }
-    if (curSeg) segs.push(curSeg)
-    const oldSegs = segs.filter((s) => !s.isToday)
-    const todaySegs = segs.filter((s) => s.isToday)
+      if (m) { segs.push(curSeg); curSeg = { title: m[1].trim(), body: [] } } else { curSeg.body.push(ln) }
+    }
+    segs.push(curSeg)
+    const spanOf = (s) => ('## ' + s.title + '\n' + s.body.join('\n')).length
+    const keep = new Array(segs.length).fill(false)
+    let kept = 0
+    for (let i = segs.length - 1; i >= 0; i--) {
+      const span = spanOf(segs[i])
+      if (i === segs.length - 1) { keep[i] = true; kept += span; continue }
+      if (kept + span <= keepBudget) { keep[i] = true; kept += span; continue }
+      break
+    }
+    const oldSegs = segs.filter((_, i) => !keep[i])
+    const keptText = segs.filter((_, i) => keep[i]).map((s) => '## ' + s.title + '\n' + s.body.join('\n')).join('\n').trim()
+    if (!oldSegs.length) return { ok: false, reason: 'no-removable' }
+
     const oldText = oldSegs.map((s) => '## ' + s.title + '\n' + s.body.join('\n')).join('\n').trim()
-    const todayText = todaySegs.map((s) => '## ' + s.title + '\n' + s.body.join('\n')).join('\n').trim()
-    const target = Math.max(limit, 200) // 压缩后旧部分目标:不超过层上限
-    if (oldText.length <= target) return true // 旧内容本来就不大,无需压缩
-    let newOld = ''
-    if (this._subagents && agent) {
-      try {
-        const layerName = layer === 'user' ? '用户级记忆' : '项目笔记'
-        const prompt = [
-          '你是记忆整理员。下面的' + layerName + '文件里"今天之前"的旧内容需要压缩,因为今天要写入的新内容已超当日预算。',
-          '规则:',
-          '- 保留所有仍有长期价值的硬信息:强制规则、偏好、关键决策、约定、账号/路径等',
-          '- 合并重复、删除已失效/过期条目、把长句压到 20 字内',
-          '- 输出 markdown,可用"## 主题"分组,输出将直接替换旧内容',
-          '- 只输出压缩结果正文,不要任何解释',
-          '',
-          '待压缩旧内容:',
-          truncateTail(oldText, 6000),
-        ].join('\n')
-        const out = await this.runSubagent(prompt, 'auto-memory-compact', agent)
-        if (out && !out.includes('(无)')) newOld = out.trim()
-      } catch (e) {
-        console.error('[dsh-auto-memory] compactLayer AI failed', e && e.message ? e.message : e)
-      }
-    }
-    if (!newOld) {
-      // AI 不可用降级:把最早段落移入归档文件,直到旧部分 ≤ target(保底不丢)
+    let folded = allowFold ? await this.foldTextToSummaryPre(oldText, layer, agent) : ''
+    if (!folded) {
+      // AI 不可用降级:把最早段落整段移入归档,直到剩余 ≤ keepBudget(保底不丢)
       const archiveFile = layer === 'user'
         ? path.join(dshHome(), 'memory', 'archived-user.md')
         : path.join(p.projectDir, 'archive', 'notes-archived.md')
       await mkdir(path.dirname(archiveFile), { recursive: true })
-      let segs2 = oldSegs.slice()
-      let remain = oldText
-      while (remain.length > target && segs2.length) {
-        const seg = segs2.shift()
+      const rest = oldSegs.slice()
+      let remainText = rest.map((s) => '## ' + s.title + '\n' + s.body.join('\n')).join('\n').trim()
+      while (remainText.length > keepBudget && rest.length > 1) {
+        const seg = rest.shift()
         await this.appendText(archiveFile, '\n## ' + seg.title + '\n' + seg.body.join('\n'))
-        remain = segs2.map((s) => '## ' + s.title + '\n' + s.body.join('\n')).join('\n').trim()
+        remainText = rest.map((s) => '## ' + s.title + '\n' + s.body.join('\n')).join('\n').trim()
       }
-      newOld = remain.slice(0, target)
+      folded = remainText.slice(0, keepBudget)
+    } else {
+      // 折叠成功:原文同样归档(整段),主文件只留要点
+      const archiveFile = layer === 'user'
+        ? path.join(dshHome(), 'memory', 'archived-user.md')
+        : path.join(p.projectDir, 'archive', 'notes-archived.md')
+      await mkdir(path.dirname(archiveFile), { recursive: true })
+      await this.appendText(archiveFile, '\n' + oldSegs.map((s) => '## ' + s.title + '\n' + s.body.join('\n')).join('\n'))
     }
-    newOld = newOld.slice(0, target)
-    const body = [newOld, todayText].filter(Boolean).join('\n\n')
+    const body = [folded, keptText].filter(Boolean).join('\n\n')
     await this.writeFull(layer === 'user' ? p.userFile : p.notesPath, body)
     if (layer === 'user') this.state.userText = body
     else this.state.notesText = body
-    // 压缩腾出的空间让当日额度重新计(今天段落仍在文件里,不丢)
-    if (this._budgets) {
-      const b = this._budgets.get('today')
-      if (b && b.date === this.memToday()) b[layer] = 0
-    }
-    this._lastCompactAt = now
+    this._lastCompactAt[layer] = Date.now()
     this.state.loadedAt = Date.now()
-    console.log('[dsh-auto-memory] compacted ' + layer + ' memory: ' + cur.length + ' -> ' + body.length + ' chars')
-    return true
+    console.log('[compacted] ' + layer + ': ' + cur.length + ' -> ' + body.length + ' chars (folded=' + (folded ? 'yes' : 'archive-only') + ')')
+    return { ok: true, reason: folded ? 'folded' : 'archived' }
   }
 
   /**
-   * F1(M6-CONTRACT 外补丁,2026-08-23):anchor 开启时的记录级压缩。
-   * 按 sidecar 记录序整条保留/移除——今天(标题日期=插件今天)记录无条件保留,其余按字节配额
-   * 从最新往回保留(layer 上限 user 4000/note 3000);被移除记录整条原文写入归档文件
-   * (writeFullRaw,不经 anchor 事务,归档非检索语料)。重组经 store.replace 原子执行:
-   * 候选预检(clean)→被移除 id 自动删除→保留 id/版本不变。永不字符切片。
-   * @returns {Promise<boolean|'not-anchored'>} true=已腾位 false=无法腾位 'not-anchored'=无 sidecar 走旧路径
+   * 把一段旧内容交给子代理折叠成要点(≤ COMPACT_FOLD_MAX_CHARS)。失败/无子代理返回 ''。
+   * 折叠失败**不是错误**——调用方会退回整条归档,所以这里 fail-soft。
    */
-  async compactAnchoredLayer(store, filePath, layer, today, paths) {
-    const cur = await this.readTextSafe(filePath)
-    if (!cur || !cur.trim()) return false
-    let parsed
-    try { parsed = parseAnchors(Buffer.from(cur, 'utf8')) } catch (_) { return 'not-anchored' }
-    if (!parsed || parsed.status !== 'clean') return false // 脏文件 fail closed:不压缩、不切片
-    const anchored = parsed.records.filter((r) => r.kind === 'anchored')
-    if (!anchored.length) return 'not-anchored'
-    const limit = layer === 'user' ? 4000 : 3000
-    const isTodayHeading = (heading) => /^\d{4}-\d{2}-\d{2}/.test(String(heading || '')) && String(heading).slice(0, 10) === today
-    const buf = Buffer.from(cur, 'utf8')
-    // 配额从尾回溯(F1):新的留;今天记录无条件保留
-    const keep = new Array(anchored.length).fill(false)
-    let keptBytes = 0
-    for (let i = anchored.length - 1; i >= 0; i--) {
-      const rec = anchored[i]
-      const spanBytes = rec.byteEnd - rec.markerByteStart
-      if (isTodayHeading(rec.heading) || keptBytes + spanBytes <= limit) { keep[i] = true; keptBytes += spanBytes }
-    }
-    const removedIdx = []
-    anchored.forEach((rec, i) => { if (!keep[i]) removedIdx.push(i) })
-    if (!removedIdx.length) return false // 无可移除 → 无法腾位(预算照常拒绝)
-    // 有序块重组:legacy 块与 preamble/tail 原样保留,gap 字节逐段拷贝,仅丢弃被移除记录的 [marker..contentEnd]
-    const blocks = []
-    for (const r of parsed.records) {
-      if (r.kind === 'anchored') blocks.push({ start: r.markerByteStart, end: r.byteEnd, keep: keep[anchored.indexOf(r)] })
-      else blocks.push({ start: r.byteStart, end: r.byteEnd, keep: true })
-    }
-    blocks.sort((a, b) => a.start - b.start)
-    const parts = []
-    let cursorB = 0
-    for (let i = 0; i < blocks.length; i++) {
-      const b = blocks[i]
-      if (b.start > cursorB) parts.push(buf.slice(cursorB, b.start).toString('utf8'))
-      if (b.keep) parts.push(buf.slice(b.start, b.end).toString('utf8'))
-      cursorB = b.end
-    }
-    if (cursorB < buf.length) parts.push(buf.slice(cursorB).toString('utf8'))
-    const newText = parts.join('')
-    // 归档:整条原文(writeFullRaw 绕开 anchor 事务;归档文件从不参与解析/索引)
-    const archiveFile = layer === 'user'
-      ? path.join(dshHome(), 'memory', 'archived-user.md')
-      : path.join(paths.projectDir, 'archive', 'notes-archived.md')
-    const archiveText = removedIdx.map((i2) => {
-      const r = anchored[i2]
-      return buf.slice(r.markerByteStart, r.byteEnd).toString('utf8')
-    }).join('\n')
-    const existingArchive = await this.readTextSafe(archiveFile)
-    await this.writeFullRaw(archiveFile, (existingArchive ? existingArchive.replace(/\s+$/, '') + '\n' : '') + archiveText + '\n')
-    const rr = await store.replace(filePath, newText)
-    if (!rr.ok) { console.error('[compacted-anchored] replace failed: ' + rr.reason); return false }
-    const freshText = await this.readTextSafe(filePath)
-    if (layer === 'user') this.state.userText = freshText
-    else this.state.notesText = freshText
-    if (this._budgets) {
-      const b = this._budgets.get('today')
-      if (b && b.date === this.memToday()) b[layer] = 0
+  async foldTextToSummaryPre(text, layer, agent) {
+    try {
+      if (!this._subagents || !agent || !String(text || '').trim()) return ''
+      const layerName = layer === 'user' ? '用户级记忆' : '项目笔记'
+      const prompt = [
+        '你是记忆整理员。下面这段' + layerName + '内容已超出容量上限,需要**压缩成要点**后留在主文件里(原文会同时归档,不会丢)。',
+        '规则:',
+        '- 保留所有仍有长期价值的硬信息:强制规则、偏好、关键决策、约定、关键路径、踩过的坑及其规则',
+        '- 合并重复、删除已失效/过期条目;每条一句话,尽量压到 30 字内',
+        '- 按主题分组,用"### 主题"小标题;不要复述原文,只留结论',
+        '- 语体:第三人称客观陈述,只落可复用结论;禁止第一人称思维叙述与思考腔',
+        '- 只输出 markdown 正文,不要任何解释;总长度不超过 ' + COMPACT_FOLD_MAX_CHARS + ' 字符',
+        '',
+        '待折叠内容:',
+        truncateTail(String(text), 6000),
+      ].join('\n')
+      const out = await this.runSubagent(prompt, 'auto-memory-fold', agent)
+      const t = String(out || '').trim()
+      if (!t || t.includes('(无)')) return ''
+      return t.slice(0, COMPACT_FOLD_MAX_CHARS)
+    } catch (e) {
+      console.error('[auto-memory-fold] failed: ' + (e && e.message ? e.message : e))
+      return ''
     }
-    this._lastCompactAt = Date.now()
-    this.state.loadedAt = Date.now()
-    console.log('[compacted-anchored] ' + layer + ': kept=' + (anchored.length - removedIdx.length) + '/' + anchored.length + ' archived=' + removedIdx.length + ' bytes=' + cur.length + '->' + newText.length)
-    return true
   }
 
   /**
-   * F1(M6-CONTRACT 外补丁,2026-08-23):anchor 开启时的记录级压缩。
-   * 按 sidecar 记录序整条保留/移除——今天(标题日期=插件今天)记录无条件保留,其余按字节配额
-   * 从最新往回保留(layer 上限 user 4000/note 3000);被移除记录整条原文写入归档文件
-   * (writeFullRaw,不经 anchor 事务,归档非检索语料)。重组经 store.replace 原子执行:
-   * 候选预检(clean)→被移除 id 自动删除→保留 id/版本不变。永不字符切片。
-   * @returns {Promise<boolean|'not-anchored'>} true=已腾位 false=无法腾位 'not-anchored'=无 sidecar 走旧路径
+   * anchor 开启时的记录级整理(2026-09-10 重做,合并原先三份重复实现)。
+   *
+   * 旧行为的致命点:标题日期=今天的记录**无条件保留** → 当天写入量本身超过额度时 `removable` 为空、
+   * 直接返回"无法腾位",于是当天再也写不进项目笔记(须跨天自解)。现在改为**只按容量配额从尾往回保留**,
+   * 保护窗口外(含今天写入的较早条目)一律可回收。
+   *
+   * 回收方式:优先把可回收的前缀折叠成**一条要点记录**写回原位置(AI 不可用时退回整条移除);
+   * 两种情况都把被回收记录的原文整条写入归档文件(writeFullRaw 绕开 anchor 事务,归档不参与解析/索引)。
+   * 重组经 `store.replace` 原子执行:候选预检(clean)→被移除 id 自动删除→保留 id/版本不变,**永不字符切片**。
+   * @param {number} keepBudget 保留内容的目标字符数(不含待写入余量)
+   * @returns {Promise<{ok:boolean,reason?:string}|'not-anchored'>}
    */
-  async compactAnchoredLayer(store, filePath, layer, today, paths) {
+  async compactAnchoredLayer(store, filePath, layer, today, paths, deficit, agent, allowFold) {
     const cur = await this.readTextSafe(filePath)
-    if (!cur || !cur.trim()) return false
+    if (!cur || !cur.trim()) return { ok: true, reason: 'empty' }
     let parsed
     try { parsed = parseAnchors(Buffer.from(cur, 'utf8')) } catch (_) { return 'not-anchored' }
-    if (!parsed || parsed.status !== 'clean') return false // 脏文件 fail closed:不压缩、不切片
+    if (!parsed || parsed.status !== 'clean') return { ok: false, reason: 'dirty-file' }
     const anchored = parsed.records.filter((r) => r.kind === 'anchored')
     if (!anchored.length) return 'not-anchored'
-    const limit = layer === 'user' ? 4000 : 3000
-    const isTodayHeading = (heading) => /^\d{4}-\d{2}-\d{2}/.test(String(heading || '')) && String(heading).slice(0, 10) === today
     const buf = Buffer.from(cur, 'utf8')
-    // 配额从尾回溯(F1):新的留;今天记录无条件保留
-    const keep = new Array(anchored.length).fill(false)
-    let keptBytes = 0
+    // 单位统一:一律换算成**字符**(spanChars);byte 区间仍保留,供切片与归档使用。
+    const spanCharsOf = (r) => buf.slice(r.markerByteStart, r.byteEnd).toString('utf8').length
+    // 目标改成**缺口制**:从最旧开始回收,直到腾出的字符数 ≥ deficit(而不是"把保留量压到某个绝对值以下")。
+    // 保护窗口(最近 COMPACT_PROTECT_RECENT_CHARS 字符)是**软**下限:窗口外不够腾时才向内侵占;
+    // 唯一硬底线是"最新 1 条永不整条移除"。
+    const protectBudget = COMPACT_PROTECT_RECENT_CHARS
+    let tailKept = 0
+    let protectFrom = 0
     for (let i = anchored.length - 1; i >= 0; i--) {
-      const rec = anchored[i]
-      const spanBytes = rec.byteEnd - rec.markerByteStart
-      if (isTodayHeading(rec.heading) || keptBytes + spanBytes <= limit) { keep[i] = true; keptBytes += spanBytes }
+      tailKept += spanCharsOf(anchored[i])
+      protectFrom = i
+      if (tailKept >= protectBudget) break
     }
-    const removedIdx = []
-    anchored.forEach((rec, i) => { if (!keep[i]) removedIdx.push(i) })
-    if (!removedIdx.length) return false // 无可移除 → 无法腾位(预算照常拒绝)
-    // 有序块重组:legacy 块与 preamble/tail 原样保留,gap 字节逐段拷贝,仅丢弃被移除记录的 [marker..contentEnd]
-    const blocks = []
-    for (const r of parsed.records) {
-      if (r.kind === 'anchored') blocks.push({ start: r.markerByteStart, end: r.byteEnd, keep: keep[anchored.indexOf(r)] })
-      else blocks.push({ start: r.byteStart, end: r.byteEnd, keep: true })
+    if (protectFrom > anchored.length - 1) protectFrom = anchored.length - 1
+    const keep = new Array(anchored.length).fill(true)
+    let removed = 0
+    let cutIdx = -1
+    for (let i = 0; i < protectFrom; i++) {
+      removed += spanCharsOf(anchored[i]); cutIdx = i
+      if (removed >= deficit) break
     }
-    blocks.sort((a, b) => a.start - b.start)
-    const parts = []
-    let cursorB = 0
-    for (let i = 0; i < blocks.length; i++) {
-      const b = blocks[i]
-      if (b.start > cursorB) parts.push(buf.slice(cursorB, b.start).toString('utf8'))
-      if (b.keep) parts.push(buf.slice(b.start, b.end).toString('utf8'))
-      cursorB = b.end
+    if (removed < deficit) { // 保护窗口外不够 → 侵入保护窗口(仍保留最新 1 条)
+      for (let i = protectFrom; i < anchored.length - 1; i++) {
+        removed += spanCharsOf(anchored[i]); cutIdx = i
+        if (removed >= deficit) break
+      }
     }
-    if (cursorB < buf.length) parts.push(buf.slice(cursorB).toString('utf8'))
-    const newText = parts.join('')
-    // 归档:整条原文(writeFullRaw 绕开 anchor 事务;归档文件从不参与解析/索引)
+    if (cutIdx < 0 || removed < deficit) return { ok: false, reason: 'no-removable' } // 受硬底线所限无法腾够
+    for (let i = 0; i <= cutIdx; i++) keep[i] = false
+    const removedIdx = []
+    for (let i = 0; i <= cutIdx; i++) removedIdx.push(i)
+    const removedSet = new Set(removedIdx)
+
+    // 归档:被回收记录的整条原文(两种回收方式都归档,保底不丢)
     const archiveFile = layer === 'user'
       ? path.join(dshHome(), 'memory', 'archived-user.md')
       : path.join(paths.projectDir, 'archive', 'notes-archived.md')
@@ -3013,93 +3425,46 @@ class MemoryEngine {
     }).join('\n')
     const existingArchive = await this.readTextSafe(archiveFile)
     await this.writeFullRaw(archiveFile, (existingArchive ? existingArchive.replace(/\s+$/, '') + '\n' : '') + archiveText + '\n')
-    const rr = await store.replace(filePath, newText)
-    if (!rr.ok) { console.error('[compacted-anchored] replace failed: ' + rr.reason); return false }
-    const freshText = await this.readTextSafe(filePath)
-    if (layer === 'user') this.state.userText = freshText
-    else this.state.notesText = freshText
-    if (this._budgets) {
-      const b = this._budgets.get('today')
-      if (b && b.date === this.memToday()) b[layer] = 0
-    }
-    this._lastCompactAt = Date.now()
-    this.state.loadedAt = Date.now()
-    console.log('[compacted-anchored] ' + layer + ': kept=' + (anchored.length - removedIdx.length) + '/' + anchored.length + ' archived=' + removedIdx.length + ' bytes=' + cur.length + '->' + newText.length)
-    return true
-  }
 
-  /**
-   * F1(M6-CONTRACT 外补丁,2026-08-23):anchor 开启时的记录级压缩。
-   * 按 sidecar 记录序整条保留/移除——今天(标题日期=插件今天)记录无条件保留,其余按字节配额
-   * 从最新往回保留(layer 上限 user 4000/note 3000);被移除记录整条原文写入归档文件
-   * (writeFullRaw,不经 anchor 事务,归档非检索语料)。重组经 store.replace 原子执行:
-   * 候选预检(clean)→被移除 id 自动删除→保留 id/版本不变。永不字符切片。
-   * @returns {Promise<boolean|'not-anchored'>} true=已腾位 false=无法腾位 'not-anchored'=无 sidecar 走旧路径
-   */
-  async compactAnchoredLayer(store, filePath, layer, today, paths) {
-    const cur = await this.readTextSafe(filePath)
-    if (!cur || !cur.trim()) return false
-    let parsed
-    try { parsed = parseAnchors(Buffer.from(cur, 'utf8')) } catch (_) { return 'not-anchored' }
-    if (!parsed || parsed.status !== 'clean') return false // 脏文件 fail closed:不压缩、不切片
-    const anchored = parsed.records.filter((r) => r.kind === 'anchored')
-    if (!anchored.length) return 'not-anchored'
-    const limit = layer === 'user' ? 4000 : 3000
-    const isTodayHeading = (heading) => /^\d{4}-\d{2}-\d{2}/.test(String(heading || '')) && String(heading).slice(0, 10) === today
-    const buf = Buffer.from(cur, 'utf8')
-    // 配额从尾回溯(F1):新的留;今天记录无条件保留
-    const keep = new Array(anchored.length).fill(false)
-    let keptBytes = 0
-    for (let i = anchored.length - 1; i >= 0; i--) {
-      const rec = anchored[i]
-      const spanBytes = rec.byteEnd - rec.markerByteStart
-      if (isTodayHeading(rec.heading) || keptBytes + spanBytes <= limit) { keep[i] = true; keptBytes += spanBytes }
-    }
-    const removedIdx = []
-    anchored.forEach((rec, i) => { if (!keep[i]) removedIdx.push(i) })
-    if (!removedIdx.length) return false // 无可移除 → 无法腾位(预算照常拒绝)
-    // 有序块重组:legacy 块与 preamble/tail 原样保留,gap 字节逐段拷贝,仅丢弃被移除记录的 [marker..contentEnd]
+    // 优先折叠成要点;AI 不可用则整条移除(原文已进归档)
+    let folded = allowFold ? await this.foldTextToSummaryPre(archiveText, layer, agent) : ''
+    // 护栏:折叠产物若比"腾出来的空间减缺口"还大,写回去仍会超容量 → 退回整条归档(不写折叠块)。
+    if (folded && folded.length > Math.max(0, removed - deficit)) folded = ''
+    const foldedBlock = folded ? ('## 重组织要点(整理于 ' + today + ')\n' + folded + '\n') : ''
+
+    // 有序重组:legacy 块与 preamble/tail 原样保留;被移除记录处仅在**首个**移除位插入折叠要点
     const blocks = []
     for (const r of parsed.records) {
-      if (r.kind === 'anchored') blocks.push({ start: r.markerByteStart, end: r.byteEnd, keep: keep[anchored.indexOf(r)] })
-      else blocks.push({ start: r.byteStart, end: r.byteEnd, keep: true })
+      if (r.kind === 'anchored') blocks.push({ start: r.markerByteStart, end: r.byteEnd, keep: keep[anchored.indexOf(r)], anchoredIdx: anchored.indexOf(r) })
+      else blocks.push({ start: r.byteStart, end: r.byteEnd, keep: true, anchoredIdx: -1 })
     }
     blocks.sort((a, b) => a.start - b.start)
     const parts = []
     let cursorB = 0
-    for (let i = 0; i < blocks.length; i++) {
-      const b = blocks[i]
+    let injected = false
+    for (const b of blocks) {
       if (b.start > cursorB) parts.push(buf.slice(cursorB, b.start).toString('utf8'))
       if (b.keep) parts.push(buf.slice(b.start, b.end).toString('utf8'))
+      else if (!injected && b.anchoredIdx >= 0) { injected = true; if (foldedBlock) parts.push(foldedBlock) }
       cursorB = b.end
     }
     if (cursorB < buf.length) parts.push(buf.slice(cursorB).toString('utf8'))
     const newText = parts.join('')
-    // 归档:整条原文(writeFullRaw 绕开 anchor 事务;归档文件从不参与解析/索引)
-    const archiveFile = layer === 'user'
-      ? path.join(dshHome(), 'memory', 'archived-user.md')
-      : path.join(paths.projectDir, 'archive', 'notes-archived.md')
-    const archiveText = removedIdx.map((i2) => {
-      const r = anchored[i2]
-      return buf.slice(r.markerByteStart, r.byteEnd).toString('utf8')
-    }).join('\n')
-    const existingArchive = await this.readTextSafe(archiveFile)
-    await this.writeFullRaw(archiveFile, (existingArchive ? existingArchive.replace(/\s+$/, '') + '\n' : '') + archiveText + '\n')
+
     const rr = await store.replace(filePath, newText)
-    if (!rr.ok) { console.error('[compacted-anchored] replace failed: ' + rr.reason); return false }
+    if (!rr.ok) { console.error('[compacted-anchored] replace failed: ' + rr.reason); return { ok: false, reason: 'replace-failed:' + rr.reason } }
     const freshText = await this.readTextSafe(filePath)
     if (layer === 'user') this.state.userText = freshText
     else this.state.notesText = freshText
-    if (this._budgets) {
-      const b = this._budgets.get('today')
-      if (b && b.date === this.memToday()) b[layer] = 0
-    }
-    this._lastCompactAt = Date.now()
+    this._lastCompactAt[layer] = Date.now()
     this.state.loadedAt = Date.now()
-    console.log('[compacted-anchored] ' + layer + ': kept=' + (anchored.length - removedIdx.length) + '/' + anchored.length + ' archived=' + removedIdx.length + ' bytes=' + cur.length + '->' + newText.length)
-    return true
+    console.log('[compacted-anchored] ' + layer + ': kept=' + (anchored.length - removedIdx.length) + '/' + anchored.length
+      + ' reclaimed=' + removedIdx.length + ' folded=' + (folded ? 'yes' : 'no')
+      + ' chars=' + cur.length + '->' + newText.length + ' deficit=' + deficit)
+    return { ok: true, reason: folded ? 'folded' : 'archived' }
   }
 
+
   // ---------- 注入渲染(同步,基于缓存) ----------
   // 动态记忆 → ctx.systemPrompt.context()(user-role 快照):内容变化才追加新快照,内容不变不重复注入(dsh-agent-loop project() 去重),
   // system prompt 不再包含动态内容 → 字节级稳定 → DeepSeek 前缀缓存全程命中(对比 section 方案:动态内容任何变化都从变化点起击穿整个前缀,含全部历史)
@@ -3215,7 +3580,7 @@ class MemoryEngine {
     lines.push('- progress 与 memory 一起写:写日志的同时,把有跨会话长期价值的内容一并写入记忆——跨项目规则 → memory_user,仅本项目 → memory_note;两者在同一轮完成,互不冲突、不遗漏。')
     lines.push('- **交接与白板(长任务续命)**:阶段产出或方向变化时,调用 memory_note(kind=handoff) 写四段式交接账本——任务状态/目标/已试方案与失败原因/进度与下一步,给下一个上下文窗口续命;对项目全貌的理解发生实质变化时,用 memory_note(kind=plan) 重写白板 PLAN.md(人能读的项目规划图,旧版自动归档,用户在面板实时可见)。账本质量纪律:每段 ≤5 行;失败项写成「方案→失败原因」并保留关键报错词;下一步必须是可直接执行的第一步(带文件路径或命令);不写临时信息。两者会注入到你的动态快照首位,是跨窗口交接的凭据。')
     lines.push('- 只记录有跨会话长期价值的;不记临时信息(搜索结果、临时路径、工具报错)。')
-    lines.push('- 每日写入预算(所有会话共享一天额度,跨天自动重置):用户级 ≤4000 字/天、项目笔记 ≤3000 字/天;超限不拒绝——框架自动把"今天之前"的旧内容交给 AI 浓缩成要点腾出空间(10 分钟内只压缩一次),AI 不可用时归档最早段落,信息不丢;每日日志无预算。')
+    lines.push('- 记忆容量(设置项 noteCapacityChars/userCapacityChars,默认各 12000 字符):项目笔记与用户级记忆各有容量上限;超出时框架自动整理——先把较早内容交给 AI 折叠成要点、失败则退回整条归档(原文进 archive,信息不丢),整理后仍超才拒绝写入,所以**新记忆正常不会被堵在外面**。整理同一层 10 分钟内只做一次;每日日志无容量限制。注意这与「注入预算」不同:注入预算管每轮往上下文塞多少摘要,容量上限管文件本体大小。')
     lines.push('- **记忆操作必须在正文可见(摘要链)**:调用 memory_log/note/user/reflect 更新记忆后,必须把结果写进本轮回复的正文文本(用户直接看到的那段文字,不是工具调用区),并在**回复末尾**用加粗或换行使其醒目(如"**已更新今日日志**\n新增:修复了XXX");调用 memory_recall/memory_external 检索时,在正文开头写明"我查了记忆,发现..."。工具返回值只是辅助,正文转述是强制要求。')
     lines.push('- 用户明确要求长期记住:跨项目规则 → memory_user;仅本项目 → memory_note。')
     lines.push('- 定期调用 memory_maintain 做 30 天蒸馏:AI 提炼旧日志要点进项目笔记,原文保底归档;不存密钥,除非用户明确要求。')
@@ -3994,20 +4359,20 @@ class MemoryEngine {
       },
       duplicateHeadings,
       budgets: (() => {
-        const out = []
-        if (this._budgets) {
-          for (const [, b] of this._budgets.entries()) {
-            out.push({
-              scope: 'daily', date: b.date,
-              userUsed: b.user, userLimit: 4000,
-              noteUsed: b.note, noteLimit: 3000,
-              userFileSize: (this.state.userText || '').length,
-              noteFileSize: (this.state.notesText || '').length,
-              lastCompactAt: this._lastCompactAt || 0,
-            })
-          }
-        }
-        return out
+        // 2026-09-10 改为**容量口径**:报的是"文件当前字符数 / 容量上限",不再有"当日已用/字每天"这种记账。
+        const uLim = this.capacityLimit('user')
+        const nLim = this.capacityLimit('note')
+        const uUsed = (this.state.userText || '').length
+        const nUsed = (this.state.notesText || '').length
+        return [{
+          scope: 'capacity',
+          userUsed: uUsed, userLimit: uLim,
+          noteUsed: nUsed, noteLimit: nLim,
+          userFileSize: uUsed,
+          noteFileSize: nUsed,
+          lastCompactAt: (this._lastCompactAt && this._lastCompactAt.note) || 0,
+          lastCompactAtUser: (this._lastCompactAt && this._lastCompactAt.user) || 0,
+        }]
       })(),
       today: todayStr(),
       memoryDate: this.memToday(),
@@ -4390,15 +4755,15 @@ class MemoryEngine {
     let run
     try {
       // prompt 必须是 block 数组(createUserMessage 校验 content.some)
-      const subModel = String(this.config.subagentModel || '').trim()
       this._subagentInflight = (this._subagentInflight || 0) + 1
       run = await subagents.start(providerName, {
         label,
         prompt: [{ type: 'text', text }],
         signal: controller.signal,
         ...(parent ? { parent } : {}),
-        // 设置页「总结/问候默认模型」:非空时覆盖子代理的模型选择(空=跟随路由默认)
-        ...(subModel ? { agentOptions: { model: subModel } } : {}),
+        // 设置页「子代理模型 / 思考强度」:非空时覆盖子代理的模型与推理档位(空=跟随路由默认)。
+        // DSH 0.1.5:两者都经 SubagentStartRequest.agentOptions 下发(provider 侧需 capabilities.agentOptions)。
+        ...(subAgentOptions(this.config) ? { agentOptions: subAgentOptions(this.config) } : {}),
       })
       // 套娃防护(问题②):登记本插件 spawn 的子代理,其生命周期事件在 pre-step/turn-stopping 零处理
       // 2026-09-09 修复:DSH 0.1.2 in-process run 对象字段为 localAgent(旧版为 agent),取两者兼容
@@ -4432,7 +4797,8 @@ class MemoryEngine {
           prompt: [{ type: 'text', text }],
           signal: controller.signal,
           ...(parent ? { parent } : {}),
-          agentOptions: { model: fbModel },
+          // 回退必须显式用 fbModel(而不是设置页的 subagentModel),否则重试等于没换模型;强度沿用配置。
+          agentOptions: subAgentOptions({ ...this.config, subagentModel: fbModel }),
         })
         result = await this.withTimeout(run2.result, tMs, null)
       }
@@ -4785,7 +5151,7 @@ class MemoryEngine {
             this.state.notesText = body
             written += notePts.length
           } else {
-            console.log('[dsh-auto-memory] auto-consolidate: NOTE 超预算且压缩不可用,已跳过')
+            console.log('[dsh-auto-memory] auto-consolidate: NOTE ' + this.budgetRefusalTextPre(r, 'note') + ',已跳过')
           }
         }
         if (userPts.length) {
@@ -4795,7 +5161,7 @@ class MemoryEngine {
             this.state.userText = body
             written += userPts.length
           } else {
-            console.log('[dsh-auto-memory] auto-consolidate: USER 超预算且压缩不可用,已跳过')
+            console.log('[dsh-auto-memory] auto-consolidate: USER ' + this.budgetRefusalTextPre(r, 'user') + ',已跳过')
           }
         }
         if (written) {
@@ -4879,7 +5245,7 @@ class MemoryEngine {
         const body = await this.appendText(p.notesPath, '\n## ' + today + '\n' + projectPts.map((x) => '- ' + x).join('\n'))
         this.state.notesText = body
         written.push('项目笔记 ' + projectPts.length + ' 条')
-      } else skipped.push('项目笔记(预算超限且压缩不可用)')
+      } else skipped.push('项目笔记(' + this.budgetRefusalTextPre(r, 'note') + ')')
     }
     if (userPts.length) {
       const r = await this.ensureBudget(agent, 'user', userPts.map((x) => '- ' + x).join('\n'))
@@ -4887,11 +5253,11 @@ class MemoryEngine {
         const body = await this.appendText(p.userFile, '\n## ' + today + '\n' + userPts.map((x) => '- ' + x).join('\n'))
         this.state.userText = body
         written.push('用户级记忆 ' + userPts.length + ' 条')
-      } else skipped.push('用户级记忆(预算超限且压缩不可用)')
+      } else skipped.push('用户级记忆(' + this.budgetRefusalTextPre(r, 'user') + ')')
     }
     this.state.loadedAt = Date.now()
     if (!written.length) {
-      if (skipped.length) return 'memory_consolidate: AI 已提炼,但今日写入预算已用尽,以下层被跳过(明天再固化): ' + skipped.join('、') + '。'
+      if (skipped.length) return 'memory_consolidate: AI 已提炼,但自动整理未能腾出空间,以下层被跳过: ' + skipped.join('、') + '。'
       return 'memory_consolidate: AI 未提炼出值得长期记录的内容。'
     }
     const detail = []
@@ -6332,7 +6698,10 @@ export function apply(ctx, config) {
   try { ctx.on('dispose', () => { engine._disposed = true }) } catch (eDispose) {}
   // 时间检测用的服务(软获取,缺失时定时兜底自动降级)
   engine._sessionsSvc = ctx.get('sessions') || undefined
-  engine._agentSvc = ctx.get('agent') || undefined
+  // DSH 0.1.5 破坏性变更:单数服务键 'agent' 已移除,Agent 注册表改名为 'agents'(AgentRegistry)。
+  // 旧写法让 _agentSvc 恒 undefined → restoreLastAgent 永久失效(实测每 tick 刷 "svc missing ... agent=false")。
+  // 先取新键,保留旧键兜底以兼容 0.1.4 及更早版本。
+  engine._agentSvc = ctx.get('agents') || ctx.get('agent') || undefined
   // 模型目录(设置页「总结/问候默认模型」抽屉数据源);软获取,缺失时抽屉回退手动输入
   engine._llm = ctx.get('llm') || undefined
   // 工作区注册表(修A,2026-09-08):接续时解析旧会话所属 workspaceId——官方 create 只在传 workspaceId 时绑定工作区
@@ -6575,7 +6944,7 @@ export function apply(ctx, config) {
       return '已更新记忆文档: ' + logPath + '\n' + entry + (gate.truncated ? '\n(内容超长,已截断)' : '')
     }),
 
-    defineTool('memory_note', '更新当前项目长期笔记 .dsh-memory/MEMORY.md(本项目专属的约定、决策、架构要点),或写交接白板。kind=note(默认):action=append 追加一段(自动带日期标题)/action=replace 整体替换(需先基于注入内容或 memory_recall 结果给出完整新内容),每日预算 3000 字/天,超限自动压缩旧内容腾空间(不拒绝写入)。kind=handoff:写一篇四段式交接账本(任务状态/目标/已试方案与失败原因/进度与下一步)到 handoff/,阶段产出或方向变化时用,给下一个上下文窗口续命。kind=plan:整体重写白板 PLAN.md(人能读的项目全貌规划图),对项目全貌的理解发生实质变化时用,旧版自动归档。**调用后必须在本轮回复正文中向用户转述:更新了什么**。', {
+    defineTool('memory_note', '更新当前项目长期笔记 .dsh-memory/MEMORY.md(本项目专属的约定、决策、架构要点),或写交接白板。kind=note(默认):action=append 追加一段(自动带日期标题)/action=replace 整体替换(需先基于注入内容或 memory_recall 结果给出完整新内容),本项目笔记有**容量上限**(字符,设置项 noteCapacityChars,默认 12000);超出时自动整理——先把较早内容交给 AI 折叠成要点、失败则退回整条归档(原文都进 archive,不丢),整理后仍超才拒绝(正常不会发生)。kind=handoff:写一篇四段式交接账本(任务状态/目标/已试方案与失败原因/进度与下一步)到 handoff/,阶段产出或方向变化时用,给下一个上下文窗口续命。kind=plan:整体重写白板 PLAN.md(人能读的项目全貌规划图),对项目全貌的理解发生实质变化时用,旧版自动归档。**调用后必须在本轮回复正文中向用户转述:更新了什么**。', {
       content: { type: 'string', required: true, description: '笔记内容。kind=plan 时给完整新全貌(不是增量)。' },
       action: { type: 'string', enum: ['append', 'replace'], description: '仅 kind=note 时有效:append=追加, replace=整体替换。' },
       kind: { type: 'string', enum: ['note', 'handoff', 'plan'], description: 'note=项目笔记(默认), handoff=四段式交接账本(新篇), plan=白板全貌重写。' },
@@ -6608,7 +6977,7 @@ export function apply(ctx, config) {
         if (tailHas(existing, write)) return 'memory_note: 与笔记尾部已有内容重复,拒绝写入(复读防护)。'
       }
       const acct = await engine.ensureBudget(exec.agent, 'note', write)
-      if (!acct.ok) return 'memory_note: 项目笔记今日预算已用尽(上限 ' + acct.acct.limit + ' 字/天)且自动压缩不可用(刚压缩过或 AI 不可用),本次未写入。可稍后再试或调用 memory_maintain 整理。'
+      if (!acct.ok) return 'memory_note: ' + engine.budgetRefusalTextPre(acct, 'note') + ' 本次未写入(原内容未改动)。'
       let body
       if (replace) {
         body = write
@@ -6620,7 +6989,7 @@ export function apply(ctx, config) {
       return '已更新项目笔记: ' + p.notesPath + '\n追加内容:\n' + write + (gate.truncated ? '\n(内容超长,已截断到 ' + write.length + ' 字符)' : '') + (acct.compacted ? '\n(已自动压缩旧内容腾出空间)' : '')
     }),
 
-    defineTool('memory_user', '更新用户级记忆 ~/.dsh/memory/MEMORY.md(跨所有项目的长期规则/偏好,用户明确要求记住时用)。action=append 追加;action=replace 整体替换。每日预算 4000 字/天,超限自动压缩旧内容腾空间(不拒绝写入)。**调用后必须在本轮回复正文中向用户转述:已记住该规则/偏好**。', {
+    defineTool('memory_user', '更新用户级记忆 ~/.dsh/memory/MEMORY.md(跨所有项目的长期规则/偏好,用户明确要求记住时用)。action=append 追加;action=replace 整体替换。有**容量上限**(字符,设置项 userCapacityChars,默认 12000);超出时自动整理——先把较早内容交给 AI 折叠成要点、失败则退回整条归档(原文都进 archive,不丢),整理后仍超才拒绝(正常不会发生)。**调用后必须在本轮回复正文中向用户转述:已记住该规则/偏好**。', {
       content: { type: 'string', required: true, description: '要记住的规则或偏好内容。' },
       action: { type: 'string', enum: ['append', 'replace'], required: true, description: 'append=追加, replace=整体替换。' },
     }, async (args, exec) => {
@@ -6637,7 +7006,7 @@ export function apply(ctx, config) {
         if (tailHas(existing, write)) return 'memory_user: 与用户级记忆尾部已有内容重复,拒绝写入(复读防护)。'
       }
       const acct = await engine.ensureBudget(exec.agent, 'user', write)
-      if (!acct.ok) return 'memory_user: 用户级记忆今日预算已用尽(上限 ' + acct.acct.limit + ' 字/天)且自动压缩不可用(刚压缩过或 AI 不可用),本次未写入。可稍后再试或调用 memory_maintain 整理。'
+      if (!acct.ok) return 'memory_user: ' + engine.budgetRefusalTextPre(acct, 'user') + ' 本次未写入(原内容未改动)。'
       let body
       if (replace) {
         body = write
@@ -6894,18 +7263,44 @@ export function apply(ctx, config) {
         if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
         if ((req.method || 'POST') !== 'POST') return writeJson(res, 405, { error: 'method not allowed' })
         try {
-          const r = await engine.buildContinueCarry()
+          // fromSessionId(2026-09-10):client 侧知道自己在续哪个会话,显式传进来,避免材料包取错会话。
+          const body = await readJsonBody(req).catch(() => ({}))
+          const r = await engine.buildContinueCarry((body && body.fromSessionId) || '')
           return writeJson(res, r.ok ? 200 : 400, r)
         } catch (e) { return writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
       },
     },
+    {
+      kind: 'exact',
+      path: API['handoff-permission'],
+      handler: async (req, res) => {
+        // 一键接续(client 路径)的权限继承(POST;loopback):官方 session.create 不收权限字段,
+        // 新会话必落 settings 的 permission.defaultPreset → 接续后每一步都要用户批准(静默运行被打断)。
+        // 由 client 在建好新会话后回调本端点,宿主侧把旧会话的预设套到新会话上(fail-soft)。
+        if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
+        if ((req.method || 'POST') !== 'POST') return writeJson(res, 405, { error: 'method not allowed' })
+        try {
+          const body = await readJsonBody(req).catch(() => ({}))
+          const r = await engine.inheritPermissionForContinue(body && body.fromSessionId, body && body.toSessionId, { attempts: (body && body.attempts) || undefined })
+          // 落闩(2026-09-10):本端点由 client 在建好新会话后回调,带两个 sid → 正是「接续已发生」的事实点。
+          // 放在这里而不是 handoff-continue(取材料,可能只是预览)是为了只在**真建成**时才关掉旧会话的自动接续。
+          if (body && body.fromSessionId && body.toSessionId) {
+            try { engine.markContinuedSession(body.fromSessionId, body.toSessionId) } catch (eL) {}
+          }
+          return writeJson(res, 200, r || { ok: false, reason: 'no result' })
+        } catch (e) { return writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
+      },
+    },
     {
       kind: 'exact',
       path: API['auto-continue-state'],
       handler: async (req, res) => {
         // M-CM6-C·宿主兜底状态(GET;loopback):浏览器 AutoContinueHost 轮询此端点展示确认卡/倒计时/执行结果。
         if (!isLoopbackRequest(req)) return writeJson(res, 403, { error: 'forbidden: loopback-only' })
-        try { return writeJson(res, 200, engine.autoContinueState()) } catch (e) { return writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
+        try {
+          const url = new URL(req.url, 'http://127.0.0.1')
+          return writeJson(res, 200, engine.autoContinueState(url.searchParams.get('sessionId')))
+        } catch (e) { return writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
       },
     },
     {