dsh-live-compact 1.0.9 → 1.1.0

package/README.md

@@ -6,18 +6,26 @@ DSH 把压缩写死在大约 80%。不到这条线，上下文一直堆。到了
 
 为什么非要等到 80%？边做边压不行吗？
 
+## 云端和端侧
+
+云端（公网地址，如 DeepSeek、GLM）：装上即可。不要设置 `SPINE_THUNDER`。看题对不对，以及缓存命中。切点前面的原文不动。
+
+端侧（本机、内网、27B）：也可以装。不要设置 `SPINE_THUNDER`。不要拿云端缓存命中来要求它。看题对不对，以及切掉多少 token。本地服务没有云端那种前缀缓存，每次提问都会把当前上下文重新预填充。两万多是当前上下文的大小，不是插件没切。
+
+`SPINE_THUNDER` 默认关闭。只有设为 `1` 才走雷霆。再设 `SPINE_THUNDER_MODEL=27b` 时，前缀超过 8 万会每次都少发，一次雷霆变成次次雷霆。端侧不要开。
+
 超过 2 万 token 就切一刀。切的是刚结束的这一轮，不调用模型。切点前面的原文不动，缓存命中还是原来的水准。上下文因此一直被按在较低的位置。雷霆大压缩能拖就拖，拖到尽可能后面。就算哪天满了、真的触发了，掉下来之后小切还在，不会很快又堆回去。
 
 headless：
 
 ```sh
-dsh plugin --profile headless add dsh-live-compact@1.0.6
+dsh plugin --profile headless add dsh-live-compact@1.1.0
 ```
 
 网页和桌面端（共用 web profile，装一次两边都生效）：
 
 ```sh
-dsh plugin --profile web add dsh-live-compact@1.0.6
+dsh plugin --profile web add dsh-live-compact@1.1.0
 ```
 
 想先装到本机看版本：
@@ -27,6 +35,35 @@ npm install -g dsh-live-compact
 dsh-live-compact --version
 ```
 
+## 1.1.0
+
+1. Issue #19 里下一轮输入回到 21 万到 24 万、前缀被打掉的那一刀，是切点走到了已有卡片左边。1.1.0 把最新一张卡片当成地板。往左走到卡片就停。切点右边还有更新的卡片，这一刀不切。已进缓存的前缀不再被后面的刀改写。
+2. 同一次收尾可以连切，这是现有设计，没有改。改的是记账。以前每一刀都把尾巴算进重写，四刀就把同一段尾巴乘了四次。现在一次收尾只记一次：第一刀之后的前缀，减去后面几刀省下的。`dsh-live-compact stats` 的 `rewrite` 用这个数。逐刀明细在 shadow 目录的 `spine-cuts.jsonl`，只有序号、token 和切点，没有消息原文。
+3. 没有加「省下的必须盖过重写」这种新门槛。加了会把同一次收尾里后面的刀切掉。65 万停切线、收尾停在 3.2 万、`CHUNK_MIN` 默认 1000、云端默认 `0.8` / `65536` / `8192`，都没改。`SPINE_THUNDER` 仍是默认关闭。
+4. 今天桌面端长时间卡住，是每回合、每个工具结果都在拷贝整份会话日志，并反复计量。1.1.0 一个空闲回合只拷贝一次日志。工具结果到达时用已经记下的调用编号，不再为了查一次调用而拷贝整份日志。收尾循环复用这一次的任务和调用表。token 计量是开头一次，每真正切下一刀再测一次。没切的回合只测一次。切哪一段没改。
+
+## 门禁和复测
+
+`npm run test:gate` 已过。Issue #19 的卡片地板、一次收尾重写只记一次、65 万和 `CHUNK_MIN` 1000 不动，以及空闲时不再重扫全日志，都在这道门禁里。连模型的 8 组 31 轮没有重跑。这次不改填日志题的判分，也不改切哪一段。下面四张图是 1.0.9 那次实测，1.1.0 沿用。
+
+云端看题对不对，以及每轮第一个 `step_end` 的缓存命中。本地看题对不对和切掉的 token。DS V4.1 Flash，8 组，184/184，跳过 0，缓存 98.22%，题末最高 35334，切掉 97306，估算费用 $0.208。GLM 5.3 Flash，同一套 8 组，184/184，同一公式缓存 74.66%，切掉 481483。第 6、8 组几乎每轮只读一次全文，规则没有为它改。Coder 390 27B，3 组 31 轮，填日志 69/69，切掉 20635，都在第 30 轮。墙钟 29 分、20 分、86 分。费用是离峰用量估算，不是账单。
+
+![汇总分题](docs/slide-110-by-question.jpg)
+
+![DS V4.1 Flash](docs/slide-110-ds.jpg)
+
+![GLM 5.3 Flash](docs/slide-110-glm.jpg)
+
+![Coder 390 27B](docs/slide-110-390.jpg)
+
+## 1.0.9
+
+1. 云端和本地按当前配置里这一家的地址区分。请求头通常只有 provider 名。配置里的 `baseURL` 优先，没有再看官方 DeepSeek 和内置目录。公网地址按云端切，回环和内网按本地。读不到地址仍按本地。`SPINE_ENGINE=local` 或 `cloud` 可以强制指定。这不改官方大门的 headroom。
+2. 官方大压缩的三项可以在启动前用环境变量覆盖：`SPINE_THRESHOLD_RATIO`、`SPINE_HEADROOM_TOKENS`、`SPINE_RETAIN_TOKENS`。云端默认仍是 `0.8`、`65536`、`8192`，不按地址改小。TUI 的 `/settings` 没有这一项。要改当前配置，直接改 `cordis.patch.yml` 里的对应字段。
+3. 发版门禁是 `npm run test:gate`，不连模型。8 组 31 轮在 `test/live-fill`，要连模型。这两部分都在 GitHub 测试集里。
+4. 测评分两个口径。云端看题对不对，以及每轮第一个 `step_end` 的缓存命中。本地看题对不对和切掉的 token。DS V4.1 Flash，8 组，184/184，跳过 0，缓存 98.22%，题末最高 35334，切掉 97306，估算费用 $0.208。GLM 5.3 Flash，同一套 8 组，184/184，同一公式缓存 74.66%。Coder 390 27B，3 组 31 轮，填日志 69/69，切掉 20635。费用是离峰用量估算，不是账单。
+5. 安装用 npm 的 `dsh-live-compact@1.0.9`。上不了 npm 时用镜像包 https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.0.9.tgz 。页面在 https://download.merkyorlynn.com/live-compact.html 。测评图在当时的 [v1.0.9](https://github.com/Tranquillitatis-Lab/dsh-live-compact/releases/tag/v1.0.9)。
+
 ![边做边压](docs/slide-cover.jpg)
 
 ![为什么非要等到 80%](docs/slide-why.jpg)
@@ -92,32 +129,6 @@ dsh-live-compact --version
 
 ![原版对比](docs/slide-stock.jpg)
 
-## 1.0.9
-
-官方大压缩的三项预设参数可以在启动前用环境变量覆盖：`SPINE_THRESHOLD_RATIO`、`SPINE_HEADROOM_TOKENS`、`SPINE_RETAIN_TOKENS`。云端默认不动，仍是 `0.8`、`65536`、`8192`，不按地址自动改小。TUI 的 `/settings` 目前没有这一项。
-
-请求头通常只有 provider 名。云端和本地按这一家的地址区分：当前配置里的 `baseURL` 优先，没有再看官方 DeepSeek 和内置目录。公网地址按云端切，回环和内网按本地。读不到地址仍按本地，不猜。这不改官方大门的 headroom。`SPINE_ENGINE=local` 或 `cloud` 仍可强制指定。
-
-发版门禁是 `npm run test:gate`，不连模型。8 组 31 轮在 `test/live-fill`，要连模型。这两部分都在 GitHub 测试集里。Pi 移植不在这道门禁里。
-
-## 1.0.9 测评
-
-云端看题对不对，以及每轮第一个 `step_end` 的缓存命中 `cacheRead / (cacheRead + input)`。本地不看缓存命中，看题对不对和切掉的 token。切掉是 `shadowedTokenCount`。费用是离峰用量估算，不是账单。
-
-DS V4.1 Flash，8 组 31 轮。184/184，跳过 0。缓存命中 98.22%。题末最高 35334，平均 28984。切掉 97306。估算费用 $0.208。
-
-GLM 5.3 Flash，同一套 8 组。184/184，跳过 0。同一公式缓存命中 74.66%。第 6、8 组几乎每轮只 `read` 一次全文，刀落在三轮以前的那份全文上，前缀被改写。切掉 481483。这是模型用法，规则没有为它改。
-
-Coder 390 27B，只跑了 3 组 31 轮，没有八组并行。填日志 69/69。切掉 20635，都在第 30 轮：组 1 是 10503，组 2 是 5106，组 3 是 5026。墙钟 29 分、20 分、86 分。
-
-![汇总分题](docs/slide-109-by-question.jpg)
-
-![DS V4.1 Flash](docs/slide-109-ds.jpg)
-
-![GLM 5.3 Flash](docs/slide-109-glm.jpg)
-
-![Coder 390 27B](docs/slide-109-390.jpg)
-
 `cordis.patch.yml` 是静态整块替换，不读这三个环境变量。要在这里改 `headroomTokens`，需直接改配置块，例如：
 
 ```yaml
@@ -231,8 +242,8 @@ Coder 390 27B，只跑了 3 组 31 轮，没有八组并行。填日志 69/69。
 | `SPINE_SHADOW_MAX_BYTES` | 268435456 | 正数直接作为备份字节上限，优先于 `SPINE_SHADOW_MAX_MB`。 |
 | `SPINE_SHADOW_MAX_MB` | 256 | 未设置正数字节上限时，按 MB 设置备份上限。 |
 | `SPINE_ENGINE` | 自动识别 | 设为 `cloud` 或 `local` 可强制切法，其他值忽略。 |
-| `SPINE_THUNDER` | 关闭 | 设为 `1` 时启用雷霆摘要路径。 |
-| `SPINE_THUNDER_MODEL` | `flash` | 设为 `27b` 时使用对应模型类型，其他值仍为 `flash`。 |
+| `SPINE_THUNDER` | 关闭 | 设为 `1` 才走雷霆。端侧不要开。 |
+| `SPINE_THUNDER_MODEL` | `flash` | 设为 `27b` 且前缀超过 8 万时，每次官方压缩都少发。端侧不要设。 |
 | `SPINE_ENGINE_FAIL` | 无 | **仅供测试**：用 `import`、`construct`、`after-super` 注入引擎故障。 |
 | `SPINE_STOCK_FAIL` | 无 | **仅供测试**：设为 `1` 时禁止回退原版引擎。 |
 | `SPINE_CHUNK_MIN` | 1000 | 一刀至少包含的 token 数。 |
@@ -248,8 +259,8 @@ Coder 390 27B，只跑了 3 组 31 轮，没有八组并行。填日志 69/69。
 从 npm 装。headless 和网页是两个 profile，要各装一次。桌面端是另一个 profile，普通 `dsh plugin --profile desktop` 会被拒绝。
 
 ```sh
-dsh plugin --profile headless add dsh-live-compact@1.0.9
-dsh plugin --profile web add dsh-live-compact@1.0.9
+dsh plugin --profile headless add dsh-live-compact@1.1.0
+dsh plugin --profile web add dsh-live-compact@1.1.0
 ```
 
 想先装到本机看版本：
@@ -259,12 +270,12 @@ npm install -g dsh-live-compact
 dsh-live-compact --version
 ```
 
-备用：上不了 npm 的，用国内镜像站的包。1.0.2 到 1.0.8 的旧链接仍在。
+备用：上不了 npm 的，用国内镜像站的包。1.0.2 到 1.0.9 的旧链接仍在。
 
 ```sh
-dsh plugin --profile headless add https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.0.9.tgz
-dsh plugin --profile web add https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.0.9.tgz
-npm install -g --force "https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.0.9.tgz"
+dsh plugin --profile headless add https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.1.0.tgz
+dsh plugin --profile web add https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.1.0.tgz
+npm install -g --force "https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.1.0.tgz"
 dsh-live-compact --version
 ```
 
@@ -274,6 +285,8 @@ DSH-TUI 同样换不掉预设里的原版压缩，先不要装。
 
 被切掉的原文会写到 `~/.dsh/compaction-spine/shadow`，只有自己能读。上限 256MB。快满时删最老的备份。卡片里的序号是会话日志的事件号。要在当前会话的备份里找一行，用 `import { searchShadow } from "dsh-live-compact/shadow-search"`。
 
+`dsh-live-compact stats` 的 `saved` 是切完当下少掉的 token，`rewrite` 是同一次收尾实际要重写的尾巴，只记一次。同一步连切不会按刀数把尾巴乘上去。这两个数口径不同，比值不是盈亏。桌面端没有终端，`rg "spine cut"` 只在终端输出里找得到。逐刀明细在 shadow 目录的 `spine-cuts.jsonl`。
+
 改上限：
 
 ```sh

package/index.js

@@ -26,7 +26,7 @@ import { captureOwnedToolResult, rawExcerptText, restoreToolText, runPruneAfterC
 import {
   discardShadowFiles,
   ensureShadowDir,
-  recordCutStats,
+  flushDrainStats,
   rotateShadow,
   sessionDir,
   shadowFileBody,
@@ -236,13 +236,18 @@ function selectNewestChunk(session, measurement, key = DEFAULT_KEY, context = {}
   if (nodes.length === 0 || nodes.length !== priced.length) return null;
   const first = session.eventAt(nodes[0])?.type === "system/message" ? 1 : 0;
   let end = priced.length - 1;
+  let floorCard = -1;
+  for (let index = first; index <= end; index += 1) {
+    if (isCheckpoint(session, nodes[index])) floorCard = index;
+  }
   while (end >= first) {
+    if (floorCard >= 0 && end <= floorCard) return null;
     const event = session.eventAt(nodes[end]);
     const shortTail = event?.type === "assistant/message" || (event?.type === "user/message" && priced[end].tokens < 400);
     if (!shortTail) break;
     end -= 1;
   }
-  while (end >= first && isCheckpoint(session, nodes[end])) end -= 1;
+  if (floorCard >= 0 && end <= floorCard) return null;
   while (end >= first && !cutOk(toolPairingBalancedAfter, session, nodes[end])) end -= 1;
   let keptTokens = 0;
   const visible = [];
@@ -261,8 +266,14 @@ function selectNewestChunk(session, measurement, key = DEFAULT_KEY, context = {}
     const keptEnd = visible[span.end].index;
     for (let index = visible[span.start].index; index <= keptEnd; index += 1) keptTokens += priced[index].tokens;
     end = cutEnd;
-    while (end >= first && (isCheckpoint(session, nodes[end]) || isUser(session, nodes[end]))) end -= 1;
-    while (end >= first && !cutOk(toolPairingBalancedAfter, session, nodes[end])) end -= 1;
+    while (end >= first && isUser(session, nodes[end]) && !(floorCard >= 0 && end - 1 <= floorCard)) end -= 1;
+    if (floorCard >= 0 && end <= floorCard) return null;
+    if (isCheckpoint(session, nodes[end])) return null;
+    while (end >= first && !cutOk(toolPairingBalancedAfter, session, nodes[end])) {
+      if (floorCard >= 0 && end - 1 <= floorCard) return null;
+      end -= 1;
+    }
+    if (floorCard >= 0 && end <= floorCard) return null;
   }
   if (end < first || isCheckpoint(session, nodes[end])) return null;
   const spanPieces = (spanStart, spanEnd) => {
@@ -380,6 +391,8 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
   sessionState = new Map();
   shadowFullWarned = new Set();
   rawSeen = new Map();
+  callIndex = new Map();
+  captureCursor = new Map();
   pruneGuarded = false;
 
   constructor(ctx, config) {
@@ -392,6 +405,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
         await Promise.allSettled(pendingCuts);
       });
       ctx.on("session/event", (session, event) => {
+        this.noteEvent(session, event);
         if (event?.type !== "tool/result") return;
         this.captureOne(session, event);
       });
@@ -399,10 +413,11 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
         if (status !== "idle") return;
         const state = this.stateFor(agent);
         if (state.warming) return;
-        const done = agent.session.snapshotEvents().some((event) => event.type === "turn/end" && event.data?.reason?.kind === "completed");
+        const events = agent.session.snapshotEvents();
+        const done = events.some((event) => event.type === "turn/end" && event.data?.reason?.kind === "completed");
         if (!done) return;
         state.warming = true;
-        const job = this.finishTurn(agent).finally(() => {
+        const job = this.finishTurn(agent, events).finally(() => {
           state.warming = false;
           pendingCuts.delete(job);
         });
@@ -456,13 +471,17 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
     return planMessages(messages);
   }
 
-  async finishTurn(agent) {
+  async finishTurn(agent, events) {
     const state = this.stateFor(agent);
     const signal = AbortSignal.timeout(30000);
+    const ev = events || agent.session.snapshotEvents();
+    this.captureNew(agent.session, ev);
+    const jobs = collectJobs(ev);
+    const calls = indexToolCalls(ev);
     try {
       await agent.runMaintenance(async (agentSignal) => {
         const op = AbortSignal.any([agentSignal, signal]);
-        const measurement = this.ctx.tokenMeter.measure(agent.session);
+        let measurement = this.ctx.tokenMeter.measure(agent.session);
         if (measurement.totalTokens < MIN_PRESSURE || measurement.totalTokens >= BIG_GATE) return;
         // 官方压缩后的第一次 idle 先让一让，免得紧接着又把它产出的摘要卷走。
         // 主判据是「这条官方卡片处理过没有」（与实际间隔多久无关），时间窗口只作可选兜底。
@@ -474,7 +493,6 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
         }
         if (inCooldown(agent.session, { windowMs: COOLDOWN_MS })) return;
         this.ensurePruneGuard();
-        this.captureSession(agent.session);
         const resolved = this.engineFor(agent);
         if (state.engine !== resolved.engine || state.engineSource !== resolved.source) {
           this.ctx.logger?.info?.(`spine engine=${resolved.engine} source=${resolved.source}`);
@@ -490,13 +508,14 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
         state.maxTurnGrowth = Math.max(state.maxTurnGrowth || 0, growth);
         const projected = state.maxTurnGrowth > 0 && last + state.maxTurnGrowth > KEEP_ROUND_TOKENS;
         const drain = cloud && (projected || last >= URGENT_TOKENS);
+        const drainNotes = [];
         for (let pass = 0; pass < 8; pass += 1) {
-          const measured = this.ctx.tokenMeter.measure(agent.session);
+          const measured = measurement;
           if (drain && measured.totalTokens <= KEEP_ROUND_TOKENS) break;
           const chunk = selectNewestChunk(agent.session, measured, state.key, {
             engine: resolved.engine,
-            jobs: collectJobs(agent.session.snapshotEvents()),
-            calls: indexToolCalls(agent.session.snapshotEvents()),
+            jobs,
+            calls,
             rawLookup: (id) => this.rawSeen.get(`${state.key}\0${id}`),
             totalTokens: measured.totalTokens,
             drain,
@@ -518,12 +537,23 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
             state.localOnly = true;
             state.approvedCard = chunk.card;
             await this.commitSelectedSpan(agent, chunk, op);
-            const after = this.ctx.tokenMeter.measure(agent.session).totalTokens;
+            measurement = this.ctx.tokenMeter.measure(agent.session);
+            const after = measurement.totalTokens;
             reduced = after < before;
             const saved = before - after;
-            const stats = saved > 0 ? recordCutStats(shadowDirectory(), { saved, rewrite: Math.max(0, after - (chunk.prefix || 0)) }) : null;
-            const total = stats ? stats.savedTokens : "unknown";
-            this.ctx.logger?.info?.(`spine cut ${Date.now() - started}ms ${before} -> ${after} chunk=${chunk.tokens} saved=${saved} total=${total}`);
+            if (saved > 0) {
+              drainNotes.push({
+                kind: "cut",
+                saved,
+                afterPrefix: Math.max(0, after - (chunk.prefix || 0)),
+                tailBeyondKept,
+                prefix: chunk.prefix || 0,
+                total: after,
+                tokens: chunk.tokens,
+                gate: "cut",
+              });
+            }
+            this.ctx.logger?.info?.(`spine cut ${Date.now() - started}ms ${before} -> ${after} chunk=${chunk.tokens} saved=${saved}`);
           } catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             this.ctx.logger?.warn?.(`spine cut failed: ${message}`);
@@ -535,7 +565,8 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
           }
           if (!drain) break;
         }
-        state.turnBase = this.ctx.tokenMeter.measure(agent.session).totalTokens;
+        if (drainNotes.length) flushDrainStats(shadowDirectory(), drainNotes, { sid: state.key, drain });
+        state.turnBase = measurement.totalTokens;
         await this.ctx.sessions?.flush?.(agent.session);
         this.rememberPrefix(agent);
       });
@@ -727,10 +758,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
     const key = session?.id || DEFAULT_KEY;
     const mapKey = this.rawKey(session, id);
     if (this.rawSeen.get(mapKey)?.ok) return this.rawSeen.get(mapKey);
-    let call = null;
-    try {
-      call = indexToolCalls(session.snapshotEvents?.() || []).get(id);
-    } catch {}
+    const call = this.callIndex.get(session?.id || DEFAULT_KEY)?.get(id) || null;
     try {
       const shadow = shadowDirectory();
       ensureShadowDir(shadow, access);
@@ -766,18 +794,47 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
     }
   }
 
-  captureSession(session) {
+  noteEvent(session, event) {
+    const found = indexToolCalls([event]);
+    if (!found.size) return;
+    const key = session?.id || DEFAULT_KEY;
+    let index = this.callIndex.get(key);
+    if (!index) {
+      index = new Map();
+      this.callIndex.set(key, index);
+    }
+    for (const [id, call] of found) {
+      if (!index.has(id)) index.set(id, call);
+    }
+  }
+
+  captureNew(session, events) {
+    const key = session?.id || DEFAULT_KEY;
+    let cursor = this.captureCursor.get(key) ?? 0;
+    if (!Array.isArray(events) || events.length < cursor) cursor = 0;
+    let next = cursor;
     const seen = new Set();
-    for (const event of session?.snapshotEvents?.() || []) {
-      if (event?.type !== "tool/result") continue;
-      const id = event.data?.message?.toolCallId;
-      if (!id || seen.has(id)) continue;
-      seen.add(id);
-      this.captureOne(session, event);
+    for (const event of events) {
+      const seq = Number.isInteger(event?.seq) ? event.seq : next;
+      if (seq < cursor) continue;
+      this.noteEvent(session, event);
+      if (event?.type === "tool/result") {
+        const id = event.data?.message?.toolCallId;
+        if (id && !seen.has(id)) {
+          seen.add(id);
+          this.captureOne(session, event);
+        }
+      }
+      next = seq + 1;
     }
+    this.captureCursor.set(key, next);
     return seen;
   }
 
+  captureSession(session) {
+    return this.captureNew(session, session?.snapshotEvents?.() || []);
+  }
+
   surfaceToolIds(session) {
     const ids = [];
     for (const seq of session?.surface?.nodes || []) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-live-compact",
-  "version": "1.0.9",
+  "version": "1.1.0",
   "description": "In-place newest-turn compaction for DeepSeek Harness. Compress while the task runs and keep the prefix.",
   "license": "MIT",
   "author": "MerkyorLynn <268568828+MerkyorLynn@users.noreply.github.com>",
@@ -37,7 +37,7 @@
     "compaction"
   ],
   "scripts": {
-    "test:gate": "node test/p0-gate.mjs && node test/p0-blockers.mjs && node --test test/cooldown.test.mjs test/gate-config.test.mjs"
+    "test:gate": "node test/p0-gate.mjs && node test/p0-blockers.mjs && node --test test/cooldown.test.mjs test/gate-config.test.mjs test/drain-stopline.mjs test/scan-once.mjs test/issue-19.mjs"
   },
   "engines": {
     "node": "^22.19 || >=24",

package/plan.js

@@ -746,15 +746,26 @@ function spanTokens(items, start, end) {
 function walkOffTail(items, end) {
   while (end >= 0) {
     const item = items[end];
+    // 卡片是停止线。走到它就没有可切的尾巴，不能再往左切进已缓存的前缀。
+    // A checkpoint is the floor. Reaching it means the tail has nothing left to cut.
+    if (item.checkpoint) return -1;
     const shortUser = item.type === "user" && (item.tokens || 0) < 400;
-    if (item.type !== "assistant" && !shortUser && !item.checkpoint) break;
+    if (item.type !== "assistant" && !shortUser) break;
     end -= 1;
   }
   while (end >= 0 && items[end].type === "user") end -= 1;
-  while (end >= 0 && items[end].checkpoint) end -= 1;
+  if (end >= 0 && items[end].checkpoint) return -1;
   return end;
 }
 
+export function cutCrossesNewerCheckpoint(items, end) {
+  if (!Array.isArray(items) || !Number.isInteger(end)) return false;
+  for (let index = end + 1; index < items.length; index += 1) {
+    if (items[index]?.checkpoint) return true;
+  }
+  return false;
+}
+
 function retreatBefore(items, end, boundary) {
   if (boundary < 0 || end < boundary) return end;
   end = boundary - 1;
@@ -805,6 +816,9 @@ export function selectCutIndexes(items, {
   const floor = firstUser >= 0 ? firstUser + 1 : 0;
   const end = walkOffTail(items, limit);
   if (end < 0) return null;
+  // 切点右边还有卡片，说明这一刀在已缓存前缀里。不切。
+  // A checkpoint to the right means this span is inside the cached prefix. Do not cut.
+  if (cutCrossesNewerCheckpoint(items, end)) return null;
   if (!cloud) {
     if (lastUser >= 0 && end <= lastUser) return null;
     if ((items[end].tokens || 0) > pointerMax && items[end].type === "tool") return { start: end, end, pointerOnly: true, gain: 0 };

package/shadow.js

@@ -11,6 +11,7 @@ import { execFileSync } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import {
   chmodSync,
+  appendFileSync,
   closeSync,
   existsSync,
   mkdirSync,
@@ -69,6 +70,7 @@ export function shadowFileBody(sessionKey, body) {
 }
 
 export const STATS_NAME = "spine-stats.json";
+export const CUTS_NAME = "spine-cuts.jsonl";
 
 export function readCutStats(dir) {
   try {
@@ -77,9 +79,79 @@ export function readCutStats(dir) {
       cuts: Number(parsed.cuts) || 0,
       savedTokens: Number(parsed.savedTokens) || 0,
       rewriteTokens: Number(parsed.rewriteTokens) || 0,
+      drains: Number(parsed.drains) || 0,
     };
   } catch {
-    return { cuts: 0, savedTokens: 0, rewriteTokens: 0 };
+    return { cuts: 0, savedTokens: 0, rewriteTokens: 0, drains: 0 };
+  }
+}
+
+export function drainRewrite(notes) {
+  const cuts = (notes || []).filter((note) => note?.kind === "cut" && note.saved > 0);
+  if (!cuts.length) return 0;
+  const later = cuts.slice(1).reduce((sum, note) => sum + (note.saved || 0), 0);
+  return Math.max(0, (cuts[0].afterPrefix || 0) - later);
+}
+
+export function flushDrainStats(dir, notes, meta = {}) {
+  const cuts = (notes || []).filter((note) => note?.kind === "cut" && note.saved > 0);
+  const charged = drainRewrite(notes);
+  const saved = cuts.reduce((sum, note) => sum + note.saved, 0);
+  if (cuts.length) recordDrainStats(dir, { cuts: cuts.length, saved, rewrite: charged });
+  const lines = (notes || []).map((note, index) => JSON.stringify({
+    v: 1,
+    ts: new Date().toISOString(),
+    sid: meta.sid || "",
+    kind: note.kind || "cut",
+    pass: index,
+    drain: meta.drain === true,
+    saved: note.saved || 0,
+    rewriteCharged: note.kind === "cut" && index === (notes || []).findIndex((item) => item?.kind === "cut") ? charged : 0,
+    tailBeyondKept: note.tailBeyondKept || 0,
+    prefix: note.prefix || 0,
+    afterPrefix: note.afterPrefix || 0,
+    tokens: note.tokens || 0,
+    total: note.total || 0,
+    gate: note.gate || "cut",
+  }));
+  if (!lines.length) return charged;
+  try {
+    appendFileSync(join(dir, CUTS_NAME), `${lines.join("\n")}\n`);
+  } catch {}
+  return charged;
+}
+
+function recordDrainStats(dir, { cuts = 0, saved = 0, rewrite = 0 } = {}) {
+  if (!(cuts > 0) || !(saved > 0)) return null;
+  try {
+    const file = join(dir, STATS_NAME);
+    const lock = join(dir, "spine-stats.lock");
+    const tmp = `${file}.${process.pid}-${randomBytes(8).toString("hex")}.tmp`;
+    let fd;
+    try {
+      fd = openSync(lock, "wx");
+    } catch {
+      return null;
+    }
+    try {
+      const prev = readCutStats(dir);
+      const locked = {
+        cuts: prev.cuts + cuts,
+        savedTokens: prev.savedTokens + saved,
+        rewriteTokens: prev.rewriteTokens + rewrite,
+        drains: (Number(prev.drains) || 0) + 1,
+        updatedAt: new Date().toISOString(),
+      };
+      writeFileSync(tmp, JSON.stringify(locked));
+      renameSync(tmp, file);
+      return locked;
+    } finally {
+      try { unlinkSync(tmp); } catch {}
+      closeSync(fd);
+      try { unlinkSync(lock); } catch {}
+    }
+  } catch {
+    return null;
   }
 }