@a9i5k4/dsh-auto-memory 2.2.4 → 2.2.6

package/README.md

@@ -1,7 +1,9 @@
-# dsh-auto-memory — She remembers, unbidden · 无问自忆
+# 无问自忆 · 记忆不断线
+
+**dsh-auto-memory** — *She remembers, unbidden.*
 
 > **EN** Now, across windows, too. Context that survives windows, sessions, and tools
-> **中文** 无问自忆——该想起的，自己浮现。跨窗口 · 跨会话 · 跨工具，记忆不断线
+> **中文** 该想起的，自己浮现。跨窗口 · 跨会话 · 跨工具，记忆不断线
 
 <p align="center">
   <a href="https://htmlpreview.github.io/?https://github.com/Aik358/dsh-auto-memory/blob/preview/docs/landing/index.html"><strong>🌐 Landing page (full feature tour · data flow · papers · screenshots)</strong></a>

package/README.zh-CN.md

@@ -1,4 +1,6 @@
-# dsh-auto-memory — 无问自忆 · She remembers, unbidden
+# 无问自忆 · 记忆不断线
+
+**dsh-auto-memory** — *She remembers, unbidden.*
 
 > **中文** 现在，换窗口也不必。跨窗口 · 跨会话 · 跨工具，记忆不断线
 > **EN** She remembers, unbidden — now, across windows, too. Context that survives windows, sessions, and tools

package/docs/USER-GUIDE.zh-CN.md

@@ -32,6 +32,8 @@
 - **装完必须重启 dsh web**:插件的注入面(manifest)在启动时加载;改完 host 代码同理。
 - 浏览器端更新后需**硬刷新**(Ctrl+Shift+R)才会加载新 client.js。
 - 入口:左侧栏底部 **记忆** 按钮 → 记忆面板,含页签 **概览 / 白板 / 语料精修 / 设置**。
+- 面板标题栏:**图钉**(线描图标,与 ⟳ ⤾ ✕ 同画风;点一下钉住后,点桌面其他地方不会自动收起,再点取消;钉住状态会记住)、⤾ 恢复默认位置、⟳ 刷新、✕ 关闭。未钉住时点击面板外或按 Esc 即收起。
+- 面板标题里的版本号与 设置 →「检查更新」显示的都是**当前安装的版本**,与 npm 上的一致(发布时自动同步)。
 - 数据全在本机:`~/.dsh/memory/`(记忆文件)、`~/.dsh/dsh-auto-memory-pre.json`(配置,发布版为 `dsh-auto-memory.json`)。
 
 ## 2. 第一次启动
@@ -132,7 +134,7 @@
 | 白板注入预算(handoffPlanChars) | 1200 | 字符硬截断 |
 | 账本注入预算(handoffLedgerChars) | 800 | 字符硬截断 |
 | 水位窗口覆盖(waterLevelWindowTokens) | 0=自动 | 0 表示自动:优先官方路由容量,其次按当前模型查 settings.yaml。**除非特殊模型,保持 0** |
-| 水位阈值(waterLevelThreshold) | 0.8 | 越阈值即注入交接建议并自动补写账本 |
+| 水位阈值(waterLevelThreshold) | 0.75 | 越阈值即注入交接建议并自动补写账本。**默认 0.75 而非 0.8**:官方自动压缩阈值是 80%,阈值贴着 80% 常被官方先压缩掉,留 5% 余量(1M 窗口约 50K token)才来得及走完交接 |
 | 水位建议注入(waterLevelAdvisory) | 开 | 无人值守时静默 |
 | 越阈值自动写账本(waterLevelAutoHandoff) | 开 | 每会话一次,给 AI 一个骨架,正式账本仍由 AI 写 |
 | **子代理痕迹回收**(subagentGcEnabled) | 开 | 见 §4.5 |
@@ -157,11 +159,15 @@
 记忆面板 → 白板页签顶部显示:**已用 token / 窗口 token · 百分比**,后面标注两个来源:
 
 - **计量**:`官方计量(usage)` = 与聊天框 context ring 同源(token-meter 的 `totalTokens`,即**当前上下文占用**);不可用时降级为启发式估算。
-- **窗口**:`官方路由容量` = 取自会话日志 `request/context` 的 `contextWindow`(最权威);`自动检测: provider/model` = 按当前模型查 `settings.yaml` 的 `contextWindow`;`回退默认值` = 前两条都拿不到时的保守值(128K)——看到这个标签说明模型窗口没识别出来,可到设置页手动填 `waterLevelWindowTokens`。
+- **窗口**:`官方路由容量` = 取自会话日志 `request/context` 的 `contextWindow`(最权威);`自动检测: provider/model` = 按**当前会话真实使用的模型**(会话日志 `request/header` 的 provider/model)查 `settings.yaml` 的 `contextWindow`,查不到才回退到 `agent-default-model`(新会话默认模型);`回退默认值` = 前两条都拿不到时的保守值(128K)——看到这个标签说明模型窗口没识别出来,可到设置页手动填 `waterLevelWindowTokens`。
+  > 你在这里看到的模型名是**这个会话正在用的模型**,不是设置里的默认模型;两者不一致时以会话为准(2026-09-08 修正,此前一律显示默认模型)。
+  > 卡片是**按会话**的:切换会话会自动换成该会话的数;该会话还没有实测数据(刚重启、或刚切过来还没发消息)时会标注「本会话尚未测量」,同时先把窗口与模型从该会话日志里推出来。
 
 达到阈值后:AI 收到交接建议,并自动补写一篇骨架账本(正式账本仍由 AI 写)。
 
 > **2.2.4 修复**:此前窗口解析有两条路同时失效(settings.yaml 的 flow 风格 YAML 解析不出、官方 contextWindow 事件只在会话开头出现而旧代码只扫最近 256 条),导致 1M 窗口被当成 128K、水位虚高显示 150%+。现已修复并如实标注来源。
+>
+> **比例如实上报**:旧版还把百分比硬截断到 150%,任何超额都显示成同一个数(例如 761,692 / 131,072 真实为 581%,却显示 150%)。现在显示真实百分比,进度条仍按 100% 封顶。注意:宿主代码不会热重载,**升级后必须重启 dsh web**(浏览器再 Ctrl+Shift+R),否则读到的仍是旧窗口解析。
 
 ### 4.2 交接白板
 
@@ -190,7 +196,7 @@
 
 ### 4.4 自动接续(免按钮,推荐)
 
-白板页签 →「自动接续」卡片:开关(默认开)+ 阈值(默认 0.8)。
+白板页签 →「自动接续」卡片:开关(默认开)+ 阈值(默认 0.75,与水位阈值同步;官方自动压缩阈值是 80%,低于它才有意义)。
 
 - **触发条件**:水位 ≥ 阈值 **且** harness 权威 `running` 位在轮次边界转为 `false`(会话真的空闲了)。长工具调用不会误触发。
 - **确认卡三分支**:点「同意接续」= 立即接续;点「拒绝」= 本轮跳过,同一边界不再提示;**30–40 秒无操作** = 视为挂机,自动接续。
@@ -252,7 +258,7 @@ AI 在对话中可直接调用(你不需要记,但了解一下有好处):
 
 | 现象 | 处理 |
 |---|---|
-| 水位显示 `xxx / 131,072 token · 150%` 之类 | 2.2.4 已修复(窗口解析两条路都失效);升级后重启 dsh web + 硬刷新。若标签仍显示「回退默认值」,说明该模型不在 settings.yaml 里,手动填 `waterLevelWindowTokens` |
+| 水位显示 `xxx / 131,072 token · 150%` 之类 | ①先确认**宿主已重启**(host 代码不热重载,只刷新页面没用)②窗口解析已在 2.2.4 修复;若标签仍是「回退默认值」,说明该模型不在 settings.yaml 里,手动填 `waterLevelWindowTokens` ③百分比已不再截断到 150%(旧版任何超额都显示 150%,真实值可能是 581%),进度条仍按 100% 封顶 |
 | 提示「词法兜底 / 未就绪」 | 设置 → 自动记忆引擎 → ⟳ 检测,按引导下载 JS 模型或装 Python |
 | 一键接续报「harness 未提供 remote.session」 | 重启 dsh web(注入面需重启加载);仍不行检查版本 ≥ 2.2.2 |
 | 新会话落到「未分组工作区」/ 没沿用模型与思考档位 | 2.2.4 已修复(create 传 workspaceId、模型取自 request/header);升级后需**重启 dsh web + 硬刷新页面** |

package/lib/client.js

@@ -25,6 +25,10 @@ window.__ModuleLoader__.load({
     var panelOpen = false
     var panelClosing = false
     var closeTimer = null
+    // 悬浮钉(2026-09-08):钉住后点击面板外不再自动收起,适合边看记忆边操作桌面
+    var PIN_KEY = 'dsh-auto-memory.panel.pinned'
+    var pinned = false
+    try { pinned = localStorage.getItem(PIN_KEY) === '1' } catch (ePin) {}
     // 几何状态:left/top/width/height,持久化到 localStorage(用户可拖动/缩放)
     var GEOM_KEY = 'dsh-auto-memory.panel.geom'
     var DEFAULT_W = 440
@@ -133,6 +137,12 @@ window.__ModuleLoader__.load({
         }, 170)
       },
       subscribe: function (fn) { listeners.add(fn); return function () { listeners.delete(fn) } },
+      isPinned: function () { return pinned },
+      togglePin: function () {
+        pinned = !pinned
+        try { localStorage.setItem(PIN_KEY, pinned ? '1' : '0') } catch (e) {}
+        emit()
+      },
     }
 
     // ───────────────────────── 国际化 ─────────────────────────
@@ -194,7 +204,7 @@ window.__ModuleLoader__.load({
         kvMem: '记忆文件', kvMemUser: '用户', kvMemNotes: '笔记', kvMemLog: '日志', kvMemMissing: '缺失',
         kvWs: '当前工作区', kvWsUnknown: '(未取到)', kvApi: 'API 连通', unknown: '(未知)',
         updateTitle: 'dsh-auto-memory 已更新', updateSub: '本次更新内容:', gotIt: '知道了', noticeOpen: '了解更多',
-        refresh: '刷新', refreshing: '刷新中…', close: '关闭', dragMove: '拖动移动', dragResize: '拖动调整大小', resetPos: '恢复默认位置',
+        refresh: '刷新', refreshing: '刷新中…', close: '关闭', dragMove: '拖动移动', dragResize: '拖动调整大小', resetPos: '恢复默认位置', pinPanel: '钉住面板(点桌面其他地方不收起)', unpinPanel: '取消钉住(点面板外自动收起)',
         generated: '已生成', failed: '失败: ',
         generatedAt: '生成于 ',
         pointsCount: ' 项', summarizing: 'AI 总结生成中…', summaryFailed: 'AI 总结生成失败,点 ⟳ 重试',
@@ -262,7 +272,7 @@ window.__ModuleLoader__.load({
         fWaterWindow: '水位估计窗口(token)', fWaterWindowHint: '会话消息按官方公式(4 字符≈1 token)估算达到该值即视为上下文将满;0=关闭。默认 65536(128K 窗口的保守半量),按所用模型调整。',
         fWaterAdvisory: '水位交接建议', fWaterAdvisoryHint: '水位越阈时在动态快照注入交接建议(写账本/刷新白板/建议开新窗);无人值守时静默。',
         fWaterAuto: '水位自动骨架账本', fWaterAutoHint: '越阈时自动写一篇系统骨架账本(每会话一次),防止模型忽视建议时交接材料缺失。',
-        fWaterThreshold: '水位建议阈值', fWaterThresholdHint: '水位比例超过该值(0.1-1.5)即触发交接建议/骨架账本;默认 0.8。',
+        fWaterThreshold: '水位建议阈值', fWaterThresholdHint: '水位比例超过该值(0.1-1.5)即触发交接建议/骨架账本;默认 0.75——官方自动压缩阈值是 80%,必须留出余量才来得及走完交接。',
         fHandoffPlan: '白板注入预算(字符)', fHandoffPlanHint: 'PLAN.md 全貌注入动态快照的硬截断预算;全文可经 memory_read 或面板白板页查看。默认 1200。',
         fHandoffLedger: '账本注入预算(字符)', fHandoffLedgerHint: '最新一篇交接账本注入动态快照的硬截断预算。默认 800。',
         fConsSchedule: '定时做梦式固化', fConsScheduleHint: '每天到点自动读最近日志发散提炼长期要点,写入项目笔记/用户级记忆(等价 memory_consolidate)。',
@@ -270,7 +280,7 @@ window.__ModuleLoader__.load({
         fConsScheduleDays: '固化回看天数', fConsScheduleDaysHint: '定时固化读取最近 N 天日志;默认 7。',
         fMaintSchedule: '定时 30 天蒸馏', fMaintScheduleHint: '每天到点自动把超过 30 天的旧日志蒸馏归档(等价 memory_maintain);无旧日志时零成本跳过。',
         fMaintScheduleTime: '蒸馏触发时间', fMaintScheduleTimeHint: 'HH:MM,默认 10:00(与固化时间错开)。',
-        waterCardTitle: '上下文水位', waterAutoSrc: '自动检测', waterManualSrc: '手动设定', waterOfficialSrc: '官方路由容量', waterFallbackSrc: '回退默认值', waterMeterOfficial: '官方计量', waterMeterHeuristic: '启发式降级', waterThresholdHint: '水位达到 {t} 时注入交接建议并自动补写账本;计量优先用官方 token-meter(与聊天框 context ring 同源),不可用时降级启发式估算;窗口优先取官方路由容量(request/context 的 contextWindow),其次按当前模型查 settings.yaml contextWindow,也可在下方手动覆盖。',
+        waterCardTitle: '上下文水位', waterAutoSrc: '自动检测', waterManualSrc: '手动设定', waterOfficialSrc: '官方路由容量', waterFallbackSrc: '回退默认值', waterNotMeasured: '本会话尚未测量(发送一轮后自动更新)', waterMeterOfficial: '官方计量', waterMeterHeuristic: '启发式降级', waterThresholdHint: '水位达到 {t} 时注入交接建议并自动补写账本;计量优先用官方 token-meter(与聊天框 context ring 同源),不可用时降级启发式估算;窗口优先取官方路由容量(request/context 的 contextWindow),其次按当前模型查 settings.yaml contextWindow,也可在下方手动覆盖。',
         autoContTitle: '自动接续', autoContHint: '开启后:水位达到阈值、且旧会话已空闲(harness 权威 running 位在轮次边界转为 false,取代旧「两轮水位持平」)时,弹出确认卡——同意=立即接续,拒绝=本轮跳过(同一边界不再提示),30-40 秒无操作视为挂机自动接续;接续前先让旧 Agent 刷新白板 PLAN 与交接账本,再建新会话(沿用工作区/模型/思考档位)并注入分层交接材料;触发后默认 30 分钟内不重复。', autoContOn: '自动接续:开', autoContOff: '自动接续:关', autoContThreshold: '阈值', autoContCountdown: '⏳ {s} 秒后自动接续…', autoContCancel: '取消', autoContConfirm: '本会话水位已达 {p}%,旧会话已空闲(轮次边界)——现在接续到新会话?', autoContAgree: '同意接续', autoContReject: '拒绝', autoContTimeout: '{s} 秒后自动接续(视为挂机)', autoContRejected: '已跳过本次接续(下一个轮次边界再提醒)',
         continueCardTitle: '一键接续', continueCardHint: '写好交接账本→创建新会话→把交接材料作为首条消息预载,并自动切换到新会话继续任务(接续材料含白板节选+最新账本;当前工作区无账本时自动取全局最近一篇)。', continueBtn: '一键接续到新会话', continueBusy: '处理中…',
         fStyle: '反思风格', fStyleHint: '生活化 / 专业性 / 由内容决定。',
@@ -342,7 +352,7 @@ window.__ModuleLoader__.load({
       kvMem: 'Memory files', kvMemUser: 'user', kvMemNotes: 'notes', kvMemLog: 'log', kvMemMissing: 'missing',
       kvWs: 'Current workspace', kvWsUnknown: '(unknown)', kvApi: 'API probes', unknown: '(unknown)',
       updateTitle: 'dsh-auto-memory Updated', updateSub: 'What\'s new in this update:', gotIt: 'Got it', noticeOpen: 'Learn more',
-        refresh: 'Refresh', refreshing: 'Refreshing…', close: 'Close', dragMove: 'Drag to move', dragResize: 'Drag to resize', resetPos: 'Reset position',
+        refresh: 'Refresh', refreshing: 'Refreshing…', close: 'Close', dragMove: 'Drag to move', dragResize: 'Drag to resize', resetPos: 'Reset position', pinPanel: 'Pin panel (stays open when clicking elsewhere)', unpinPanel: 'Unpin (auto-hide on outside click)',
         generated: 'Generated', failed: 'Failed: ',
         generatedAt: 'Generated ',
         pointsCount: ' items', summarizing: 'AI summary generating…', summaryFailed: 'Summary failed, press refresh to retry',
@@ -410,7 +420,7 @@ window.__ModuleLoader__.load({
         fWaterWindow: 'Water-level window (tokens)', fWaterWindowHint: 'Session messages priced with the official meter (4 chars ≈ 1 token); past this, context is considered nearly full; 0 disables. Default 65536 — a conservative half of a 128K window.',
         fWaterAdvisory: 'Water-level handoff advisory', fWaterAdvisoryHint: 'Injects a handoff advisory past the threshold (write ledger / refresh plan / suggest a new window); silent in unattended mode.',
         fWaterAuto: 'Auto skeleton ledger', fWaterAutoHint: 'Past the threshold, auto-writes one system skeleton ledger per session as a safety net if the model ignores the advisory.',
-        fWaterThreshold: 'Water-level threshold', fWaterThresholdHint: 'Inject the handoff advisory / skeleton ledger once the ratio passes this value (0.1-1.5); default 0.8.',
+        fWaterThreshold: 'Water-level threshold', fWaterThresholdHint: 'Inject the handoff advisory / skeleton ledger once the ratio passes this value (0.1-1.5); default 0.75 — the official auto-compaction threshold is 80%, so a 5% margin is needed to finish the handoff first.',
         fHandoffPlan: 'Plan injection budget (chars)', fHandoffPlanHint: 'Hard truncation budget for injecting the PLAN.md snapshot into the dynamic memory; full text via memory_read or the Whiteboard tab. Default 1200.',
         fHandoffLedger: 'Ledger injection budget (chars)', fHandoffLedgerHint: 'Hard truncation budget for injecting the latest handoff ledger. Default 800.',
         fConsSchedule: 'Scheduled deep consolidation', fConsScheduleHint: 'Once a day at the set time, read recent logs and distill long-term value into project notes / user memory (same flow as memory_consolidate).',
@@ -418,7 +428,7 @@ window.__ModuleLoader__.load({
         fConsScheduleDays: 'Consolidation lookback (days)', fConsScheduleDaysHint: 'How many recent days of logs the scheduled consolidation reads; default 7.',
         fMaintSchedule: 'Scheduled 30-day distill', fMaintScheduleHint: 'Once a day at the set time, distill & archive logs older than 30 days (same flow as memory_maintain); zero cost when nothing to archive.',
         fMaintScheduleTime: 'Distill time', fMaintScheduleTimeHint: 'HH:MM, default 10:00 (staggered from the consolidation time).',
-        waterCardTitle: 'Context water level', waterAutoSrc: 'auto-detected', waterManualSrc: 'manual', waterOfficialSrc: 'route capacity', waterFallbackSrc: 'fallback default', waterMeterOfficial: 'official meter', waterMeterHeuristic: 'heuristic fallback', waterThresholdHint: 'Past {t} of the window, the handoff advisory is injected and the skeleton ledger is backfilled; metering prefers the official token-meter (same source as the chat context ring), falling back to the heuristic when unavailable; the window prefers the official route capacity (request/context contextWindow), then the active model in settings.yaml, or your manual override below.',
+        waterCardTitle: 'Context water level', waterAutoSrc: 'auto-detected', waterManualSrc: 'manual', waterOfficialSrc: 'route capacity', waterFallbackSrc: 'fallback default', waterNotMeasured: 'Not measured for this session yet (updates after the next turn)', waterMeterOfficial: 'official meter', waterMeterHeuristic: 'heuristic fallback', waterThresholdHint: 'Past {t} of the window, the handoff advisory is injected and the skeleton ledger is backfilled; metering prefers the official token-meter (same source as the chat context ring), falling back to the heuristic when unavailable; the window prefers the official route capacity (request/context contextWindow), then the active model in settings.yaml, or your manual override below.',
         autoContTitle: 'Auto continue', autoContHint: 'When on: once the water level passes the threshold AND the old session is idle (the authoritative harness running bit flipped to false at a turn boundary, replacing the old "level unchanged across two polls"), a confirm card appears — Agree = continue now, Decline = skip this boundary (no re-prompt for it), no answer for 30-40s = unattended, continue automatically. Before continuing, the old agent refreshes PLAN + ledger; the new session keeps workspace/model/reasoning effort and receives layered handoff material; suppressed for 30 minutes after each run.', autoContOn: 'Auto continue: on', autoContOff: 'Auto continue: off', autoContThreshold: 'Threshold', autoContCountdown: '⏳ Auto-continue in {s}s…', autoContCancel: 'Cancel', autoContConfirm: 'Water level at {p}% and the old session is idle (turn boundary) — continue into a new session now?', autoContAgree: 'Continue', autoContReject: 'Decline', autoContTimeout: 'auto-continue in {s}s (unattended)', autoContRejected: 'Skipped this handoff (will ask again at the next turn boundary)',
         continueCardTitle: 'One-click continue', continueCardHint: 'Writes the handoff ledger → creates a new session → injects the handoff material as the first message → switches to the new session automatically (material = PLAN excerpt + latest ledger; falls back to the most recent global ledger when this workspace has none).', continueBtn: 'Continue in a new session', continueBusy: 'Working…',
         fStyle: 'Reflection style', fStyleHint: 'Life-style / Professional / Auto.',
@@ -492,6 +502,15 @@ window.__ModuleLoader__.load({
         return s ? !!s.running : null
       } catch (e) { return null }
     }
+    // 当前会话 id(跟随 GUI 切换会话):水位卡按会话取数,切换即刷新(2026-09-08)
+    function currentSessionIdClient() {
+      try {
+        var snap = sessions && sessions.list && sessions.list.getSnapshot()
+        if (!snap) return ''
+        var id = snap.current
+        return (id === undefined || id === null) ? '' : String(id)
+      } catch (e) { return '' }
+    }
     function amCtzValue() {
       return (typeof Intl !== 'undefined' && typeof Intl.DateTimeFormat === 'function') ? (Intl.DateTimeFormat().resolvedOptions().timeZone || undefined) : undefined
     }
@@ -542,6 +561,28 @@ window.__ModuleLoader__.load({
 
     // ───────────────────────── 更新弹窗 / 首次指导 ─────────────────────────
     var CHANGELOG = {
+      '2.2.6': { zh: [
+        '★ 修复:交接测量终于站到官方压缩的同一条边界上——官方自动压缩挂在每个 step 边界(pre-step,阈值 80%),而插件此前只在「一轮结束」测量;某一轮把水位从阈值下推到 80% 以上时,官方会在该轮就压缩完,交接白板/账本来不及写。现在 pre-step 也做同一测量(同一会话 5 秒节流),水位一到阈值就先写交接材料,不再被官方抢跑。',
+        '★ 自动接续改为宿主兜底:建新会话不再依赖浏览器页面——水位达标后在宿主侧开倒计时,确认卡照常弹出(同意/拒绝都直接发给宿主);页面被后台节流、标签页关闭或人不在时,倒计时一到宿主自己完成「刷新白板/账本 → 建新会话 → 沿用模型与工作区 → 注入交接材料」,不再因浏览器休眠而断档。',
+      ], en: [
+        '★ Fix: handoff measurement now runs on the same boundary as official compaction — the official auto-compaction hook fires at every step boundary (pre-step, 80% threshold) while the plugin only measured at turn end; a single turn that pushes the level past 80% let the official compaction finish before the handoff ledger was written. The same measurement now also runs on pre-step (throttled to once per 5s per session), so the handoff material is written as soon as the threshold is crossed.',
+        '★ Auto-continue is now host-side: creating the new session no longer depends on the browser tab. Once the water level crosses the threshold the host starts a countdown; the confirm card still appears (Agree/Decline are sent straight to the host), and if the tab is throttled, closed, or nobody is at the keyboard, the host itself completes "refresh PLAN/ledger → create session → restore model & workspace → inject handoff material" when the countdown ends. No more missed handoffs from a sleeping browser.',
+      ] },
+      '2.2.5': { zh: [
+        '★ 修复:上下文水位百分比不再被硬截断到 150%——旧版 `Math.min(tokens / window, 1.5)` 让任何超额都显示成同一个数(例如 761,692 / 131,072 真实为 581%)。现在如实上报,进度条仍按 100% 封顶。',
+        '★ 修复:水位卡标出的模型现在是「当前会话真实使用的模型」——此前一律读 settings.yaml 的 agent-default-model(新会话默认模型),你在界面切过模型后,卡片会张冠李戴地标成另一个模型(实测会话跑 deepseek-official/deepseek-v4.1-flash,却标成 opencode-go/deepseek-v4-flash)。现改为优先取会话日志 request/header 的 provider/model,默认模型只作兜底。',
+        '★ 修复:水位卡改成按会话显示——此前是全机单值、只在有对话轮次时更新,切到别的会话仍显示上一个会话的数(或重启后的 0),模型名也只能拿默认模型凑。现在按 sessionId 取该会话的实测值;没有实测就现场从该会话日志推导窗口与模型,并明确标注「本会话尚未测量」。',
+        '★ 版本号同步:面板徽标与「检测更新」读的是开发树的 package.json,长期停在 0.1.30(而 npm 已是 2.2.x),于是界面显示旧版本、更新检查永远报「有新版本」。现在发布脚本会把版本号回写开发树,两条线永远一致。',
+        '★ 新增悬浮钉:记忆面板标题栏加了一个图钉按钮(线描图标,与 ⟳ ⤾ ✕ 同画风),点一下钉住——之后再点桌面或其他地方,面板不会自动收起(再点一下取消)。钉住状态会记住。',
+        '★ 交接阈值下调到 75%:官方自动压缩阈值是 80%,阈值贴着 80% 常常还没走完交接就被官方压缩掉;水位建议阈值与自动接续阈值默认都改为 0.75,留 5% 余量(1M 窗口约 50K token)。已存在的 0.8 配置不会被自动改写,可在设置页手动改。',
+      ], en: [
+        '★ Fix: the context water-level percentage is no longer clamped to 150% — the old `Math.min(tokens / window, 1.5)` made every over-window reading look identical (761,692 / 131,072 is really 581%). It now reports the true value; the progress bar still caps at 100%.',
+        '★ Fix: the model shown on the water-level card is now the model the session is actually using — it used to always read agent-default-model from settings.yaml, so after switching models in the UI the card named a different model (observed: session running deepseek-official/deepseek-v4.1-flash but the card said opencode-go/deepseek-v4-flash). It now prefers provider/model from the session log\'s request/header, with the default model only as a fallback.',
+        '★ Fix: the water-level card is now per-session — it used to be a single global value updated only on turns, so switching conversations kept showing another session\'s numbers (or 0 after a restart) with the default model name. It now reads the measured value for the session id, and when there is none it derives the window/model from that session log and says "not measured for this session yet".',
+        '★ Version sync: the panel badge and "Check for updates" read the dev tree package.json, which sat at 0.1.30 while npm was already 2.2.x — the UI showed an old version and the update check always reported "update available". The release script now writes the version back to the dev tree so both lines stay in lockstep.',
+        '★ New pin button: the panel header now has a line-art pin toggle matching the ⟳ ⤾ ✕ icons — pin it and clicking elsewhere on the desktop no longer auto-hides the panel (click again to unpin). The pinned state is remembered.',
+        '★ Handoff threshold lowered to 75%: the official auto-compaction threshold is 80%, so a threshold sitting at 80% often gets compacted before the handoff finishes. Both the water-level advisory and the auto-continue threshold now default to 0.75, leaving 5% headroom (~50K tokens on a 1M window). An existing 0.8 in your config is not rewritten automatically — change it in Settings if you want the new default.',
+      ] },
       '2.2.4': { zh: [
         '★ 修复:一键接续的新会话终于落进旧会话所属工作区——官方 session.create 只有传 workspaceId 才会绑定工作区,只传 cwd 仅设工作目录(故此前恒落「未分组」);现 host 先解析旧会话的 workspaceId 再建会话,解析不到才回退 cwd。',
         '★ 修复:新会话沿用旧会话的模型与思考档位——模型信息在会话日志的 request/header.header.config(旧版查错了事件类型,恒取空 → 回落默认模型)。',
@@ -820,6 +861,8 @@ window.__ModuleLoader__.load({
       pyStatus: '/api/dsh-auto-memory/python-setup/status',
       handoffState: '/api/dsh-auto-memory/handoff-state',
       handoffContinue: '/api/dsh-auto-memory/handoff-continue',
+      autoContState: '/api/dsh-auto-memory/auto-continue-state',
+      autoContDecide: '/api/dsh-auto-memory/auto-continue-decide',
       semanticDownload: '/api/dsh-auto-memory/semantic-download',
     }
     function query(params) {
@@ -876,6 +919,7 @@ window.__ModuleLoader__.load({
       '[data-dam-resize]:hover { opacity: 1; }',
       '[data-dam-btn] { border: none; background: transparent; cursor: pointer; color: inherit; opacity: .75; font-size: calc(13px * var(--dam-scale)); padding: 4px 8px; border-radius: 6px; }',
       '[data-dam-btn]:hover { opacity: 1; background: color-mix(in srgb, var(--dsw-alias-label-secondary, #666) 16%, transparent); }',
+      '[data-dam-btn][data-pin="on"] { opacity: 1; background: color-mix(in srgb, var(--dam-accent, #4f7cff) 24%, transparent); }',
       '[data-dam-tabs-wrap] { display: flex; align-items: center; min-width: 0; border-bottom: 1px solid color-mix(in srgb, var(--dsw-alias-border-l1, rgba(128,128,128,.2)) 55%, transparent); }',
       '[data-dam-tabs] { flex: 1; min-width: 0; overflow: hidden; padding: 5px 4px; scrollbar-width: none; -ms-overflow-style: none; }',
       '[data-dam-tabs]::-webkit-scrollbar { display: none; }',
@@ -1178,6 +1222,22 @@ window.__ModuleLoader__.load({
       var label = props && props.label ? props.label : t('loading')
       return h('div', { 'data-dam-loading': '' }, h('span', { 'data-dam-spinner': '', 'aria-hidden': 'true' }), h('span', null, label))
     }
+    /** 线描图钉图标(2026-09-08):与标题栏 ⤾ ⟳ ✕ 同一画风——单色 currentColor 描边、无彩色 emoji;
+     *  未钉住=描边空心,已钉住=填充(内孔用 evenodd 挖空)。 */
+    function PinIcon(props) {
+      var filled = !!(props && props.filled)
+      return h('svg', {
+        width: 13, height: 13, viewBox: '0 0 16 16', 'aria-hidden': 'true',
+        style: { display: 'block', margin: '0 auto', pointerEvents: 'none' },
+      }, h('path', {
+        d: 'M8 1.7c2.2 0 4 1.8 4 4 0 2.9-4 8.6-4 8.6S4 8.6 4 5.7c0-2.2 1.8-4 4-4zM8 4.2a1.5 1.5 0 1 0 0 3 1.5 1.5 0 0 0 0-3z',
+        fill: filled ? 'currentColor' : 'none',
+        fillRule: 'evenodd',
+        stroke: 'currentColor',
+        strokeWidth: '1.1',
+        strokeLinejoin: 'round',
+      }))
+    }
     function AnimatedDisclosure(props) {
       var open = !!props.open
       var shownPair = useState(open)
@@ -2012,6 +2072,10 @@ window.__ModuleLoader__.load({
       var dataPair = useState(null)
       var data = dataPair[0]
       var setData = dataPair[1]
+      // 当前会话 id:水位卡按会话取数(切换会话即刷新,2026-09-08)
+      var sidPair = useState(function () { return currentSessionIdClient() })
+      var sid = sidPair[0]
+      var setSid = sidPair[1]
       var openPair = useState(null)
       var open = openPair[0]
       var setOpen = openPair[1]
@@ -2031,7 +2095,7 @@ window.__ModuleLoader__.load({
       var setAutoCfg = autoPair[1]
       useEffect(function () {
         apiGet(API.config).then(function (c) {
-          setAutoCfg({ enabled: !(c && c.autoContinueEnabled === false), threshold: (c && Number(c.autoContinueThreshold)) || 0.8 })
+          setAutoCfg({ enabled: !(c && c.autoContinueEnabled === false), threshold: (c && Number(c.autoContinueThreshold)) || 0.75 })
         }).catch(function () { setAutoCfg({ enabled: false, threshold: 0.7 }) })
       }, [])
       var autoSave = function (patch) {
@@ -2051,8 +2115,22 @@ window.__ModuleLoader__.load({
       }
       useEffect(function () {
         var alive = true
-        apiGet(API.handoffState).then(function (d) { if (alive) setData(d) }).catch(function () {})
+        setData(null)
+        apiGet(API.handoffState, { sessionId: sid }).then(function (d) { if (alive) setData(d) }).catch(function () {})
         return function () { alive = false }
+      }, [sid])
+      // 切换会话即刷新水位卡:订阅官方会话列表快照,current 变化时重取(2026-09-08)
+      useEffect(function () {
+        var unsub = null
+        try {
+          if (sessions && sessions.list && typeof sessions.list.subscribe === 'function') {
+            unsub = sessions.list.subscribe(function () {
+              var now = currentSessionIdClient()
+              setSid(function (prev) { return prev === now ? prev : now })
+            })
+          }
+        } catch (eSub) {}
+        return function () { if (typeof unsub === 'function') unsub() }
       }, [])
       useEffect(function () {
         if (!open) return
@@ -2087,9 +2165,11 @@ window.__ModuleLoader__.load({
             (wl.tokens || 0).toLocaleString() + ' / ' + wl.window.toLocaleString() + ' token · ' + pct + '%',
             ' ', h('span', { 'data-dam-hint': '' }, srcLabel),
             ' ', h('span', { 'data-dam-hint': '' }, wl.meter ? (wl.meter.indexOf('official') === 0 ? '· ' + t('waterMeterOfficial') + '(' + String(wl.meter).slice(9) + ')' : '· ' + t('waterMeterHeuristic')) : '')),
+          // 本会话尚未测量(刚重启/刚切过来还没发消息):明说,而不是显示成 0 让人以为上下文是空的
+          wl.at ? null : h('div', { 'data-dam-hint': '', style: { marginBottom: '4px' } }, t('waterNotMeasured')),
           h('div', { style: { height: '6px', borderRadius: '3px', background: 'color-mix(in srgb, currentColor 12%, transparent)', overflow: 'hidden' } },
             h('div', { style: { height: '100%', width: Math.min(pct, 100) + '%', background: barColor, borderRadius: '3px' } })),
-          h('div', { 'data-dam-hint': '', style: { marginTop: '4px' } }, t('waterThresholdHint').replace('{t}', String(wl.threshold || 0.8))),
+          h('div', { 'data-dam-hint': '', style: { marginTop: '4px' } }, t('waterThresholdHint').replace('{t}', String(wl.threshold || 0.75))),
         ])))
       }
       if (autoCfg && wl.window > 0) {
@@ -2812,6 +2892,14 @@ window.__ModuleLoader__.load({
           h('strong', null, t('autoMemory')),
           h('span', { 'data-dam-hint': '', style: { fontSize: '10px', opacity: .55 } }, ver ? 'v' + ver + '-ui' : ''),
           h('span', { className: 'dam-spacer' }),
+          // 悬浮钉(2026-09-08):钉住后点面板外不再自动收起;图标为线描 SVG,与 ⤾ ⟳ ✕ 同画风
+          h('button', {
+            'data-dam-btn': '', 'data-pin': pinned ? 'on' : 'off',
+            title: pinned ? t('unpinPanel') : t('pinPanel'),
+            'aria-pressed': pinned ? 'true' : 'false',
+            style: { display: 'inline-flex', alignItems: 'center', justifyContent: 'center', padding: '4px 6px' },
+            onClick: function () { controller.togglePin() },
+          }, h(PinIcon, { filled: pinned })),
           h('button', { 'data-dam-btn': '', title: t('resetPos'), onClick: function () { controller.resetGeom() } }, '⤾'),
           h('button', { 'data-dam-btn': '', title: t('refresh'), onClick: function () { setNonce(nonce + 1) } }, '⟳'),
           h('button', { 'data-dam-btn': '', title: t('close'), onClick: function () { controller.close() } }, '✕')),
@@ -3410,114 +3498,78 @@ window.__ModuleLoader__.load({
       var cfP = useState(null)
       var acConfirm = cfP[0]
       var setAcConfirm = cfP[1]
+      // 2.2.6:宿主兜底状态(倒计时/执行中/结果全部由宿主权威判定;浏览器只展示与传达决定)
+      var asP = useState(null)
+      var acState = asP[0]
+      var setAcState = asP[1]
       useEffect(function () {
         var alive = true
         var load = function () {
           apiGet(API.config).then(function (c) { if (alive) setAcCfg(c || {}) }).catch(function () {})
+          apiGet(API.autoContState).then(function (s) { if (alive && s) setAcState(s) }).catch(function () {})
         }
         load()
-        var iv = setInterval(load, 30000)
+        var iv = setInterval(load, 3000)
         return function () { alive = false; clearInterval(iv) }
       }, [])
       useEffect(function () {
+        var alive = true
         var on = !(acCfg && acCfg.autoContinueEnabled === false)
         if (!on) return
-        var thr = (acCfg && Number(acCfg.autoContinueThreshold)) || 0.8
-        var confirmSec = Number(acCfg && acCfg.autoContinueConfirmSeconds)
-        if (!(confirmSec >= 10 && confirmSec <= 120)) confirmSec = 35
-        var cooldownMin = Number(acCfg && acCfg.autoContinueCooldownMinutes)
-        if (!(cooldownMin > 0)) cooldownMin = 30
-        var alive = true
-        var maybePrompt = function (edgeAt) {
-          if (!alive || acBusy || autoState.cdIv || autoState.promptVisible) return
-          if (!edgeAt || Date.now() - edgeAt > 10 * 60 * 1000) return   // 边界太旧不再提示
-          if (Date.now() < autoState.suppressUntil) return
-          if (autoState.rejectedEdgeAt === edgeAt) return                // ②拒绝过同一边界
-          apiGet(API.handoffState).then(function (d) {
-            if (!alive || !d || !d.enabled) return
-            var wl = d.waterLevel || {}
-            if (!wl.window || !(wl.ratio >= thr)) return
-            var last = 0
-            try { last = Number(localStorage.getItem('dsh-auto-memory.autoCont.last') || 0) } catch (eL) {}
-            if (Date.now() - last < cooldownMin * 60 * 1000) return
-            if (autoState.promptVisible || autoState.cdIv) return
-            setAcConfirm({ ratio: Number(wl.ratio) || 0, tokens: Number(wl.tokens) || 0, window: Number(wl.window) || 0, edgeAt: edgeAt })
-            setAcSt('')
-            autoState.promptVisible = true
-            var left = confirmSec
-            setAcCd(left)
-            autoState.cdIv = setInterval(function () {
-              left -= 1
-              if (left <= 0) {
-                clearInterval(autoState.cdIv); autoState.cdIv = null; setAcCd(0)
-                autoState.promptVisible = false; setAcConfirm(null)
-                runAuto()   // ③超时 = 挂机 → 自动接续兜底
-              } else setAcCd(left)
-            }, 1000)
-          }).catch(function () {})
-        }
-        // 轮次边界:running true→false 边沿 + 3s 短确认
-        var verifyEdge = function (edgeAt) {
-          if (!alive || autoState.edgeAt !== edgeAt) return
-          var info = currentRunningInfo()
-          if (info && info.running) return   // 短确认失败:新一轮已开始,不算边界
-          maybePrompt(edgeAt)
-        }
-        var armEdge = function () {
-          autoState.edgeAt = Date.now()
-          var info = currentRunningInfo()
-          autoState.edgeSession = info ? info.sessionId : ''
-          var edgeAt = autoState.edgeAt
-          setTimeout(function () { verifyEdge(edgeAt) }, 3000)
-        }
-        var observe = function () {
+        var thr = (acCfg && Number(acCfg.autoContinueThreshold)) || 0.75
+        // 渲染:armed 倒计时 → 确认卡;executing → 执行中;lastOk → 成功;error → 失败提示。
+        // 触发/倒计时/超时执行全部由宿主侧驱动(2.2.6),浏览器即使被节流也不影响接续。
+        var poll = function () {
           if (!alive) return
-          var info = currentRunningInfo()
-          if (!info) return
-          if (autoState.lastRunning === null) {
-            autoState.lastRunning = info.running
-            if (!info.running) armEdge()   // 首次观察即空闲(挂机/刚进会话):按边界处理
-            return
-          }
-          if (autoState.lastRunning === true && info.running === false) armEdge()
-          autoState.lastRunning = info.running
-        }
-        var unsub = null
-        try { if (sessions && sessions.list && typeof sessions.list.subscribe === 'function') unsub = sessions.list.subscribe(observe) } catch (eSub) {}
-        observe()
-        var iv = setInterval(function () { observe(); maybePrompt(autoState.edgeAt) }, 20000)  // 兜底:水位后到 / 订阅不可用
-        return function () {
-          alive = false
-          clearInterval(iv)
-          if (unsub) { try { unsub() } catch (eU) {} }
+          apiGet(API.autoContState).then(function (s) {
+            if (!alive || !s) return
+            setAcState(s)
+            if (s.executing) {
+              setAcSt(locale === 'zh' ? '宿主正在自动接续:刷新白板/账本 → 建新会话 → 注入材料…' : 'Host auto-continuing: refresh PLAN/ledger → new session → inject…')
+              return
+            }
+            if (s.lastOk) {
+              setAcSt((locale === 'zh' ? '✓ 已自动接续到新会话,可直接上手' : '✓ Auto-continued into a new session') + (s.lastOk.model ? ' · ' + s.lastOk.model + (s.lastOk.reasoningEffort ? '/' + s.lastOk.reasoningEffort : '') : ''))
+              return
+            }
+            if (s.error) { setAcSt('✗ ' + s.error); return }
+            var arm = s.armed
+            if (arm && arm.ratio >= thr) {
+              setAcConfirm({ ratio: Number(arm.ratio) || 0, tokens: Number(arm.tokens) || 0, window: Number(arm.window) || 0, edgeAt: Number(arm.edgeAt) || 0 })
+              setAcCd(Math.max(0, Math.ceil((Number(arm.expiresAt) || 0) - Date.now()) / 1000))
+            } else {
+              setAcConfirm(null)
+              setAcCd(0)
+              if (acSt && /^✗/.test(acSt)) setAcSt('')
+            }
+          }).catch(function () {})
         }
-      }, [acCfg && acCfg.autoContinueEnabled === false, acCfg && (Number(acCfg.autoContinueThreshold) || 0.8), acCfg && acCfg.autoContinueConfirmSeconds, acCfg && acCfg.autoContinueCooldownMinutes, acBusy])
+        poll()
+        var iv = setInterval(poll, 3000)
+        return function () { alive = false; clearInterval(iv) }
+      }, [acCfg && acCfg.autoContinueEnabled === false, acCfg && (Number(acCfg.autoContinueThreshold) || 0.75)])
       var cancelAc = function () {
-        if (autoState.cdIv) { clearInterval(autoState.cdIv); autoState.cdIv = null }
-        autoState.promptVisible = false
         setAcCd(0)
       }
+      // 2.2.6:执行权在宿主。同意/拒绝都 POST 给宿主(浏览器只传达决定);执行/超时全部宿主侧完成。
       var runAuto = function () {
-        if (acBusy) return
-        cancelAc()
-        setAcConfirm(null)
-        if (!remoteFace || !remoteFace.session || typeof remoteFace.session.create !== 'function') {
-          setAcSt(locale === 'zh' ? '✗ remote.session 不可用——请重启 dsh web 后重试' : '✗ remote.session unavailable — restart dsh web')
-          return
-        }
-        setAcBusy(true)
-        setAcSt(locale === 'zh' ? '正在自动接续:刷新白板/账本 → 建新会话 → 注入材料…' : 'Auto-continuing: refresh PLAN/ledger → new session → inject…')
-        runContinueFlow({ onProgress: function (m) { setAcSt(m) } }).then(function (r) {
-          setAcSt((locale === 'zh' ? '✓ 已自动接续到新会话,可直接上手' : '✓ Auto-continued into a new session') + (r && r.model ? ' · ' + r.model + (r.reasoningEffort ? '/' + r.reasoningEffort : '') : ''))
-          setAcBusy(false)
-        }).catch(function (e) { setAcSt('✗ ' + String(e && e.message ? e.message : e)); setAcBusy(false) })
+        var edgeAt = (acConfirm && acConfirm.edgeAt) || 0
+        apiPost(API.autoContDecide, { action: 'agree', edgeAt: edgeAt }).then(function (r) {
+          if (r && r.ok) {
+            setAcConfirm(null)
+            setAcCd(0)
+            setAcSt(locale === 'zh' ? '宿主正在自动接续:刷新白板/账本 → 建新会话 → 注入材料…' : 'Host auto-continuing: refresh PLAN/ledger → new session → inject…')
+          } else {
+            setAcSt('✗ ' + String((r && r.error) || 'auto-continue agree failed'))
+          }
+        }).catch(function (e) { setAcSt('✗ ' + String(e && e.message ? e.message : e)) })
       }
       var onAgree = function () { runAuto() }
       var onReject = function () {
-        var edgeAt = (acConfirm && acConfirm.edgeAt) || autoState.edgeAt || 0
+        var edgeAt = (acConfirm && acConfirm.edgeAt) || 0
         cancelAc()
         setAcConfirm(null)
-        autoState.rejectedEdgeAt = edgeAt
+        apiPost(API.autoContDecide, { action: 'reject', edgeAt: edgeAt }).then(function () {}).catch(function () {})
         setAcSt(t('autoContRejected'))
       }
       if (acConfirm || acCd > 0 || acSt) {
@@ -3530,7 +3582,7 @@ window.__ModuleLoader__.load({
               h('button', { 'data-dam-btn': '', style: { marginLeft: '6px' }, onClick: onReject }, t('autoContReject')),
               acCd > 0 ? h('span', { 'data-dam-hint': '', style: { marginLeft: '8px' } }, t('autoContTimeout').replace('{s}', String(acCd))) : null),
           ]) : null,
-          !acConfirm && acCd > 0 ? h('div', null, t('autoContCountdown').replace('{s}', String(acCd)), ' ', h('button', { style: { marginLeft: '6px', border: '1px solid rgba(232,234,237,.45)', borderRadius: '8px', background: 'transparent', color: '#e8eaed', cursor: 'pointer', padding: '2px 10px' }, onClick: cancelAc }, t('autoContCancel'))) : null,
+          !acConfirm && acCd > 0 ? h('div', null, t('autoContCountdown').replace('{s}', String(acCd)), ' ', h('button', { style: { marginLeft: '6px', border: '1px solid rgba(232,234,237,.45)', borderRadius: '8px', background: 'transparent', color: '#e8eaed', cursor: 'pointer', padding: '2px 10px' }, onClick: onReject }, t('autoContCancel'))) : null,
           acSt ? h('div', { style: (acConfirm || acCd > 0) ? { marginTop: '4px' } : {} }, acSt) : null)
       }
       return null
@@ -4060,7 +4112,7 @@ window.__ModuleLoader__.load({
         field(t('fHandoffPlan'), h('input', { 'data-dam-input': '', type: 'number', min: 200, value: cfg.handoffPlanChars === undefined ? 1200 : cfg.handoffPlanChars, onChange: function (e) { set('handoffPlanChars', Number(e.target.value) || 1200) } }), t('fHandoffPlanHint')),
         field(t('fHandoffLedger'), h('input', { 'data-dam-input': '', type: 'number', min: 100, value: cfg.handoffLedgerChars === undefined ? 800 : cfg.handoffLedgerChars, onChange: function (e) { set('handoffLedgerChars', Number(e.target.value) || 800) } }), t('fHandoffLedgerHint')),
         field(t('fWaterWindow'), h('input', { 'data-dam-input': '', type: 'number', min: 0, value: cfg.waterLevelWindowTokens === undefined ? 65536 : cfg.waterLevelWindowTokens, onChange: function (e) { set('waterLevelWindowTokens', Number(e.target.value) || 0) } }), t('fWaterWindowHint')),
-        field(t('fWaterThreshold'), h('input', { 'data-dam-input': '', type: 'number', min: 0.1, max: 1.5, step: 0.05, value: cfg.waterLevelThreshold === undefined ? 0.8 : cfg.waterLevelThreshold, onChange: function (e) { set('waterLevelThreshold', Number(e.target.value) || 0.8) } }), t('fWaterThresholdHint')),
+        field(t('fWaterThreshold'), h('input', { 'data-dam-input': '', type: 'number', min: 0.1, max: 1.5, step: 0.05, value: cfg.waterLevelThreshold === undefined ? 0.75 : cfg.waterLevelThreshold, onChange: function (e) { set('waterLevelThreshold', Number(e.target.value) || 0.75) } }), t('fWaterThresholdHint')),
         field(t('fWaterAdvisory'), h('input', { type: 'checkbox', checked: cfg.waterLevelAdvisory !== false, onChange: function (e) { set('waterLevelAdvisory', e.target.checked) } }), t('fWaterAdvisoryHint')),
         field(t('fWaterAuto'), h('input', { type: 'checkbox', checked: cfg.waterLevelAutoHandoff !== false, onChange: function (e) { set('waterLevelAutoHandoff', e.target.checked) } }), t('fWaterAutoHint')),
         field(locale === 'zh' ? '子代理痕迹回收' : 'Subagent trace recycle', h('input', { type: 'checkbox', checked: cfg.subagentGcEnabled !== false, onChange: function (e) { set('subagentGcEnabled', e.target.checked) } }),
@@ -4105,6 +4157,7 @@ window.__ModuleLoader__.load({
       try {
         var onDocPointerDown = function (e) {
           if (!panelOpen || panelClosing) return
+          if (controller.isPinned()) return   // 悬浮钉:钉住后点面板外不收起(2026-09-08)
           var el = e.target
           if (el && el.closest && (el.closest('[data-dam-panel]') || el.closest('[data-dam-sidebar-btn]'))) return
           controller.close()

package/lib/index.js

@@ -43,8 +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 } from './subagent-gc.js'
-import { parseModelWindowsPre, pickWindowPre, findOfficialContextWindowPre } from './water-window.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'
@@ -161,6 +161,8 @@ 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',
+  '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',
   'semantic-download': '/api/dsh-auto-memory/semantic-download',
   'semantic-emit': '/api/dsh-auto-memory/semantic-emit',
@@ -221,16 +223,18 @@ 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)。 */
-  autoContinueThreshold: 0.8,
+  /** 自动接续水位阈值(0.5-0.95);2026-09-08 与 waterLevelThreshold 同步下调到 0.75(官方自动压缩阈值 80%,必须留余量)。 */
+  autoContinueThreshold: 0.75,
   /** 确认卡倒计时秒数(30-40s 无操作 = 挂机 → 自动接续兜底)。 */
   autoContinueConfirmSeconds: 35,
   /** 接续前刷新仪式(默认开):先让旧 Agent 刷新 PLAN.md + 交接账本,host 再用最新材料组装交接。 */
@@ -1643,16 +1647,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 = 0
-      let model = ''
-      let provider = ''
+      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))
@@ -1660,47 +1668,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 }
           }
         }
         // 2.2.4 修复:settings.yaml 的 llm-deepseek 段是 flow 风格 YAML(`{ models: [ { id: x, contextWindow: 1000000, … } ] }`),
         // 旧解析器只认 block 风格 → 整段解析失败、窗口退化为 fallback。改为纯函数解析(block + flow 双支持)。
-        if (model) value = pickWindowPre(parseModelWindowsPre(text), provider, model)
+        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 > 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)。
-        // 2.2.4 修复:该事件只在请求头部变化时追加(实测 2999 条事件里仅 2 条,且位于会话开头),
-        // 旧实现只扫最近 256 条 → 长会话永远扫不到,窗口退化为 fallback 131072(水位虚高到 150%+)。
-        // 现在全量向前扫 + 按会话 id 缓存 5 分钟,避免每轮重复遍历。
-        try {
-          const sid = agent && agent.session && agent.session.id ? String(agent.session.id) : ''
-          const cached = this._officialWindowCache
-          let cw = 0
-          if (cached && sid && cached.sid === sid && Date.now() - cached.at < 300000) {
-            cw = cached.window
-          } else {
-            cw = findOfficialContextWindowPre(sessionEventsOf(agent && agent.session))
-            this._officialWindowCache = { sid, at: Date.now(), window: cw }
-          }
-          if (cw > 0) { win = cw; winSource = 'official-context' }
-        } 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)
@@ -1733,7 +1812,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
@@ -1741,9 +1822,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) {
@@ -1777,6 +1863,153 @@ class MemoryEngine {
     } catch (e) { diag('checkWaterLevel error: ' + (e && e.message)) }
   }
 
+  /** M-CM6-A·水位 v3(2026-09-08):pre-step 边界补测 —— 官方自动压缩(compaction-basic)挂在 `agent/pre-step`,
+   *  阈值 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) {
+    try {
+      if (this.config.handoffEnabled === false) return
+      if (!agent || !this.hasReliableSessionIdentity(agent)) return
+      const rt = this.runtimeFor(agent)
+      const now = Date.now()
+      if (rt && rt.waterStepAt && now - rt.waterStepAt < minGapMs) return
+      if (rt) rt.waterStepAt = now
+      void this.checkWaterLevel(agent)
+    } catch (e) { diag('checkWaterLevelAtStep error: ' + (e && e.message)) }
+  }
+
+  /** M-CM6-C·宿主兜底自动接续(2026-09-08,2.2.6):浏览器端 AutoContinueHost 被后台节流/关闭时,
+   *  宿主自身在倒计时到期后直接建新会话。协议:turn-stopping 且水位≥阈值 → arm 倒计时(confirmSeconds,
+   *  默认 35s,写入 _autoContState)→ 浏览器轮询 GET auto-continue-state 显示确认卡(同意=POST decide
+   *  agree,宿主立即执行;拒绝=POST decide reject,同一边界不再触发)→ 到期无人响应 → 宿主自动执行,
+   *  与官方 SessionController service(ctx.get('sessionController'))同进程直调,不依赖浏览器。 */
+  armAutoContinue(agent, wl) {
+    try {
+      if (!agent || !this.hasReliableSessionIdentity(agent)) return
+      if (this.config.handoffEnabled === false) return
+      if (this.config.autoContinueEnabled === false) return
+      if (!wl || !(wl.ratio >= (Number(this.config.autoContinueThreshold) || 0.75))) return
+      const st = this._autoContState || (this._autoContState = {})
+      const now = Date.now()
+      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 || '')
+      // 拒绝语义:时间窗 10 分钟内不再 arm(近似客户端「拒绝=跳过本边界」;窗口过后按新边界重新评估)
+      if (st.rejectedEdgeAt && now - st.rejectedEdgeAt < 10 * 60 * 1000) return
+      if (st.armed && Date.now() < st.armed.expiresAt) return         // 已有进行中的倒计时
+      if (st.executing) return
+      const confirmSec = Number(this.config.autoContinueConfirmSeconds)
+      const sec = confirmSec >= 10 && confirmSec <= 120 ? confirmSec : 35
+      st.armed = {
+        edgeAt: now,
+        sessionId: sid,
+        expiresAt: now + sec * 1000,
+        ratio: Number(wl.ratio) || 0,
+        tokens: Number(wl.tokens) || 0,
+        window: Number(wl.window) || 0,
+        source: String(wl.source || ''),
+      }
+      diag('auto-continue armed: sid=' + sid + ' ratio=' + st.armed.ratio.toFixed(2) + ' expiresAt=' + st.armed.expiresAt)
+    } catch (e) { diag('armAutoContinue error: ' + (e && e.message)) }
+  }
+
+  /** 心跳驱动:倒计时到期且无人决定 → 宿主自动执行接续。 */
+  async tickAutoContinue() {
+    try {
+      const st = this._autoContState || (this._autoContState = {})
+      if (!st.armed || st.executing) return
+      if (Date.now() < st.armed.expiresAt) return
+      diag('auto-continue deadline reached, executing host-side')
+      await this.hostAutoContinue()
+    } catch (e) { diag('tickAutoContinue error: ' + (e && e.message)) }
+  }
+
+  /** 宿主侧执行接续:刷账本(已由水位检查写过)→ 材料 → sessionController.create/selectModel/prompt。 */
+  async hostAutoContinue() {
+    const st = this._autoContState || (this._autoContState = {})
+    if (st.executing) return { ok: false, error: 'already executing' }
+    const armed = st.armed
+    st.armed = null
+    st.executing = true
+    st.error = ''
+    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()
+      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 }),
+        ...(d.agentPreset ? { agentPreset: d.agentPreset } : {}),
+      })
+      const newId = String((created && (created.sessionId || created.id)) || '')
+      if (!newId) throw new Error('create returned no sessionId')
+      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)
+      }
+      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 || '' }
+    } catch (e) {
+      st.error = String(e && e.message ? e.message : e)
+      diag('hostAutoContinue error: ' + st.error)
+      return { ok: false, error: st.error }
+    } finally {
+      st.executing = false
+      st.armed = null
+    }
+  }
+
+  /** 浏览器轮询视图:armed 倒计时 / 最近一次执行结果 / 拒绝边界 / 错误。 */
+  autoContinueState() {
+    const st = this._autoContState || (this._autoContState = {})
+    const armed = st.armed ? {
+      edgeAt: st.armed.edgeAt,
+      sessionId: st.armed.sessionId,
+      ratio: st.armed.ratio,
+      tokens: st.armed.tokens,
+      window: st.armed.window,
+      expiresAt: st.armed.expiresAt,
+      leftMs: Math.max(0, st.armed.expiresAt - Date.now()),
+    } : null
+    return {
+      enabled: this.config.autoContinueEnabled !== false && this.config.handoffEnabled !== false,
+      threshold: Number(this.config.autoContinueThreshold) || 0.75,
+      armed,
+      executing: !!st.executing,
+      rejectedEdgeAt: st.rejectedEdgeAt || 0,
+      lastRunAt: st.lastRunAt || 0,
+      lastOk: st.lastOk || null,
+      error: st.error || '',
+    }
+  }
+
+  /** 浏览器决定:agree=立即宿主执行;reject=标记该边界不再触发。 */
+  async decideAutoContinue(action, edgeAt) {
+    const st = this._autoContState || (this._autoContState = {})
+    const armedEdge = st.armed && st.armed.edgeAt
+    if (action === 'reject') {
+      if (armedEdge !== undefined && armedEdge !== null) st.rejectedEdgeAt = armedEdge
+      st.armed = null
+      diag('auto-continue rejected at edge ' + String(armedEdge))
+      return { ok: true, rejected: true }
+    }
+    if (action === 'agree') {
+      if (st.executing) return { ok: false, error: 'already executing' }
+      if (!st.armed) return { ok: false, error: 'no pending auto-continue' }
+      edgeAt = edgeAt || st.armed.edgeAt
+      if (edgeAt !== st.armed.edgeAt) return { ok: false, error: 'stale edge' }
+      return this.hostAutoContinue()
+    }
+    return { ok: false, error: 'unknown action' }
+  }
+
   /** 官方 token-meter 公式(dsh-context 移植版):文本 ≈ ceil(字符/4)+4 角色框定;忠实于 dsh-token-meter/estimate.ts 的文本分支。 */
   estimateSessionTokens(messages) {
     let tokens = 0
@@ -1968,7 +2201,7 @@ class MemoryEngine {
   }
 
   /** 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')
@@ -1994,13 +2227,43 @@ 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) {}
+    // 水位:优先返回「该会话」的记录(实测 → 磁盘推导);未指定 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.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()
@@ -2014,16 +2277,7 @@ class MemoryEngine {
       refresh: this.config.autoContinueRefreshRitual === false || !sid
         ? { sessionId: '', prompt: '' }
         : { sessionId: sid, prompt: this.refreshRitualPrompt() },
-      waterLevel: {
-        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,
-        at: Number(this.state.waterLevelAt) || 0,
-      },
+      waterLevel: water,
     }
   }
 
@@ -2782,7 +3036,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
@@ -5763,7 +6017,13 @@ export function apply(ctx, config) {
         // 最后活动时间写入该 agent 自己的 runtime(不再落到 currentRuntime()/default)
         try { engine.runtimeFor(agent).lastActiveAt = Date.now() } catch (e) {}
         // M-CM4 水位感知:每轮测量会话消息体量,越阈值→advisory+自动骨架账本(异步,不阻塞收尾)
-        try { void engine.checkWaterLevel(agent) } catch (e) {}
+        try { void engine.checkWaterLevel(agent).then(function () {
+          // M-CM6-C 宿主兜底:轮末测量完成后若达标 → arm 倒计时(浏览器活着时由它展示确认卡;被节流/关闭则宿主到期自执行)
+          try {
+            const rt2 = engine.runtimeFor(agent)
+            engine.armAutoContinue(agent, { ratio: rt2.waterLevel, tokens: rt2.waterLevelTokens, window: rt2.waterLevelWindow, source: rt2.waterLevelSource })
+          } catch (eArm) {}
+        }) } catch (e) {}
         // 全局活动戳同步更新(暂离检测统揽全局,见 tickTime)
         engine._globalLastActiveAt = Date.now()
         try { engine.ingestAgentLifecycle(agent, 'agent/turn-stopping', { turn: payload && payload.turn, payload: { turn: payload && payload.turn } }) } catch (e) {}
@@ -5794,6 +6054,9 @@ export function apply(ctx, config) {
         // M7.5:pre-step 边界先冲刷 CoT 缓冲——保证本轮 context_push 的 window 携带最新思维链
         try { engine.flushReasoningBuffer(rt) } catch (_) {}
         engine.ingestAgentLifecycle(agent, 'agent/pre-step', { turn: payload && payload.turn, step: payload && payload.step, payload: { turn: payload && payload.turn, step: payload && payload.step } })
+        // M-CM6-A·水位 v3(2026-09-08):官方压缩在 pre-step 就动手,交接测量必须站同一条边界
+        // (否则某轮把水位从 <阈值 推到 ≥0.8 时,官方先压缩、白板账本来不及写)。异步不阻塞放行。
+        try { engine.checkWaterLevelAtStep(agent) } catch (eWL) {}
         // M6-3:pre-step 时序(§8)——校验 cursor/index/TTL 后 claim packet,等待渲染面消费
         try { if (engine._activationHost) engine._activationHost.onPreStep(agent) } catch (_) {}
         // 只刷新顶层会话:子代理(自动沉淀/固化的 subagent)session 无 cwd,刷新会把 state 切到错误工作区
@@ -6243,7 +6506,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) }) }
       },
     },
@@ -6261,6 +6524,29 @@ export function apply(ctx, config) {
         } 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) }) }
+      },
+    },
+    {
+      kind: 'exact',
+      path: API['auto-continue-decide'],
+      handler: async (req, res) => {
+        // M-CM6-C·宿主兜底决定(POST;loopback):agree=宿主立即执行接续;reject=本边界不再触发。
+        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.decideAutoContinue(body && body.action, body && body.edgeAt)
+          return writeJson(res, r && r.ok ? 200 : 400, r || { ok: false, error: 'no result' })
+        } catch (e) { return writeJson(res, 500, { error: String(e && e.message ? e.message : e) }) }
+      },
+    },
     {
       kind: 'exact',
       path: API['subagent-gc'],
@@ -7061,7 +7347,7 @@ export function apply(ctx, config) {
     })()
   }, 5 * 60 * 1000)
   // 心跳独立 15 秒一次(对齐 polling-lease 心跳节奏),证明轮询机制活着
-  const heartbeatTimer = setInterval(() => { void writeHeartbeat(); try { engine.tickTime() } catch (e) {}; try { void engine.subagentGcSweep() } catch (e) {} }, 15000)
+  const heartbeatTimer = setInterval(() => { void writeHeartbeat(); try { engine.tickTime() } catch (e) {}; try { void engine.subagentGcSweep() } catch (e) {}; try { void engine.tickAutoContinue() } catch (e) {} }, 15000)
   void writeHeartbeat() // 立即心跳一次:重启后马上可见轮询存活
 
   // ---------- 注册与清理 ----------

package/lib/water-window.js

@@ -67,6 +67,38 @@ export function pickWindowPre(windows, provider, model) {
   return 0
 }
 
+/**
+ * 从会话事件里取最近一条 request/header|request/context 的真实 provider/model(+ 顺带 contextWindow)。
+ *
+ * 背景(2026-09-08 用户实测):水位卡此前把「窗口来源」标成 settings.yaml 的 agent-default-model(新会话默认模型),
+ * 用户在 GUI 里切过默认模型后,当前会话实际跑的模型与卡片显示不符
+ * (实测:会话日志 request/header = deepseek-official/deepseek-v4.1-flash-expires-on-0910,卡片却写 opencode-go/deepseek-v4-flash)。
+ * 会话自己的请求头才是「这个会话正在用哪个模型」的权威来源;默认模型只作兜底。
+ *
+ * @param {object[]} events - 会话事件数组。
+ * @param {number} maxScan - 最多向前扫多少条(默认全部)。
+ * @returns {{provider:string,model:string,contextWindow:number}} 未找到时字段为空/0。
+ */
+export function findSessionModelPre(events, maxScan = 0) {
+  const out = { provider: '', model: '', contextWindow: 0 }
+  if (!Array.isArray(events) || !events.length) return out
+  const floor = maxScan > 0 ? Math.max(0, events.length - maxScan) : 0
+  for (let i = events.length - 1; i >= floor; i--) {
+    const ev = events[i]
+    const t = ev && ev.type
+    if (t !== 'request/header' && t !== 'request/context') continue
+    const d = (ev && ev.data) || {}
+    const cfg = (d.header && d.header.config) || d.config || {}
+    const provider = String(cfg.provider || d.provider || '')
+    const model = String(cfg.model || d.model || '')
+    const cw = Number(d.contextWindow) || 0
+    if (!out.model && model) { out.model = model; out.provider = provider }
+    if (!out.contextWindow && cw > 0) out.contextWindow = cw
+    if (out.model && out.contextWindow) break
+  }
+  return out
+}
+
 /**
  * 从会话事件里取最近一条 request/context 的 contextWindow(路由权威值)。
  * 不限制扫描窗口:该事件只在请求头部变化时追加,长会话里往往只存在于开头。

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@a9i5k4/dsh-auto-memory",
   "description": "Proactive associative memory for DSH: zero-prompt recall injected before the model speaks, three-layer auto-consolidation, skill crystallization, and Astra-style context management - handoff ledgers, PLAN whiteboard, water-level sensing. Local-first, model-agnostic, zero deps. 主动联想记忆+Astra 式上下文管理:自动唤回/自动沉淀/技能固化/交接账本与白板跨窗口续命/水位感知。",
-  "version": "2.2.4",
+  "version": "2.2.6",
   "type": "module",
   "main": "lib/index.js",
   "exports": {