dsh-live-compact 1.0.7 → 1.0.8

package/README.md

@@ -92,6 +92,18 @@ dsh-live-compact --version
 
 ![原版对比](docs/slide-stock.jpg)
 
+## 1.0.8
+
+同一套 8 组、184 个填日志回合。真实 DeepSeek。跳过工具 0，WARN 184/184，NOTICE 184/184。缓存命中 98.23%，1.0.6 是 97.88%，原版是 98.51%。题末平均 2.6 万，最高 3.6 万，最低 1.6 万。1.0.6 最高 3.5 万。原版最高 12.6 万。费用按离峰用量估算，1.0.8 是 $0.209，1.0.6 是 $0.211，原版是 $0.229，不是账单。切掉的原文 11.4 万 token。原版没有压缩，8 组题末加起来积累了 34.9 万。
+
+![1.0.8 和 1.0.6、原版](docs/slide-108-vs.jpg)
+
+卡片不再使用官方的 `<compacted-summary>` 和 `compact-checkpoint`。官方压缩会把那种节点当成上一版摘要再摘一次，切片摘要会越压越短。新卡片用 `spine-checkpoint`。已经写过的旧卡片仍会停住，不会再切一遍。
+
+遇到已有卡片就停止往前扩。这是故意的。卡片已经换过一次，再穿过去会改掉已经进缓存的前缀。最新一段不够 1000，就跳过，不回头凑。
+
+单个工具结果超过 3.2 万 token 才只留指针。默认不改。要自己调，启动前设 `SPINE_POINTER_TOKENS`，例如 `8000`。不按占比算。
+
 ## 1.0.7 长填日志
 
 1.0.7 跑了同一套 8 组。真实 DeepSeek。184 个填日志回合都调用了工具。WARN 183/184，NOTICE 184/184，假 NOTICE 是 0。8 组都切过，一共 43 刀。卡片 43 张都有会话序号，没有备份路径。
@@ -100,7 +112,7 @@ dsh-live-compact --version
 
 ![1.0.7 长填日志](docs/slide-107-fill.jpg)
 
-和已发布的 1.0.6 同一套题比：跳过工具都是 0。费用按离峰用量估算，1.0.7 是 $0.249，1.0.6 是 $0.211，不是账单。缓存命中 96.10%，上一轮 1.0.6 是 97.88%。题末上下文 1.0.7 平均 2.3 万、最高 3.1 万、最低 1.9 万，8 组都在 3.2 万以内。1.0.6 平均 2.6 万、最高 3.5 万。65 万停切线没动。
+和已发布的 1.0.6、以及上次同一套题的官方压缩比。跳过工具都是 0。费用按离峰用量估算，1.0.7 是 $0.249，1.0.6 是 $0.211，原版是 $0.229，不是账单。缓存命中 1.0.7 是 96.10%，1.0.6 是 97.88%，原版是 98.51%。题末上下文 1.0.7 平均 2.3 万、最高 3.1 万、最低 1.9 万，8 组都在 3.2 万以内。1.0.6 平均 2.6 万、最高 3.5 万。原版平均 4.4 万、最高 12.6 万，有两组到了 8.0 万和 12.6 万。切掉的原文，1.0.7 是 21.5 万 token，1.0.6 是 9.0 万。原版这一轮没有压缩，8 组题末上下文加起来积累了 34.9 万，最高一组 12.6 万。65 万停切线没动。
 
 ![和 1.0.6 比](docs/slide-107-vs106.jpg)
 
@@ -170,8 +182,8 @@ dsh-live-compact --version
 从 npm 装。headless 和网页是两个 profile，要各装一次。桌面端是另一个 profile，普通 `dsh plugin --profile desktop` 会被拒绝。
 
 ```sh
-dsh plugin --profile headless add dsh-live-compact@1.0.7
-dsh plugin --profile web add dsh-live-compact@1.0.7
+dsh plugin --profile headless add dsh-live-compact@1.0.8
+dsh plugin --profile web add dsh-live-compact@1.0.8
 ```
 
 想先装到本机看版本：
@@ -181,12 +193,12 @@ npm install -g dsh-live-compact
 dsh-live-compact --version
 ```
 
-备用：上不了 npm 的，用国内镜像站的包。1.0.2 到 1.0.6 的旧链接仍在。
+备用：上不了 npm 的，用国内镜像站的包。1.0.2 到 1.0.7 的旧链接仍在。
 
 ```sh
-dsh plugin --profile headless add https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.0.7.tgz
-dsh plugin --profile web add https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.0.7.tgz
-npm install -g --force "https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.0.7.tgz"
+dsh plugin --profile headless add https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.0.8.tgz
+dsh plugin --profile web add https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.0.8.tgz
+npm install -g --force "https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.0.8.tgz"
 dsh-live-compact --version
 ```
 

package/index.js

@@ -6,31 +6,31 @@
  * Notes follow UnwhiteCat's PR #3, rewritten for the current behavior.
  *
  * 小切在轮次结束后做，不调模型。最近 3 个已结束的工具轮留在原处。
- * 本地切点不越过最后一条用户消息。云端最新一段不足 1000 时才跨较早的用户消息。
- * 最后一条用户消息不进切段。不够 1000 token 就跳过。超过 65 万停掉小切，交给官方大压缩。
- * The small cut runs after the turn, with no model call. The latest 3 finished
- * tool rounds stay native. Local cuts stay after the last user. Cloud may include
- * earlier users only when the newest span is under 1000. The last user never
- * enters a span. Under 1000 tokens, skip. Above 650000, small cuts stop for the host gate.
+ * 切法和 1.0.6 一样：不越过用户消息，最近的工具轮按原预算留在原处。
+ * 不够 1000 token 就跳过，不回头凑。超过 65 万停掉小切，交给官方大压缩。
+ * The small cut runs after the turn, with no model call. The cut matches 1.0.6:
+ * it does not cross a user message, and recent tool rounds stay within the
+ * original token budget. Under 1000 tokens, skip. Do not walk back to manufacture
+ * a cut. Above 650000, small cuts stop for the host gate.
  */
 import { randomBytes, randomUUID } from "node:crypto";
 import { chmodSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { BasicCompactionEngine } from "@deepseek-ai/dsh-compaction-basic";
-import { CompactionId, compactCheckpointSource, toolPairingBalancedAfter, toolPairingBalancedBefore } from "@deepseek-ai/dsh-compaction";
+import { CompactionId, toolPairingBalancedAfter, toolPairingBalancedBefore } from "@deepseek-ai/dsh-compaction";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
-import { attachBackupHint, backgroundJobId, backupClaimOk, buildCard, collectJobs, fallbackProviderURL, indexToolCalls, jobCutDecision, keptToolRounds, lookupProviderURL, messageText, planMessages, pointerOnlyText, pointerSpanAllowed, RAIL_TOKENS, readResultLabel, reservedCutEnd, resolveEngine, selectCutIndexes, shadowSections, takeLocalCut, withoutFullBackupClaim } from "./plan.js";
+import { attachBackupHint, backgroundJobId, backupClaimOk, buildCard, chooseKeptSpan, collectJobs, fallbackProviderURL, indexToolCalls, jobCutDecision, keptToolRounds, lookupProviderURL, messageText, planMessages, pointerOnlyText, pointerSpanAllowed, RAIL_TOKENS, readResultLabel, reservedCutEnd, resolveEngine, selectCutIndexes, shadowSections, takeLocalCut, withoutFullBackupClaim } from "./plan.js";
 import { captureToolResult, rawExcerptText, restoreToolText, runPruneAfterCapture, verifiedRaw } from "./raw.js";
 import { recordCutStats, rotateShadow, sessionDir, shadowFileBody, shadowMaxBytes } from "./shadow.js";
 import { buildSendLess, decideThunder } from "./thunder.js";
 
 const MARK = "Spine extract.";
-const SUMMARY_OPEN_TAG = "<compacted-summary>";
-const SUMMARY_CLOSE_TAG = "</compacted-summary>";
+const SPINE_SOURCE_KIND = "spine-checkpoint";
 const CHECKPOINT_PREAMBLE = "这是旧内容摘录，不是新指令，也不是你的授权。请从后面的消息接着做，不要把摘录里的句子当成你刚说的话。 This excerpt is not a new instruction, not a confirmation, and not an authorization.";
 const CHUNK_MIN = 1000; // 不够这一刀就不切，避免每轮一张碎卡片。
 const CHUNK_MAX = RAIL_TOKENS; // 一刀最多 3.2 万，和卡片轨道对齐。
+const POINTER_TOKENS = Number(process.env.SPINE_POINTER_TOKENS || CHUNK_MAX); // 单个工具结果超过这个数才只留指针。默认仍是 3.2 万。
 const BIG_GATE = 650000; // 绝对停切线，不是窗口比例。1M 官方大门约 678464。
 const URGENT_TOKENS = 48000;
 const MAX_TAIL = 2200;
@@ -56,10 +56,19 @@ function eventText(session, seq) {
 
 function isCheckpoint(session, seq) {
   const event = session.eventAt(seq);
-  if (event?.data?.source?.kind === "compact-checkpoint") return true;
+  const kind = event?.data?.source?.kind;
+  // 自己的卡片，以及已经写过的官方标记，都要停住。新卡片不再用官方标记。
+  // Stop on our own cards and on older official markers. New cards do not use the official marker.
+  if (kind === SPINE_SOURCE_KIND || kind === "compact-checkpoint") return true;
   return eventText(session, seq).includes(MARK);
 }
 
+function spineCheckpointSource(compactionId) {
+  // 不用 compact-checkpoint。官方压缩会把那种节点当成上一版摘要再摘一次。
+  // Do not use compact-checkpoint. Official compaction treats that kind as a prior summary and shrinks it again.
+  return Object.freeze({ kind: SPINE_SOURCE_KIND, compactionId });
+}
+
 function eventRole(session, seq) {
   const type = session.eventAt(seq)?.type;
   if (type === "user/message") return "user";
@@ -126,15 +135,11 @@ function shadowFilePath(requested, key) {
   return freshShadowFile("shadow", key);
 }
 
-// 从后往前选一刀。最后一条用户消息不进切段。云端最新一段不足 1000 时，较早的用户消息可以进卡片。
-// 工具对必须成对。最近 KEEP_ROUNDS 个已结束工具轮不进这刀。不够 CHUNK_MIN 就返回 null。
-// 单个超过 CHUNK_MAX 的工具结果只留指针，并连同对应 tool-call 一起替换。
-// 这段里不能有最后一条用户消息或 checkpoint。
-// Pick one span from the tail. The last user stays out. Cloud may card earlier users
-// only when the newest span is under 1000. Tool pairs stay balanced.
-// The newest KEEP_ROUNDS finished tool rounds stay out of the cut. Under CHUNK_MIN, return null.
-// One oversized tool result becomes a pointer and is replaced together with its tool-call.
-// That span must not contain the last user or a checkpoint.
+// 从后往前选一刀，和 1.0.6 一样。不越过用户消息。工具对必须成对。
+// 最近的工具轮按 KEEP_ROUND_TOKENS 留在原处。不够 CHUNK_MIN 就返回 null。
+// Pick one span from the tail, as in 1.0.6. Do not cross a user message.
+// Tool pairs stay balanced. Recent tool rounds stay within KEEP_ROUND_TOKENS.
+// Under CHUNK_MIN, return null.
 function selectNewestChunk(session, measurement, key = DEFAULT_KEY, context = {}) {
   const decision = jobCutDecision(context.jobs || []);
   if (!decision.cut) return null;
@@ -161,7 +166,13 @@ function selectNewestChunk(session, measurement, key = DEFAULT_KEY, context = {}
     visible.push({ index, type: event?.type === "tool/result" ? "tool" : "other", toolCalls });
   }
   const rounds = keptToolRounds(visible, KEEP_ROUNDS);
-  const span = rounds.length ? { start: rounds[0].start, end: rounds[rounds.length - 1].end } : null;
+  // 收尾也留最近 3 个工具轮。刚读的日志还要用来答题，不能整段换掉。
+  // A drain still keeps the latest 3 tool rounds. The log just read is needed for the next answer.
+  const span = chooseKeptSpan(rounds, (from, to) => {
+    let tokens = 0;
+    for (let index = visible[from.start].index; index <= visible[to.end].index; index += 1) tokens += priced[index].tokens;
+    return tokens;
+  }, KEEP_ROUND_TOKENS);
   const cutEnd = span ? reservedCutEnd(visible[span.start].index, first) : null;
   if (span && cutEnd === null) return null;
   if (cutEnd !== null) {
@@ -235,7 +246,12 @@ function selectNewestChunk(session, measurement, key = DEFAULT_KEY, context = {}
     engine: context.engine || "cloud",
     chunkMin: CHUNK_MIN,
     chunkMax: CHUNK_MAX,
+    pointerMax: POINTER_TOKENS,
     maxEnd: end,
+    totalTokens: context.totalTokens,
+    drain: context.drain === true,
+    urgentTokens: URGENT_TOKENS,
+    keepBudget: KEEP_ROUND_TOKENS,
   });
   if (!picked) return null;
   if (picked.pointerOnly) {
@@ -333,6 +349,8 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
       approvedCard: null,
       lastPrefix: "",
       lastPrefixTokens: 0,
+      turnBase: null,
+      maxTurnGrowth: 0,
     };
     this.sessionState.set(key, state);
     if (this.sessionState.size > MAX_TRACKED_SESSIONS) {
@@ -367,45 +385,66 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
         if (measurement.totalTokens < MIN_PRESSURE || measurement.totalTokens >= BIG_GATE) return;
         this.ensurePruneGuard();
         this.captureSession(agent.session);
-        const events = agent.session.snapshotEvents();
         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}`);
           state.engine = resolved.engine;
           state.engineSource = resolved.source;
         }
-        const chunk = selectNewestChunk(agent.session, measurement, state.key, {
-          engine: resolved.engine,
-          jobs: collectJobs(events),
-          calls: indexToolCalls(events),
-          rawLookup: (id) => this.rawSeen.get(`${state.key}\0${id}`),
-        });
-        if (chunk === null) {
-          this.ctx.logger?.debug?.("spine cut skipped");
-          return;
-        }
-        const tailBeyondKept = chunk.after - (chunk.keptTokens || 0);
-        if (tailBeyondKept > MAX_TAIL && measurement.totalTokens < URGENT_TOKENS) return;
-        const before = measurement.totalTokens;
-        const started = Date.now();
-        let reduced = false;
-        try {
-          state.localOnly = true;
-          state.approvedCard = chunk.card;
-          await this.commitSelectedSpan(agent, chunk, op);
-          const after = this.ctx.tokenMeter.measure(agent.session).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}`);
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          this.ctx.logger?.warn?.(`spine cut failed: ${message}`);
-        }
-        if (!reduced) {
-          this.ctx.logger?.warn?.(`spine cut did not reduce ${before}; leaving the prefix for the gate`);
+        const cloud = resolved.engine !== "local";
+        // 预测下一轮会过 32000 才收尾。实际总量回到 32000 就停，不收到 16000。
+        // Drain when the next request would pass 32000. Stop at the measured 32000. Do not cut down to 16000.
+        const last = measurement.totalTokens;
+        const base = state.turnBase ?? last;
+        const growth = Math.max(0, last - base);
+        state.maxTurnGrowth = Math.max(state.maxTurnGrowth || 0, growth);
+        let drain = cloud && last + state.maxTurnGrowth > KEEP_ROUND_TOKENS;
+        for (let pass = 0; pass < 8; pass += 1) {
+          const measured = this.ctx.tokenMeter.measure(agent.session);
+          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()),
+            rawLookup: (id) => this.rawSeen.get(`${state.key}\0${id}`),
+            totalTokens: measured.totalTokens,
+            drain,
+          });
+          if (chunk === null) {
+            if (drain && measured.totalTokens > KEEP_ROUND_TOKENS) {
+              this.ctx.logger?.warn?.(`spine drain stopped at ${measured.totalTokens}; no legal span`);
+            } else {
+              this.ctx.logger?.debug?.("spine cut skipped");
+            }
+            break;
+          }
+          const tailBeyondKept = chunk.after - (chunk.keptTokens || 0);
+          if (!drain && tailBeyondKept > MAX_TAIL && measured.totalTokens < URGENT_TOKENS) break;
+          const before = measured.totalTokens;
+          const started = Date.now();
+          let reduced = false;
+          try {
+            state.localOnly = true;
+            state.approvedCard = chunk.card;
+            await this.commitSelectedSpan(agent, chunk, op);
+            const after = this.ctx.tokenMeter.measure(agent.session).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}`);
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.ctx.logger?.warn?.(`spine cut failed: ${message}`);
+            break;
+          }
+          if (!reduced) {
+            this.ctx.logger?.warn?.(`spine cut did not reduce ${before}; leaving the prefix for the gate`);
+            break;
+          }
+          if (!drain) break;
         }
+        state.turnBase = this.ctx.tokenMeter.measure(agent.session).totalTokens;
         await this.ctx.sessions?.flush?.(agent.session);
         this.rememberPrefix(agent);
       });
@@ -439,11 +478,10 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
     const compactionId = CompactionId(randomUUID());
     const checkpointMessage = createUserMessage({
       content: [
-        { type: "text", text: `${CHECKPOINT_PREAMBLE}\n\n${SUMMARY_OPEN_TAG}` },
+        { type: "text", text: `${CHECKPOINT_PREAMBLE}\n\n${MARK}` },
         ...summarized.summary,
-        { type: "text", text: SUMMARY_CLOSE_TAG },
       ],
-      source: compactCheckpointSource(compactionId),
+      source: spineCheckpointSource(compactionId),
     });
     const framedTokens = this.ctx.tokenMeter.estimateMessage?.(checkpointMessage);
     if (typeof framedTokens === "number" && framedTokens >= chunk.tokens) {
@@ -502,6 +540,8 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
     return super.compactIfNeeded(agent, trigger, signal);
   }
 
+  // 请求头往往只有 provider。先读目录里的地址，再对官方 DeepSeek 用公网默认端点。
+  // Headers often carry only the provider. Read a catalog URL, then use the public DeepSeek endpoint.
   engineFor(agent) {
     const header = agent?.session?.requestHeader?.()?.config || {};
     const context = agent?.session?.requestContext?.() || {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-live-compact",
-  "version": "1.0.7",
+  "version": "1.0.8",
   "description": "In-place newest-turn compaction for DeepSeek Harness. Compress while the task runs and keep the prefix.",
   "license": "MIT",
   "type": "module",

package/plan.js

@@ -561,6 +561,7 @@ export function isLocalHost(host) {
 }
 
 // 宿主 listProviders 只给 {id, name}，没有 baseURL。按 id 或 provider 取地址。
+// The host list only has {id, name}. Match either field and read a URL if one is present.
 export function lookupProviderURL(provider, listed) {
   const name = String(provider || "");
   if (!name) return "";
@@ -570,6 +571,8 @@ export function lookupProviderURL(provider, listed) {
 
 // 官方 DeepSeek 的请求头没有 baseURL。没读到自定义地址时用公网默认端点，避免被当成本地而停切。
 // Strata 仍由 provider 名判断，不走这里。
+// Official DeepSeek headers omit baseURL. Use the public endpoint so it is not treated as local.
+// A provider name containing strata stays local and does not use this fallback.
 export function fallbackProviderURL(provider) {
   if (/^(?:deepseek-official|deepseek)$/i.test(String(provider || ""))) return "https://api.deepseek.com/anthropic";
   return "";
@@ -638,49 +641,64 @@ function balanced(items, start, end) {
   return true;
 }
 
-export function selectCutIndexes(items, { engine = "cloud", chunkMin = 1000, chunkMax = 32000, maxEnd = null } = {}) {
+export function selectCutIndexes(items, {
+  engine = "cloud",
+  chunkMin = 1000,
+  chunkMax = 32000,
+  pointerMax = chunkMax,
+  maxEnd = null,
+  totalTokens,
+  drain = false,
+  urgentTokens = 48000,
+  keepBudget = 32000,
+} = {}) {
   if (!items?.length) return null;
-  const limit = maxEnd === null ? items.length - 1 : maxEnd;
+  const cloud = engine !== "local";
+  // 云端平时不切。到原有紧急线，或这一轮已经在收尾，才批量切。
+  // Cloud does not cut on an ordinary turn. Drain only at the existing urgent line, or when this turn already started a drain.
+  const draining = cloud && (drain || (typeof totalTokens === "number" && totalTokens >= urgentTokens));
+  // 收尾时即使已经低于 32000 也继续切到这批的下限。平时低于 32000 不切。
+  // During a drain, keep cutting below 32000. On an ordinary turn, stay under 32000 and do not cut.
+  if (!drain && cloud && typeof totalTokens === "number" && totalTokens <= keepBudget) return null;
+  const limit = draining ? items.length - 1 : (maxEnd === null ? items.length - 1 : maxEnd);
   if (limit < 0) return null;
   const lastUser = items.reduce((found, item, index) => (item.type === "user" ? index : found), -1);
   const firstUser = items.findIndex((item) => item.type === "user");
   const floor = firstUser >= 0 ? firstUser + 1 : 0;
   const oversized = [];
   for (let index = limit; index >= 0; index -= 1) {
-    if ((items[index].tokens || 0) <= chunkMax || items[index].type !== "tool") continue;
-    if (engine === "local" && lastUser >= 0 && index <= lastUser) continue;
+    if (items[index].type !== "tool" || (items[index].tokens || 0) <= pointerMax) continue;
+    if (!cloud && lastUser >= 0 && index <= lastUser) continue;
     oversized.push(index);
   }
-  let end = walkOffTail(items, limit);
-  if (end < 0) return oversized.length ? { start: oversized[0], end: oversized[0], pointerOnly: true, gain: 0 } : null;
-  if (engine === "local") {
-    if (lastUser >= 0 && end <= lastUser) return oversized.length ? { start: oversized[0], end: oversized[0], pointerOnly: true, gain: 0 } : null;
-    if ((items[end].tokens || 0) > chunkMax && items[end].type === "tool") return { start: end, end, pointerOnly: true, gain: 0 };
+  const pointer = oversized.length ? { start: oversized[0], end: oversized[0], pointerOnly: true, gain: 0 } : null;
+  // 没到紧急线时，云端只处理超大工具结果，不因一个刚老化的结果改写前缀。
+  // Below the urgent line, cloud only pointer-cuts an oversized tool. One newly aged result does not rewrite the prefix.
+  if (cloud && !draining) return pointer;
+  const end = walkOffTail(items, limit);
+  if (end < 0) return pointer;
+  if (!cloud) {
+    if (lastUser >= 0 && end <= lastUser) return pointer;
+    if ((items[end].tokens || 0) > pointerMax && items[end].type === "tool") return { start: end, end, pointerOnly: true, gain: 0 };
     if ((items[end].tokens || 0) > chunkMax) return null;
     const local = expandBack(items, end, Math.max(floor, lastUser), { crossUser: false, chunkMax });
     if (local.gain < chunkMin || !balanced(items, local.start, local.end)) return null;
     return local;
   }
-  if ((items[end].tokens || 0) > chunkMax && items[end].type === "tool") return { start: end, end, pointerOnly: true, gain: 0 };
+  if ((items[end].tokens || 0) > pointerMax && items[end].type === "tool") return { start: end, end, pointerOnly: true, gain: 0 };
   const phase = expandBack(items, end, 0, { crossUser: false, chunkMax });
-  if (phase.gain >= chunkMin) {
-    if (phase.tokens <= chunkMax && balanced(items, phase.start, phase.end) && !(lastUser >= phase.start && lastUser <= phase.end)) return phase;
-    return null;
-  }
-  end = retreatBefore(items, end, lastUser);
-  if (end < floor) return oversized.length ? { start: oversized[0], end: oversized[0], pointerOnly: true, gain: 0 } : null;
-  if ((items[end].tokens || 0) > chunkMax && items[end].type === "tool") return { start: end, end, pointerOnly: true, gain: 0 };
-  const extended = expandBack(items, end, floor - 1, { crossUser: true, chunkMax });
-  if (extended.start < floor) extended.start = floor;
-  extended.gain = nonUserGain(items, extended.start, extended.end);
-  extended.tokens = spanTokens(items, extended.start, extended.end);
-  if (extended.tokens > chunkMax || extended.gain < chunkMin || !balanced(items, extended.start, extended.end)) return null;
-  if (lastUser >= extended.start && lastUser <= extended.end) return null;
-  return extended;
+  // 不跨 user 去凑 1000。不够就跳过。
+  // Do not walk across users to manufacture 1000 tokens. Under that, skip.
+  if (phase.gain < chunkMin) return pointer;
+  if (phase.tokens > chunkMax || !balanced(items, phase.start, phase.end)) return null;
+  if (lastUser >= phase.start && lastUser <= phase.end) return null;
+  return phase;
 }
 
 // pointerOnly 扩到 tool-call 之后，这一段仍不能包含最后一条 user 或 checkpoint。
 // 本地整段必须严格晚于最后一条 user。较早的 user 可以留在段内，由卡片用 JSON 原文保住。
+// After expanding to the tool-call, the span still must not contain the last user or a checkpoint.
+// A local span must start after the last user. An earlier user may stay and be kept as JSON.
 export function pointerSpanAllowed(items, start, end, engine = "cloud") {
   if (!Array.isArray(items) || !Number.isInteger(start) || !Number.isInteger(end)) return false;
   if (start < 0 || end < start || end >= items.length) return false;
@@ -693,6 +711,9 @@ export function pointerSpanAllowed(items, start, end, engine = "cloud") {
   return true;
 }
 
+// 超大工具结果只留序号指针。助手正文不写成工具行。较早用户原文仍是单行 JSON。
+// An oversized tool result keeps a sequence pointer. Assistant prose is not labeled as a tool.
+// An earlier user, if the span includes one, stays as one-line JSON. No backup path.
 export function pointerOnlyText(pieces) {
   const tools = (pieces || []).filter((piece) => sourceRole(piece?.role) === "tool" && Number.isInteger(piece.seq));
   const users = (pieces || []).filter((piece) => sourceRole(piece?.role) === "user" && String(piece.text || "").trim());