@jjh32456/dsh-longlive 1.6.4 → 1.6.6

package/CHANGELOG.md

@@ -1,8 +1,26 @@
+## 1.6.6
+
+- 热截断修复：去掉 skipPast 永久钉死（aborted/interrupted 轮只要有 turn/end 就整轮可切）；段首 system/message 永不进切段，中途注入的 system 副本随旧前缀归档。修复后真实会话一次可切 35 个 closed 轮（约 46 万 tokens），上下文回到最近 4 轮量级。
+
 # 变更记录
 
 本文件从 0.7.6 开始记录；更早的版本没有随包维护变更日志（0.7.5 及以前的 tarball 里没有
 CHANGELOG）。
 
+## 1.6.5 — 2026-11-06
+
+**热截断热修复：被宿主重启中断过的会话不再永久失去自动切刀。**
+
+根因：`selectCutPlan` 把「closed-but-not-completed」（有 `turn/end`，但 reason 为
+aborted / interrupted / truncated）的轮次当成不可跨越的屏障。一旦这类轮次落在保留窗口
+之前，计划会一直返回 null，自动热截断从此静默失效——实测上下文涨到 50 万 tokens 也不再
+切一刀（1.6.4 的 300k 闸门本身没问题，是计划永远为空）。
+
+1.6.5 改为：这类轮次继续**保留不切**，但计划从它**之后**继续找连续的已完成轮，不再返回
+null；另外修了候选段**首轮内部的 system/message**（宿主中途注入）把段截成空的问题——现在
+该轮原地保留、段从它之后开始。新增 H3 / H3b 回归测试覆盖这两个场景。
+`node test/run.mjs` / `node test/run-rc.mjs` 全绿。
+
 ## 1.6.4 — 2026-11-06
 
 **热截断参数收尾 + D6 重启兼容 + 可移植性收口。** 1.6.3-rc.2 的默认窗口在长对话里几乎

package/QUICKSTART.md

@@ -1,4 +1,4 @@
-# QUICKSTART — 五步跑通（1.6.4）
+# QUICKSTART — 五步跑通（1.6.5）
 
 目标：在一台新机器上，5 步内让 `@jjh32456/dsh-longlive` 装好、能用、能回滚、能卸干净。
 完整背景见 [README.md](README.md)，逐码排错见 [docs/ERRORS.md](docs/ERRORS.md)，
@@ -42,7 +42,7 @@ $DSH = '<DSH 安装目录>\resources\runtime\cli\bin\dsh.cmd'
 先把包放到固定目录，核对 sha256，再装进一个**新 profile**：
 
 ```powershell
-$TGZ = 'C:\path\to\jjh32456-dsh-longlive-1.6.4.tgz'
+$TGZ = 'C:\path\to\jjh32456-dsh-longlive-1.6.5.tgz'
 Get-FileHash -Algorithm SHA256 $TGZ      # 对照同目录的 .tgz.sha256
 
 $LLPROFILE = 'fresh0723b'
@@ -54,7 +54,7 @@ $LLPROFILE = 'fresh0723b'
 & $DSH plugin --profile $LLPROFILE list --depth 0
 ```
 
-`list` 应出现 `@jjh32456/dsh-longlive@1.6.4`。`dsh plugin --profile <新名字> add` 自己也会初始化
+`list` 应出现 `@jjh32456/dsh-longlive@1.6.5`。`dsh plugin --profile <新名字> add` 自己也会初始化
 profile，但那样只带 `@deepseek-ai/dsh-base`；要网页 UI 和与本文一致的验证，先用
 `--from-default-profile web` 建模板 profile。
 
@@ -67,8 +67,8 @@ profile，但那样只带 `@deepseek-ai/dsh-base`；要网页 UI 和与本文一
 ```powershell
 Set-Location <仓库根目录>
 & $NODE test\run.mjs
-& $NODE scripts\pack.mjs --expect-version 1.6.4
-# 产物：dist\jjh32456-dsh-longlive-1.6.4.tgz（+ .sha256）
+& $NODE scripts\pack.mjs --expect-version 1.6.5
+# 产物：dist\jjh32456-dsh-longlive-1.6.5.tgz（+ .sha256）
 ```
 
 `pack.mjs` 只负责打包，不跑测试；`--expect-version` 会在版本不匹配时拒绝出包。
@@ -79,7 +79,7 @@ Set-Location <仓库根目录>
 宿主正在跑、且当前 profile 就是目标 profile 时：
 
 ```
-plugin_manager action=install_bundle target="file:C:/path/to/jjh32456-dsh-longlive-1.6.4.tgz"
+plugin_manager action=install_bundle target="file:C:/path/to/jjh32456-dsh-longlive-1.6.5.tgz"
 ```
 
 目标必须是**绝对路径**，且需要上面说的权限。装完按宿主提示重载（或重启该 profile）。

package/README.en.md

@@ -1,4 +1,4 @@
-# @jjh32456/dsh-longlive (Longlive)
+# @jjh32456/dsh-longlive (Longlive)
 
 A DeepSeek Harness plugin that keeps a long session healthy: **inspect it, back it up, and shrink it safely** before the context window fills up. No standalone UI; no network requests or telemetry in the default configuration (Router / RouterFace / embedding call the provider you configure, only after you enable them).
 ## What you get
@@ -13,7 +13,7 @@ A DeepSeek Harness plugin that keeps a long session healthy: **inspect it, back
 ```powershell
 $DSH  = '<DSH install>\resources\runtime\cli\bin\dsh.cmd'
 $NODE = '<DSH install>\resources\runtime\primary-runtime\dependencies\node\bin\node.exe'
-& $DSH plugin --profile desktop add "file:C:/path/jjh32456-dsh-longlive-1.6.4.tgz"
+& $DSH plugin --profile desktop add "file:C:/path/jjh32456-dsh-longlive-1.6.5.tgz"
 & $DSH plugin --profile desktop list --depth 0
 & $NODE "$env:USERPROFILE\.dsh\profiles\desktop\node_modules\@jjh32456\dsh-longlive\scripts\longlive-doctor.mjs" --profile desktop
 ```

package/README.md

@@ -1,4 +1,4 @@
-# @jjh32456/dsh-longlive（久视）
+# @jjh32456/dsh-longlive（久视）
 
 > 1.6.0 起包名由 `dsh-session-longlive` 改为 `dsh-longlive`；1.6.4 起发布名改为 scoped 包
 > `@jjh32456/dsh-longlive`（npm 包名），显示名仍是「久视」（英文 Longlive）；
@@ -81,7 +81,7 @@ $NODE = '<DSH 安装目录>\resources\runtime\primary-runtime\dependencies\node\
 
 ```powershell
 # 1. 安装本地 tgz（用 plugin add，不要用 npm install）
-& $DSH plugin --profile desktop add "file:C:/path/jjh32456-dsh-longlive-1.6.4.tgz"
+& $DSH plugin --profile desktop add "file:C:/path/jjh32456-dsh-longlive-1.6.5.tgz"
 
 # 2. 确认版本
 & $DSH plugin --profile desktop list --depth 0
@@ -129,7 +129,7 @@ $NODE = '<DSH 安装目录>\resources\runtime\primary-runtime\dependencies\node\
 
 ## 版本与边界
 
-- 本套文档对应 **1.6.4** 的本地 tgz（1.6.0 起包名由 `dsh-session-longlive` 改为 `dsh-longlive`；
+- 本套文档对应 **1.6.5** 的本地 tgz（1.6.0 起包名由 `dsh-session-longlive` 改为 `dsh-longlive`；
   1.6.4 起发布名改为 scoped 包 `@jjh32456/dsh-longlive`）。
   **1.6.3 起新增热截断**：一个不调 LLM 的 cut-only 压缩引擎，通过 bundle patch 关掉宿主 stock
   `compaction-basic` 行并插入 `compaction-hot-truncate`；只切「已完成、且早于保留窗口（默认 4 轮 /

package/SPEC.md

@@ -1,11 +1,11 @@
-# 插件规格：@jjh32456/dsh-longlive（久视）
+# 插件规格：@jjh32456/dsh-longlive（久视）
 
 > 命名（2026-11-06 改）：发布包名 **@jjh32456/dsh-longlive**（1.6.4 起 scoped 发布名；
 > 1.6.0–1.6.3 为 `dsh-longlive`），显示名「久视」（英文 Longlive）。原名
 > `dsh-session-longlive`（2026-10-30 定），1.6.0 起迁移；拼写是 longlive，不是 longevity。
 >
-> 当前版本：**1.6.4**（1.6.0 改名基座 + 1.6.3 热截断 + 1.6.4 的 300k 触发 / 保留 4 轮与
-> 可移植性收口；D2/D6 默认关闭；安装包 `dist/jjh32456-dsh-longlive-1.6.4.tgz`）。
+> 当前版本：**1.6.5**（1.6.0 改名基座 + 1.6.3 热截断 + 1.6.4 的 300k 触发 / 保留 4 轮与
+> 可移植性收口；D2/D6 默认关闭；安装包 `dist/jjh32456-dsh-longlive-1.6.5.tgz`）。
 
 ## 零、安全性承诺（2026-10-30 要求：不能出错，出错就死了）
 

package/docs/CONFIG.md

@@ -1,6 +1,6 @@
-# CONFIG.md — @jjh32456/dsh-longlive（久视）配置手册
+# CONFIG.md — @jjh32456/dsh-longlive（久视）配置手册
 
-适用版本：**1.6.4**（以包内 `package.json` 的 `version` 为准）。所有默认值以该源码树为准。
+适用版本：**1.6.5**（以包内 `package.json` 的 `version` 为准）。所有默认值以该源码树为准。
 读者：会改 YAML、会看日志，但没参与开发的人。
 
 ---

package/docs/DEV.md

@@ -1,4 +1,4 @@
-# @jjh32456/dsh-longlive — session longevity for DSH
+# @jjh32456/dsh-longlive — session longevity for DSH
 
 中文名：**会话长寿**。给 DeepSeek Harness 的宿主插件。
 
@@ -11,12 +11,12 @@
 五步版见 [QUICKSTART.md](../QUICKSTART.md)。最短路径（tgz 已在手，CLI 不需要会话权限）：
 
 ```powershell
-& $DSH plugin --profile <profile> add "file:C:/path/to/jjh32456-dsh-longlive-1.6.4.tgz"
-& $DSH plugin --profile <profile> list --depth 0      # 应显示 @1.6.4
+& $DSH plugin --profile <profile> add "file:C:/path/to/jjh32456-dsh-longlive-1.6.5.tgz"
+& $DSH plugin --profile <profile> list --depth 0      # 应显示 @1.6.5
 ```
 
 `$DSH` 指 DSH 安装目录里的 `resources\runtime\cli\bin\dsh.cmd`（干净机器的 PATH 里通常没有它）。
-从源码安装则先 `& $NODE scripts\pack.mjs --expect-version 1.6.4`；`$NODE` 指 DSH 安装目录里的
+从源码安装则先 `& $NODE scripts\pack.mjs --expect-version 1.6.5`；`$NODE` 指 DSH 安装目录里的
 `resources\runtime\primary-runtime\dependencies\node\bin\node.exe`（>=20）。
 会话内也可以 `plugin_manager action=install_bundle target="file:<绝对路径>"`，但那需要
 danger-full-access 或逐次批准。

package/docs/FAQ.md

@@ -1,4 +1,4 @@
-# 常见问题（FAQ）
+# 常见问题（FAQ）
 
 **读完你会得到什么**：装完没反应、侧栏不见了、401/404、剪完变少、换电脑、断电、卸载这些最常见的情况，能自己判断「是正常、是没装好，还是该回滚」。
 
@@ -8,7 +8,7 @@
 
 大概率是正常的。这个插件**没有自带界面**，默认 `mode: "log"` 也只会在后台写一行评估日志，不会弹窗、不会剪东西。
 
-按顺序确认：`dsh plugin --profile desktop list --depth 0` 有 `@jjh32456/dsh-longlive@1.6.4`；doctor 没有硬错误（退出码 0，或只有 engram 缺失导致的 1）；重启后新会话里能数到 22 个工具；聊到超过阈值后，`%USERPROFILE%\.dsh\longlive-memory\.longlive\logs\auto-truncate.log` 才出现评估行（默认阈值 300000，所以短时间内没有是正常的）。
+按顺序确认：`dsh plugin --profile desktop list --depth 0` 有 `@jjh32456/dsh-longlive@1.6.5`；doctor 没有硬错误（退出码 0，或只有 engram 缺失导致的 1）；重启后新会话里能数到 22 个工具；聊到超过阈值后，`%USERPROFILE%\.dsh\longlive-memory\.longlive\logs\auto-truncate.log` 才出现评估行（默认阈值 300000，所以短时间内没有是正常的）。
 
 如果这四样都没有，先看宿主启动 stderr 有没有 `1 entry did not activate`。
 
@@ -92,7 +92,7 @@
 
 四个独立证据，至少看到两个：
 
-1. `plugin list` 显示 `@1.6.4`；
+1. `plugin list` 显示 `@1.6.5`；
 2. doctor 没有硬错误（0，或只有 engram 缺失导致的 1）；
 3. 新会话能调用 `session_health`，返回里有 `sessionPath` / `events` / `visibleMessages`；
 4. 聊到超过阈值后，`auto-truncate.log` 出现评估行（`action` 是 `planned` / `dryrun-planned` / `none` 都算插件在评估）。

package/docs/FEATURES.md

@@ -1,4 +1,7 @@
-# 1.6.4 可选能力与开关
+# 1.6.5 可选能力与开关
+
+1.6.5 是热截断热修复：被宿主重启中断过的会话（存在 closed-but-not-completed 轮次）不会再
+永久失去自动切刀；计划会从被中断轮次之后继续找可切的已完成轮。其余行为与 1.6.4 相同。
 
 1.6.4 在 1.6.0 改名基座之上加入**热截断**（cut-only `CompactionEngine`：只切已完成且早于
 保留窗口的整轮，不调 LLM，原始事件不动，只追加一条覆盖率指针；默认 `mode=cut`，自动切达到

package/docs/QUICKSTART.md

@@ -1,8 +1,8 @@
-# 从零到第一次截断（QUICKSTART）
+# 从零到第一次截断（QUICKSTART）
 
 **读完你会得到什么**：从一台已经装好 DSH 的 Windows 机器出发，装好 longlive，用 `dryrun` 看它「打算怎么剪」，再切到 `request`，最后安全地完成第一次真截断，并且知道怎么退回去。
 
-> 适合谁：第一次拿到 `jjh32456-dsh-longlive-1.6.4.tgz` 的人。全程约 20 分钟，其中真截断那一步应用会自己关闭再打开（VM 实测约 31.5 秒），请挑你不用电脑的时候做。
+> 适合谁：第一次拿到 `jjh32456-dsh-longlive-1.6.5.tgz` 的人。全程约 20 分钟，其中真截断那一步应用会自己关闭再打开（VM 实测约 31.5 秒），请挑你不用电脑的时候做。
 >
 > 本文默认 DSH home 是 `%USERPROFILE%\.dsh`；如果你设过 `DSH_HOME`，把命令里的这段整体换掉。
 
@@ -25,14 +25,14 @@ $NODE = '<DSH 安装目录>\resources\runtime\primary-runtime\dependencies\node\
 ## 1. 装插件：三条命令
 
 ```powershell
-$TGZ = 'C:/path/jjh32456-dsh-longlive-1.6.4.tgz'   # 换成真实绝对路径
+$TGZ = 'C:/path/jjh32456-dsh-longlive-1.6.5.tgz'   # 换成真实绝对路径
 
 & $DSH plugin --profile desktop add "file:$TGZ"
 & $DSH plugin --profile desktop list --depth 0
 & $NODE "$env:USERPROFILE\.dsh\profiles\desktop\node_modules\@jjh32456\dsh-longlive\scripts\longlive-doctor.mjs" --profile desktop
 ```
 
-**你应该看到**：`list` 里出现 `@jjh32456/dsh-longlive@1.6.4`；doctor 打印一张表，最后是「全部可选依赖已启用。」或只有 engram 缺失的提示。
+**你应该看到**：`list` 里出现 `@jjh32456/dsh-longlive@1.6.5`；doctor 打印一张表，最后是「全部可选依赖已启用。」或只有 engram 缺失的提示。
 
 **报错了怎么办**：
 - `ENOENT` → `file:` 后面必须是**真实存在的绝对路径**，用正斜杠；不要把 `~` 写进去。

package/docs/README.en.md

@@ -14,7 +14,7 @@ A DeepSeek Harness plugin that keeps a long session healthy: **inspect it, back
 ```powershell
 $DSH  = '<DSH install>\resources\runtime\cli\bin\dsh.cmd'
 $NODE = '<DSH install>\resources\runtime\primary-runtime\dependencies\node\bin\node.exe'
-& $DSH plugin --profile desktop add "file:C:/path/jjh32456-dsh-longlive-1.6.4.tgz"
+& $DSH plugin --profile desktop add "file:C:/path/jjh32456-dsh-longlive-1.6.5.tgz"
 & $DSH plugin --profile desktop list --depth 0
 & $NODE "$env:USERPROFILE\.dsh\profiles\desktop\node_modules\@jjh32456\dsh-longlive\scripts\longlive-doctor.mjs" --profile desktop
 ```

package/docs/TROUBLESHOOTING.md

@@ -1,4 +1,4 @@
-# TROUBLESHOOTING.md — 按症状查（1.6.4）
+# TROUBLESHOOTING.md — 按症状查（1.6.5）
 
 用法：先看「症状」，对不上再看「最可能原因」。每条只给**一条**验证命令——先确认判断，再动手。
 「什么时候该停手」比「怎么修」更重要：结构一旦不对，继续重试只会扩大损失。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jjh32456/dsh-longlive",
-  "version": "1.6.4",
+  "version": "1.6.6",
   "type": "module",
   "description": "久视（longlive）：一个磁盘上的共享大脑，让每个会话都是同一个你——记忆卡、状态卡、开机卡让新会话接上同一段关系与未完成的事；配套会话卫生（热截断/备份/D2/D6 裁剪）与记忆工具（巩固/召回/程序性记忆）。1.6.4 修复记忆根可移植性（默认根 = <DSH home>/longlive-memory，一处配置贯穿全部落盘），并同步面板 0.2.5 文案与 G1-G4 修复。",
   "keywords": [

package/src/compaction/engine-core.js

@@ -370,8 +370,9 @@ export function selectCutPlan(session, options, measurement, helpers = {}) {
   };
 
   // Walk backwards until the retained suffix satisfies BOTH limits. A turn
-  // that is not completed is never part of the retained *window*, so it also
-  // cannot be cut; the scan still counts it as a completed-turn boundary stop.
+  // that is not completed counts toward the token budget but never toward the
+  // completed-turn floor, so the retained suffix may temporarily hold a few
+  // extra turns while a closed aborted turn sits inside the window.
   let keptTurns = 0;
   let keptTokens = 0;
   let boundary = -1;
@@ -390,7 +391,46 @@ export function selectCutPlan(session, options, measurement, helpers = {}) {
   const surfaceNodes = session?.surface?.nodes ?? [];
   if (surfaceNodes.length === 0) return null;
 
-  // Never include a leading system prompt in the replaced span.
+  // 2026-11-06 1.6.6 hotfix — the aborted-turn freeze, second attempt.
+  //
+  // 1.6.5 stopped an aborted/unfinished turn from returning null, but it kept
+  // the old "never cut an aborted turn" rule: the span was moved *after* the
+  // last aborted turn in the prefix. When aborted turns recur near the tail
+  // (restart-aborted / interrupted turns; real session 2026-11-06: turns 48,
+  // 74, 85, 90, 94), the last one sits right before the retention boundary, so
+  // the plan degenerates to "cut the single completed turn after it" (6–18k
+  // tokens) while every older completed turn (≈370k tokens) stays pinned in
+  // the surface as a permanent prefix. That is the exact shape of the
+  // 396k-token context.
+  //
+  // A turn with a `turn/end` event is closed: it never gains new events, its
+  // tool pairs are complete by construction, and cutting it whole keeps the
+  // pairing balanced. Only a turn with no `turn/end` yet (the currently open
+  // turn, or a turn the log was truncated inside) must stay in place. So the
+  // span may now cover closed-but-not-completed turns; `cutTurnGroups` below
+  // includes them and the archive copies the full turn range via byNumber.
+  const groupStart = new Array(groups.length);
+  const groupEnd = new Array(groups.length);
+  const groupOfPosition = new Array(surfaceNodes.length);
+  {
+    let cursor = 0;
+    for (let index = 0; index < groups.length; index += 1) {
+      groupStart[index] = cursor;
+      for (let offset = 0; offset < groups[index].seqs.length; offset += 1) groupOfPosition[cursor++] = index;
+      groupEnd[index] = cursor - 1;
+    }
+  }
+  const turnInfoOf = (group) => (group.kind === 'turn' && group.turn !== 0 ? table.byNumber.get(group.turn) : undefined);
+  const isOpenGroup = (group) => {
+    if (group.kind !== 'turn') return false;
+    if (group.turn === 0) return true;
+    const info = turnInfoOf(group);
+    return info === undefined || info.endSeq === null;
+  };
+
+  // The head of the surface is the real system prompt: the host protects
+  // position 0 and this engine keeps the whole leading run of system/message
+  // nodes in place. The span starts at the first user/assistant node after it.
   let startIndex = 0;
   while (startIndex < surfaceNodes.length
     && table.bySeq.get(surfaceNodes[startIndex])?.type === 'system/message') {
@@ -404,40 +444,64 @@ export function selectCutPlan(session, options, measurement, helpers = {}) {
     startIndex += 1;
   }
   if (startIndex >= surfaceNodes.length) return null;
-
-  // The cut prefix is groups[0..boundary); their surface lengths sum to the
-  // last positional index that belongs to the prefix.
-  let endIndex = -1;
-  for (let index = 0; index < boundary; index += 1) endIndex += groups[index].seqs.length;
-  if (endIndex < startIndex) return null;
-
-  // An aborted/unfinished turn is never cut; stop before its surface group.
-  for (let index = 0; index < boundary; index += 1) {
-    const group = groups[index];
-    if (group.kind === 'turn' && group.turn !== 0 && !group.completed) {
-      endIndex = Math.min(endIndex, surfaceNodes.indexOf(group.seqs[0]) - 1);
-      break;
+  // A leading group may start with the injected system prompt and continue with
+  // the turn's own nodes. The system nodes stay outside; the span starts at the
+  // first non-system node of that group — the skipped prefix is system-only, so
+  // no user/assistant/tool node is left half-cut. A group whose head contains
+  // non-system nodes is kept whole instead.
+  let startGroup = groupOfPosition[startIndex];
+  while (startGroup < groups.length && groupStart[startGroup] < startIndex) {
+    let systemOnlyHead = true;
+    for (let position = groupStart[startGroup]; position < startIndex; position += 1) {
+      if (table.bySeq.get(surfaceNodes[position])?.type !== 'system/message') { systemOnlyHead = false; break; }
+    }
+    if (systemOnlyHead) break;
+    startIndex = groupEnd[startGroup] + 1;
+    while (startIndex < surfaceNodes.length) {
+      const type = table.bySeq.get(surfaceNodes[startIndex])?.type;
+      if (type === 'user/message' || type === 'assistant/message') break;
+      startIndex += 1;
     }
+    if (startIndex >= surfaceNodes.length) return null;
+    startGroup = groupOfPosition[startIndex];
   }
 
-  // The host tolerates later system nodes inside a replacement range, but this
-  // engine promises never to cut one — and never to leave half a turn behind.
-  // A system node inside the candidate span therefore excludes its whole turn.
-  for (let index = startIndex; index <= endIndex; index += 1) {
-    if (table.bySeq.get(surfaceNodes[index])?.type !== 'system/message') continue;
-    const seq = surfaceNodes[index];
-    const owner = groups.find((group) => group.seqs.includes(seq));
-    const ownerStart = owner === undefined ? index : surfaceNodes.indexOf(owner.seqs[0]);
-    endIndex = Math.min(endIndex, ownerStart - 1);
-    break;
+  // Cut everything older than the retention boundary, minus groups that must
+  // stay in place: the currently open/unclosed turn and groups without a turn
+  // record are never part of the span. Every other group is cut whole. This is
+  // what lets a closed aborted turn be removed together with its neighbours
+  // instead of acting as a barrier the span has to jump over.
+  let endGroup = boundary - 1;
+  let blockedAt = -1;
+  for (let index = startGroup; index <= endGroup; index += 1) {
+    if (isOpenGroup(groups[index])) { blockedAt = index; break; }
   }
-  if (endIndex < startIndex) return null;
-
+  if (blockedAt >= 0) endGroup = blockedAt - 1;
+  if (endGroup < startGroup) return null;
+  const endIndex = groupEnd[endGroup];
+
+  // A system/message node *inside* the span is a host-restart re-injection of
+  // the same prompt (the protected copy is position 0, handled above). The
+  // previous revision excluded the whole containing turn; in the real session
+  // that pinned turns 66/72/75 (≈100k tokens of ordinary dialogue carrying one
+  // injected copy each) outside every future cut, so the context could never
+  // reach the retention window. The host tolerates later system nodes inside a
+  // replacement range, so an injected copy is archived together with the old
+  // prefix it belongs to. Nodes before the span start are never touched.
   const shadowedSeqs = surfaceNodes.slice(startIndex, endIndex + 1);
   const shadowedSet = new Set(shadowedSeqs);
   const touchedGroups = groups.filter((group) => group.seqs.some((seq) => shadowedSet.has(seq)));
-  if (touchedGroups.some((group) => group.kind === 'turn' && group.turn !== 0 && !group.completed)) return null;
-  const cutTurnGroups = touchedGroups.filter((group) => group.kind === 'turn' && group.turn !== 0 && group.completed);
+  if (touchedGroups.some((group) => isOpenGroup(group))) return null;
+  for (const group of touchedGroups) {
+    if (group.kind !== 'turn') continue;
+    const missing = group.seqs.filter((seq) => !shadowedSet.has(seq));
+    if (missing.some((seq) => table.bySeq.get(seq)?.type !== 'system/message')) return null;
+  }
+  const cutTurnGroups = touchedGroups.filter((group) => {
+    if (group.kind !== 'turn' || group.turn === 0) return false;
+    const info = turnInfoOf(group);
+    return info !== undefined && info.endSeq !== null;
+  });
   if (cutTurnGroups.length === 0) return null;
 
   // Archive every original event of the cut turns, plus any checkpoint node
@@ -648,7 +712,7 @@ export function buildPointerText(facts) {
   const range = firstTurn === lastTurn ? `第 ${firstTurn} 轮` : `第 ${firstTurn}–${lastTurn} 轮`;
   const lines = [
     `本会话共 ${totalTurns} 轮，其中 ${archivedTurns} 轮已压缩归档；需要原文用 session_original(turn=…) 或读归档路径：${archivePath}`,
-    `本次热截断切掉${range}（${cutTurnCount} 轮 / ${shadowedTokenCount} tokens / ${surfaceEventCount} 个表面事件）；只切已完成且早于保留窗口的轮，切点之后的原文未动。`,
+    `本次热截断切掉${range}（${cutTurnCount} 轮 / ${shadowedTokenCount} tokens / ${surfaceEventCount} 个表面事件）；只切已结束且早于保留窗口的轮（含被中止/中断的旧轮），当前未完成的轮不切，切点之后的原文未动。`,
     `归档：${eventCount} 条原始事件（JSONL，每行含 seq/turn/原始消息）` + (sha256 ? `，sha256=${sha256.slice(0, 16)}…` : '') + '。',
     `保留窗口：最近 ${retainTurns} 个已完成轮、至少 ${retainTokens} tokens（本次保留 ${retainedTurns} 轮）。`,
   ];

package/test/hot-truncate.test.mjs

@@ -11,7 +11,8 @@
 //                 mode=off, live-compact deference and no-op degradation.
 //
 // What is pinned here:
-//   * an open / aborted turn is never cut;
+//   * an open turn is never cut; a closed aborted turn is cut whole with the
+//     old prefix (1.6.6: it used to be a barrier that pinned everything);
 //   * only turns older than retainTurns AND retainTokens are cut;
 //   * the cut point and later surface text are untouched (only a prefix shrinks);
 //   * the archive contains every original event of the cut turns with a
@@ -395,20 +396,169 @@ test('H2 retainTurns and retainTokens both gate the cut', async () => {
   assert.equal(tokenDominant.surface.nodes.length, 1 + 10);
 });
 
-test('H3 an aborted turn blocks the prefix but never gets cut itself', async () => {
+test('H3 closed aborted turns are cut with the old prefix and never freeze later cuts', async () => {
   const session = new MockSession();
   for (let turn = 1; turn <= 3; turn += 1) addTurn(session, turn, { completed: false });
   for (let turn = 4; turn <= 9; turn += 1) addTurn(session, turn, { completed: true });
-  const { engine } = engineFor({ archiveDir: caseDir('archive') });
+  addTurn(session, 10, { open: true });
+  // 1.6.6 hotfix: 1.6.5 still skipped past aborted turns, so when aborted turns
+  // recur near the tail the span collapsed to "the one completed turn after the
+  // last aborted turn" (the 396k-token bug). A turn with turn/end is closed and
+  // cuttable as a whole, so the prefix is removed in one plan.
+  const dir = caseDir('archive');
+  const { engine } = engineFor({ archiveDir: dir, perEvent: 5000, retainTurns: 4, retainTokens: 0, autoMinTokens: 0 });
   const result = await engine.compactIfNeeded(makeAgent(session), 'pressure', new AbortController().signal);
-  assert.equal(result, null, 'the aborted turn-1 prefix is not a legal completed-only cut');
-  assert.equal(pointerEvents(session).length, 0);
+  assert.ok(result, 'aborted turns must not block the prefix cut');
+  assert.equal(result.shadowedSeqs.length, 10, 'turns 1-5 (2 surface nodes each) are cut');
+  const archive = readArchive(path.join(dir, fs.readdirSync(dir).find((name) => name.endsWith('.jsonl'))));
+  assert.deepEqual(archive.header.cutTurns.map((entry) => entry.turn), [1, 2, 3, 4, 5]);
+  assert.equal(pointerEvents(session).length, 1);
+  // Only the four retained completed turns and the open turn stay.
+  assert.equal(session.surface.nodes.length, 1 + 8 + 2);
+  const summary = pointerEvents(session)[0];
+  const pointer = session.events[summary.seq + 1];
+  assert.match(pointer.data.content[0].text, /第 1–5 轮/);
 });
 
 // ---------------------------------------------------------------------------
 // Archive
 // ---------------------------------------------------------------------------
 
+test('H3b a mid-turn system node is archived with its old prefix instead of freezing the plan', async () => {
+  // 1.6.6: 1.6.5 kept the whole turn containing a host-injected system node in
+  // place and started the span after it. When such injections land inside
+  // several completed turns (every host restart re-emits the prompt mid-turn),
+  // that rule pinned ≈100k tokens permanently: real session 2026-11-06 turns
+  // 66/72/75. The protected copy is the leading one at surface 0 (see H28); a
+  // later injected copy is host-tolerated inside a replacement range, so it is
+  // archived with the prefix it belongs to.
+  const session = new MockSession();
+  for (let turn = 1; turn <= 3; turn += 1) addTurn(session, turn, { completed: false });
+  session.append('turn/start', { turn: 4 });
+  session.append('assistant/message', {
+    turn: 4,
+    step: 1,
+    message: {
+      id: 'assistant-4',
+      role: 'assistant',
+      source: { kind: 'model', provider: 'test', model: 'test' },
+      content: [{ type: 'text', text: '第 4 轮回答（前面是重启中断）' }],
+    },
+  }, { surfaceOp: 'append' });
+  session.append('system/message', {
+    turn: 4,
+    step: 2,
+    message: {
+      id: 'system-4',
+      role: 'system',
+      source: { kind: 'system-prompt' },
+      content: [{ type: 'text', text: 'A host-injected system message mid-turn.' }],
+    },
+  }, { surfaceOp: 'append' });
+  session.append('user/message', {
+    id: 'user-4b',
+    role: 'user',
+    content: [{ type: 'text', text: '第 4 轮用户追问' }],
+    source: { kind: 'user', clientTimeZone: 'Asia/Shanghai' },
+  }, { surfaceOp: 'append' });
+  session.append('turn/end', { turn: 4, reason: { kind: 'completed' } });
+  for (let turn = 5; turn <= 10; turn += 1) addTurn(session, turn, { completed: true });
+  addTurn(session, 11, { open: true });
+  const dir = caseDir('archive');
+  const { engine } = engineFor({ archiveDir: dir, perEvent: 5000, retainTurns: 4, retainTokens: 0, autoMinTokens: 0 });
+  const result = await engine.compactIfNeeded(makeAgent(session), 'pressure', new AbortController().signal);
+  assert.ok(result, 'a mid-turn system node must not freeze the prefix cut');
+  assert.equal(result.shadowedSeqs.length, 13, 'turns 1-6 (2+2+2+3+2+2 surface nodes) are cut');
+  const archive = readArchive(path.join(dir, fs.readdirSync(dir).find((name) => name.endsWith('.jsonl'))));
+  assert.deepEqual(archive.header.cutTurns.map((entry) => entry.turn), [1, 2, 3, 4, 5, 6]);
+  assert.equal(session.surface.nodes.length, 1 + 8 + 2, 'pointer + four retained turns + open turn');
+  const summary = pointerEvents(session)[0];
+  const pointer = session.events[summary.seq + 1];
+  assert.match(pointer.data.content[0].text, /第 1–6 轮/);
+});
+
+test('H30 a mid-surface aborted turn does not collapse the plan to one turn (396k regression)', async () => {
+  // Real session 2026-11-06 shape: the log has many completed turns, one
+  // restart-aborted turn near the tail, and the retention boundary right after
+  // it. 1.6.5 moved the span past the aborted turn, so the cut became "one
+  // completed turn / 6-18k tokens" while the whole older prefix stayed. The
+  // new planner must cut the entire prefix, aborted turn included, so that
+  // only the four retained completed turns and the open turn are left.
+  const session = new MockSession();
+  for (let turn = 1; turn <= 10; turn += 1) addTurn(session, turn, { completed: true });
+  addTurn(session, 11, { completed: false }); // aborted, closed
+  for (let turn = 12; turn <= 20; turn += 1) addTurn(session, turn, { completed: true });
+  addTurn(session, 21, { open: true });
+  const dir = caseDir('archive');
+  const { engine } = engineFor({ archiveDir: dir, perEvent: 5000, retainTurns: 4, retainTokens: 0, autoMinTokens: 0 });
+  const result = await engine.compactIfNeeded(makeAgent(session), 'pressure', new AbortController().signal);
+  assert.ok(result);
+  assert.equal(result.shadowedSeqs.length, 32, '16 turns x 2 surface nodes, aborted turn included');
+  const archive = readArchive(path.join(dir, fs.readdirSync(dir).find((name) => name.endsWith('.jsonl'))));
+  assert.deepEqual(archive.header.cutTurns.map((entry) => entry.turn), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+  // pointer + turns 17-20 (8 nodes) + open turn 21 (2 nodes)
+  assert.equal(session.surface.nodes.length, 1 + 8 + 2);
+  const abortedUser = session.events.find((event) => event.type === 'user/message' && event.data.id === 'user-11');
+  assert.equal(session.surface.nodes.includes(abortedUser.seq), false, 'the aborted turn left the surface');
+  const openUser = session.events.find((event) => event.type === 'user/message' && event.data.id === 'user-21');
+  assert.equal(session.surface.nodes.includes(openUser.seq), true, 'the open turn is never cut');
+  assert.match(result.summary[0].text, /第 1–16 轮/);
+});
+
+test('H30b real-session shape: head system + mid-surface injected system + aborted turns', async () => {
+  // Mirrors session-e219dedf on 2026-11-06: the real system prompt sits at
+  // surface 0 and must stay; a restart injects a second system/message in the
+  // middle of the surface (inside turn 12); several turns are aborted; the
+  // current turn is open. A single cut must remove the whole old prefix and
+  // leave exactly the four retained completed turns plus the open turn.
+  const session = new MockSession();
+  addTurnWithSystemHead(session, 1);
+  for (let turn = 2; turn <= 20; turn += 1) {
+    if (turn === 12) {
+      session.append('turn/start', { turn: 12 });
+      session.append('user/message', {
+        id: 'user-12', role: 'user', content: [{ type: 'text', text: '第 12 轮用户消息' }],
+        source: { kind: 'user', clientTimeZone: 'Asia/Shanghai' },
+      }, { surfaceOp: 'append' });
+      session.append('assistant/message', {
+        turn: 12, step: 1,
+        message: {
+          id: 'assistant-12', role: 'assistant',
+          source: { kind: 'model', provider: 'test', model: 'test' },
+          content: [{ type: 'text', text: '第 12 轮回答' }],
+        },
+      }, { surfaceOp: 'append' });
+      session.append('system/message', {
+        turn: 12, step: 2,
+        message: {
+          id: 'system-12', role: 'system', source: { kind: 'system-prompt' },
+          content: [{ type: 'text', text: 'You are an AI agent powered by DeepSeek Harness.' }],
+        },
+      }, { surfaceOp: 'append' });
+      session.append('turn/end', { turn: 12, reason: { kind: 'completed' } });
+      continue;
+    }
+    if (turn === 8 || turn === 15) addTurn(session, turn, { completed: false });
+    else addTurn(session, turn, { completed: true });
+  }
+  addTurn(session, 21, { open: true });
+  const systemEvent = session._events.find((event) => event.type === 'system/message');
+  const injected = session._events.filter((event) => event.type === 'system/message')[1];
+  assert.ok(systemEvent && injected);
+  const dir = caseDir('archive');
+  const { engine } = engineFor({ archiveDir: dir, perEvent: 5000, retainTurns: 4, retainTokens: 0, autoMinTokens: 0 });
+  const result = await engine.compactIfNeeded(makeAgent(session), 'pressure', new AbortController().signal);
+  assert.ok(result, 'the 396k shape must produce a plan');
+  const archive = readArchive(path.join(dir, fs.readdirSync(dir).find((name) => name.endsWith('.jsonl'))));
+  assert.deepEqual(archive.header.cutTurns.map((entry) => entry.turn), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+  assert.equal(result.shadowedSeqs.includes(systemEvent.seq), false, 'the head system prompt is never cut');
+  assert.equal(result.shadowedSeqs.includes(injected.seq), true, 'the injected copy goes with the old prefix');
+  assert.equal(session.surface.nodes[0], systemEvent.seq, 'head system prompt stays at surface 0');
+  // head system + pointer + four retained turns (8 nodes) + open turn (2 nodes)
+  assert.equal(session.surface.nodes.length, 1 + 1 + 8 + 2);
+  assert.equal(session.surface.nodes.includes(injected.seq), false, 'injected copy left the surface');
+});
+
 test('H4 archive: atomic JSONL, exact event count, sha256, append-only', async () => {
   const dir = caseDir('archive');
   const session = buildSession(9, { openLast: false });
@@ -470,7 +620,7 @@ test('H5 pointer text carries N/M, session_original(turn=…), and the archive p
   const text = result.summary[0].text;
   assert.match(text, /本会话共 9 轮，其中 3 轮已压缩归档；需要原文用 session_original\(turn=…\) 或读归档路径：/);
   assert.ok(text.includes(dir), 'archive directory is in the pointer');
-  assert.match(text, /只切已完成且早于保留窗口的轮/);
+  assert.match(text, /只切已结束且早于保留窗口的轮/);
   assert.match(text, /保留窗口：最近 6 个已完成轮、至少 0 tokens（本次保留 6 轮）/);
 
   const pointerEvent = session.events[result.summarySeq + 1];
@@ -531,7 +681,12 @@ test('H28 a system prompt at surface 0 is never cut; the pointer lands at positi
   assert.equal(parsed.header.cutTurns[0].startSeq, 0, 'the archive still covers the whole turn');
 });
 
-test('H29 a system message inside the candidate span stops the cut before its turn', async () => {
+test('H29 a mid-span host-injected system message is archived with the old prefix', async () => {
+  // 1.6.6: the head system prompt is still never cut (H28). A host-injected
+  // system/message in the middle of the surface is a duplicate re-emitted by a
+  // restart; the host tolerates it inside a replacement range, and keeping it
+  // outside pinned every following turn forever. It is archived with the old
+  // prefix instead of stopping the cut before its turn.
   const session = new MockSession();
   addTurn(session, 1);
   addTurnWithSystemInside(session, 2);
@@ -541,12 +696,12 @@ test('H29 a system message inside the candidate span stops the cut before its tu
   const dir = caseDir('archive');
   const { engine } = engineFor({ archiveDir: dir });
   const result = await engine.compactNow(makeAgent(session), new AbortController().signal);
-  assert.ok(result, 'the safe prefix before the system message is still cuttable');
-  assert.equal(result.shadowedSeqs.includes(systems[0].seq), false);
+  assert.ok(result, 'the old prefix is cuttable');
+  assert.equal(result.shadowedSeqs.includes(systems[0].seq), true, 'the injected copy is archived with the prefix');
   const file = fs.readdirSync(dir).find((name) => name.endsWith('.jsonl'));
   const parsed = readArchive(path.join(dir, file));
-  assert.deepEqual(parsed.header.cutTurns.map((entry) => entry.turn), [1], 'only turn 1 is cut');
-  assert.equal(session.surface.nodes.includes(systems[0].seq), true, 'the system node remains on the surface');
+  assert.deepEqual(parsed.header.cutTurns.map((entry) => entry.turn), [1, 2], 'turn 1 and the injected turn 2 are cut');
+  assert.equal(session.surface.nodes.includes(systems[0].seq), false, 'the injected copy left the surface with its turn');
 });
 
 test('H6 successive cuts update the cumulative archived count and fold the old pointer', async () => {

package/test/packaging.test.mjs

@@ -140,17 +140,17 @@ test('只带白名单安装后：没有 prototype，所有 src 相对 import 都
   assert.deepEqual(offenders, [], `存在跨出包目录/缺失的 import：\n${offenders.join('\n')}`);
 });
 
-test('R2-07 发布版本面：包版本 1.6.4，文档同步 D2/D6 能力集', () => {
-  assert.equal(PKG.version, '1.6.4');
+test('R2-07 发布版本面：包版本 1.6.5，文档同步 D2/D6 能力集', () => {
+  assert.equal(PKG.version, '1.6.5');
   const read = (rel) => fs.readFileSync(path.join(ROOT, rel), 'utf8');
   const en = read('docs/README.en.md');
   assert.ok(en.includes('@jjh32456/dsh-longlive-panel@0.2.5'), '面板版本未统一到 0.2.5（scoped 包名）');
-  assert.ok(en.includes('jjh32456-dsh-longlive-1.6.4.tgz'), '英文文档示例 tgz 不是 scoped 的 1.6.4');
+  assert.ok(en.includes('jjh32456-dsh-longlive-1.6.5.tgz'), '英文文档示例 tgz 不是 scoped 的 1.6.5');
   assert.ok(en.includes('@jjh32456/dsh-longlive'), '英文文档缺少 scoped 包名');
   assert.equal(en.includes('dsh-longlive-panel@0.1.3'), false, '英文文档仍残留 0.1.3');
   assert.equal(en.includes('0.9.0-rc.1'), false, '英文文档仍残留 rc.1');
   const features = read('docs/FEATURES.md');
-  assert.ok(features.startsWith('# 1.6.4'), 'FEATURES.md 标题不是 1.6.4');
+  assert.ok(features.startsWith('# 1.6.5'), 'FEATURES.md 标题不是 1.6.5');
   assert.equal(features.includes('0.9.0-rc.1'), false, 'FEATURES.md 仍残留 rc.1');
 });