dsh-live-compact 1.0.8 → 1.1.0

package/index.js

@@ -6,30 +6,42 @@
  * Notes follow UnwhiteCat's PR #3, rewritten for the current behavior.
  *
  * 小切在轮次结束后做，不调模型。最近 3 个已结束的工具轮留在原处。
- * 切法和 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.
+ * 切法和 1.0.6 一样：不越过用户消息。不够 1000 token 就跳过，不回头凑。
+ * 超过 65 万停掉小切，交给官方大压缩。
+ * The small cut runs after the turn, with no model call. It does not cross a user
+ * message. 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 { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { pathToFileURL } from "node:url";
 import { BasicCompactionEngine } from "@deepseek-ai/dsh-compaction-basic";
 import { CompactionId, toolPairingBalancedAfter, toolPairingBalancedBefore } from "@deepseek-ai/dsh-compaction";
 import { createUserMessage } from "@deepseek-ai/dsh-llm";
-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 { attachBackupHint, backgroundJobId, backupClaimOk, buildCard, collectJobs, indexToolCalls, jobCutDecision, keptToolRounds, messageText, planMessages, pointerOnlyText, pointerSpanAllowed, RAIL_TOKENS, readResultLabel, reservedCutEnd, resolveEngine, resolveProviderBaseURL, selectCutIndexes, shadowSections, takeLocalCut, withoutFullBackupClaim } from "./plan.js";
+import { captureOwnedToolResult, rawExcerptText, restoreToolText, runPruneAfterCapture, verifiedRaw } from "./raw.js";
+import {
+  discardShadowFiles,
+  ensureShadowDir,
+  flushDrainStats,
+  rotateShadow,
+  sessionDir,
+  shadowFileBody,
+  shadowMaxBytes,
+  writeShadowFile,
+  writeShadowOwner,
+} from "./shadow.js";
 import { buildSendLess, decideThunder } from "./thunder.js";
+import { OFFICIAL_COMPACTION_KIND, inCooldown, lastSourceKindSeq, resolveCooldownMs } from "./cooldown.js";
 
 const MARK = "Spine extract.";
 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 CHUNK_MIN = Number(process.env.SPINE_CHUNK_MIN || 1000); // 不够这一刀就不切，避免每轮一张碎卡片。
+const CHUNK_MAX = Number(process.env.SPINE_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;
@@ -37,6 +49,7 @@ const MAX_TAIL = 2200;
 const MIN_PRESSURE = Number(process.env.SPINE_MIN_TOKENS || 20000);
 const KEEP_ROUNDS = Number(process.env.SPINE_KEEP_ROUNDS || 3);
 const KEEP_ROUND_TOKENS = Number(process.env.SPINE_KEEP_ROUND_TOKENS || 32000);
+const COOLDOWN_MS = resolveCooldownMs(); // 额外的时间兜底；0 = 只用 seq 一次性跳过
 const MAX_TRACKED_SESSIONS = 64;
 const DEFAULT_KEY = "__default__";
 
@@ -100,20 +113,21 @@ function sessionKey(agent) {
   return typeof id === "string" && id.length > 0 ? id : DEFAULT_KEY;
 }
 
-function tightenShadow(dir) {
-  try {
-    chmodSync(dir, 0o700);
-  } catch {}
-}
-
 function shadowBody(messages) {
   return (messages || []).map((message) => shadowSections(message)).join("\n\n");
 }
 
-function freshShadowFile(kind, key) {
-  const dir = sessionDir(shadowDirectory(), key);
-  mkdirSync(dir, { recursive: true, mode: 0o700 });
-  return join(dir, `${kind}-${Date.now()}-${randomBytes(4).toString("hex")}.txt`);
+export function freshShadowFile(kind, key, access = {}) {
+  const shadow = shadowDirectory();
+  ensureShadowDir(shadow, access);
+
+  const dir = sessionDir(shadow, key);
+  ensureShadowDir(dir, access);
+
+  return join(
+    dir,
+    `${kind}-${Date.now()}-${randomBytes(4).toString("hex")}.txt`,
+  );
 }
 
 function commandFromCall(event) {
@@ -135,10 +149,84 @@ function shadowFilePath(requested, key) {
   return freshShadowFile("shadow", key);
 }
 
+// 实际文件由 writeShadowFile 以 mode: 0o600 创建并收紧权限。
+export function saveShadowImpl(
+  messages,
+  required,
+  shadowFile,
+  warnKey = DEFAULT_KEY,
+  protectPaths = [],
+  access = {},
+) {
+  const shadow = shadowDirectory();
+  ensureShadowDir(shadow, access);
+
+  const file = shadowFilePath(shadowFile, warnKey);
+  const dir = sessionDir(shadow, warnKey);
+  ensureShadowDir(dir, access);
+
+  const owner = join(dir, "owner");
+  const ownerExisted = existsSync(owner);
+  let ownerWritten = false;
+
+  try {
+    writeShadowOwner(dir, access);
+    ownerWritten = true;
+
+    const body = shadowFileBody(warnKey, shadowBody(messages));
+    const incoming = Buffer.byteLength(body);
+    const cap = shadowMaxBytes();
+
+    const rotation = rotateShadow({
+      dir: shadow,
+      incomingBytes: incoming,
+      protectPath: file,
+      protectPaths,
+      sessionKey: warnKey,
+      cap,
+    });
+
+    if (!rotation.ok) {
+      this.warnShadowFull(warnKey, shadow, rotation.used, cap);
+      if (required) {
+        throw new Error(
+          "spine: shadow backup is full; leaving the span",
+        );
+      }
+      return;
+    }
+
+    if (rotation.deleted > 0) {
+      this.ctx.logger?.info?.(
+        `spine: shadow 轮换 删除 ${rotation.deleted} 个文件，` +
+        `腾出 ${rotation.freed} 字节，` +
+        `用量 ${rotation.used + incoming}/${cap}`,
+      );
+    }
+
+    if (rotation.oversize) {
+      this.warnShadowOversize(warnKey, cap);
+    }
+
+    writeShadowFile(file, body, access);
+
+    if (!existsSync(file)) {
+      throw new Error("spine: shadow backup was not written");
+    }
+  } catch (error) {
+    if (ownerWritten && !ownerExisted) {
+      discardShadowFiles([owner], error);
+    }
+    throw error;
+  }
+}
+
+export { saveShadowImpl as saveShadow };
+
 // 从后往前选一刀，和 1.0.6 一样。不越过用户消息。工具对必须成对。
-// 最近的工具轮按 KEEP_ROUND_TOKENS 留在原处。不够 CHUNK_MIN 就返回 null。
+// 最近 KEEP_ROUNDS 个已结束的工具轮留在原处。不够 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.
+// Tool pairs stay balanced. The newest KEEP_ROUNDS finished rounds stay verbatim.
 // Under CHUNK_MIN, return null.
 function selectNewestChunk(session, measurement, key = DEFAULT_KEY, context = {}) {
   const decision = jobCutDecision(context.jobs || []);
@@ -148,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 = [];
@@ -166,21 +259,21 @@ 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);
-  // 收尾也留最近 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 span = rounds.length ? { start: rounds[0].start, end: rounds.at(-1).end } : null;
   const cutEnd = span ? reservedCutEnd(visible[span.start].index, first) : null;
   if (span && cutEnd === null) return null;
   if (cutEnd !== null) {
     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) => {
@@ -251,7 +344,6 @@ function selectNewestChunk(session, measurement, key = DEFAULT_KEY, context = {}
     totalTokens: context.totalTokens,
     drain: context.drain === true,
     urgentTokens: URGENT_TOKENS,
-    keepBudget: KEEP_ROUND_TOKENS,
   });
   if (!picked) return null;
   if (picked.pointerOnly) {
@@ -289,7 +381,7 @@ function selectNewestChunk(session, measurement, key = DEFAULT_KEY, context = {}
   return { start: nodes[start], end: nodes[end], tokens, after, keptTokens, card, prefix };
 }
 
-export { planMessages };
+export { BIG_GATE, isCheckpoint, planMessages, spineCheckpointSource };
 
 // 只换「切哪一段、怎么换成卡片」。官方大门仍由宿主算。
 // Changes which span is cut and how it becomes a card. The host still owns the stock gate.
@@ -299,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) {
@@ -311,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);
       });
@@ -318,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);
         });
@@ -375,16 +471,28 @@ 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 先让一让，免得紧接着又把它产出的摘要卷走。
+        // 主判据是「这条官方卡片处理过没有」（与实际间隔多久无关），时间窗口只作可选兜底。
+        const officialSeq = lastSourceKindSeq(agent.session, OFFICIAL_COMPACTION_KIND);
+        if (officialSeq !== undefined && state.cooldownSeenSeq !== officialSeq) {
+          state.cooldownSeenSeq = officialSeq;
+          this.ctx.logger?.info?.(`spine cooldown: official compaction ${officialSeq} seen, skip this pass`);
+          return;
+        }
+        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}`);
@@ -392,20 +500,22 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
           state.engineSource = resolved.source;
         }
         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.
+        // 预测下一轮会过 32000 时收尾；没有增长基线时仍由已有 48000 紧急线接管。
+        // Drain a projected request over 32000. Without a growth baseline, the existing 48000 urgent line still takes over.
         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;
+        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,
@@ -427,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}`);
@@ -444,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);
       });
@@ -540,54 +662,130 @@ 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.
+  // 请求头往往只有 provider。目录和官方 DeepSeek 之后，再读当前配置里的 baseURL。
+  // 读不到地址仍按本地，避免没配地址的会话被当成云端去改前缀。
+  // Headers often carry only the provider. After the catalog and official DeepSeek, read the live profile URL.
+  // No URL still means local, so an unconfigured session is not rewritten as cloud.
   engineFor(agent) {
     const header = agent?.session?.requestHeader?.()?.config || {};
     const context = agent?.session?.requestContext?.() || {};
     const provider = header.provider || context.provider || "";
-    let baseURL = header.baseURL || context.baseURL || "";
-    if (!baseURL) {
+    const listed = this.listedProviders();
+    const baseURL = resolveProviderBaseURL({
+      provider,
+      headerURL: header.baseURL || context.baseURL || "",
+      listed,
+      layers: this.providerLayers(),
+      patchText: this.profilePatchText(),
+      catalog: this.catalogProviders(),
+    });
+    return resolveEngine({ provider, baseURL });
+  }
+
+  listedProviders() {
+    try {
+      return this.ctx.llm?.listProviders?.() || this.ctx.get?.("llm")?.listProviders?.() || [];
+    } catch {
+      return [];
+    }
+  }
+
+  hostService(name) {
+    const nodes = [this.ctx, this.ctx?.root, this.ctx?.parent];
+    for (const node of nodes) {
+      if (!node || typeof node.get !== "function") continue;
       try {
-        const listed = this.ctx.llm?.listProviders?.() || this.ctx.get?.("llm")?.listProviders?.() || [];
-        baseURL = lookupProviderURL(provider, listed);
+        const hit = node.get(name);
+        if (hit) return hit;
       } catch {}
     }
-    if (!baseURL) baseURL = fallbackProviderURL(provider);
-    return resolveEngine({ provider, baseURL });
+    return undefined;
+  }
+
+  providerLayers() {
+    try {
+      const rows = this.hostService("configEditor")?.configuration?.() || [];
+      return rows.map((row) => ({ override: row?.override, inherited: row?.inherited }));
+    } catch {
+      return [];
+    }
+  }
+
+  catalogProviders() {
+    const anchors = [import.meta.url];
+    try {
+      if (process.argv[1]) anchors.push(pathToFileURL(process.argv[1]).href);
+    } catch {}
+    for (const anchor of anchors) {
+      try {
+        const loaded = createRequire(anchor)("@earendil-works/pi-ai/providers/all");
+        const list = typeof loaded.builtinProviders === "function" ? loaded.builtinProviders() : [];
+        return list.map((entry) => ({
+          id: entry?.id || "",
+          baseURL: entry?.baseUrl || entry?.baseURL || "",
+        })).filter((entry) => entry.id && entry.baseURL);
+      } catch {}
+    }
+    return [];
+  }
+
+  profilePatchText() {
+    const candidates = [];
+    try {
+      const profile = this.hostService("profileContext");
+      if (profile?.patchPath) candidates.push(profile.patchPath);
+      if (profile?.dir) candidates.push(join(profile.dir, "cordis.patch.yml"));
+    } catch {}
+    const home = process.env.DSH_HOME;
+    const flag = process.argv.indexOf("--profile");
+    const name = flag >= 0 ? process.argv[flag + 1] : process.env.DSH_PROFILE;
+    if (home && name && !String(name).startsWith("-")) candidates.push(join(home, "profiles", name, "cordis.patch.yml"));
+    for (const path of candidates) {
+      try {
+        if (path && existsSync(path)) return readFileSync(path, "utf8");
+      } catch {}
+    }
+    return "";
   }
 
   rawKey(session, toolCallId) {
     return `${session?.id || DEFAULT_KEY}\0${toolCallId}`;
   }
 
-  captureOne(session, event) {
+  captureOne(session, event, access = {}) {
     const id = event?.data?.message?.toolCallId;
     if (!id) return null;
     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 dir = sessionDir(shadowDirectory(), key);
-      try {
-        mkdirSync(dir, { recursive: true, mode: 0o700 });
-        writeFileSync(join(dir, "owner"), String(process.pid), { mode: 0o600 });
-      } catch {}
-      const record = captureToolResult({
+      const shadow = shadowDirectory();
+      ensureShadowDir(shadow, access);
+
+      const dir = sessionDir(shadow, key);
+      const record = captureOwnedToolResult({
         dir,
         toolCallId: id,
         text: messageText(event.data?.message),
         turn: event.data?.turn,
         name: call?.name || "",
-        pathLabel: readResultLabel(call?.name, call?.filePath, event.data?.turn),
+        pathLabel: readResultLabel(
+          call?.name,
+          call?.filePath,
+          event.data?.turn,
+        ),
+        access,
       });
       this.rawSeen.set(mapKey, record);
       return record;
     } catch (error) {
+      if (
+        error?.code === "ESHADOWACCESS" ||
+        error?.code === "ESHADOWCLEANUP"
+      ) {
+        throw error;
+      }
       const message = error instanceof Error ? error.message : String(error);
       this.ctx?.logger?.warn?.(`spine: raw backup failed: ${message}`);
       const record = { ok: false, reason: "unwritable", toolCallId: id };
@@ -596,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 || []) {
@@ -676,37 +903,23 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
     this.ctx.logger?.warn?.(`spine: 这一份备份超过上限 ${cap}，已写下，其他可删备份已清。`);
   }
 
-  saveShadow(messages, required, shadowFile, warnKey = DEFAULT_KEY, protectPaths = []) {
-    const shadow = shadowDirectory();
-    mkdirSync(shadow, { recursive: true, mode: 0o700 });
-    tightenShadow(shadow);
-    const file = shadowFilePath(shadowFile, warnKey);
-    const dir = sessionDir(shadow, warnKey);
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
-    writeFileSync(join(dir, "owner"), String(process.pid), { mode: 0o600 });
-    const body = shadowFileBody(warnKey, shadowBody(messages));
-    const incoming = Buffer.byteLength(body);
-    const cap = shadowMaxBytes();
-    const rotation = rotateShadow({
-      dir: shadow,
-      incomingBytes: incoming,
-      protectPath: file,
+  saveShadow(
+    messages,
+    required,
+    shadowFile,
+    warnKey = DEFAULT_KEY,
+    protectPaths = [],
+    access = {},
+  ) {
+    return saveShadowImpl.call(
+      this,
+      messages,
+      required,
+      shadowFile,
+      warnKey,
       protectPaths,
-      sessionKey: warnKey,
-      cap,
-    });
-    if (!rotation.ok) {
-      this.warnShadowFull(warnKey, shadow, rotation.used, cap);
-      if (required) throw new Error("spine: shadow backup is full; leaving the span");
-      return;
-    }
-    if (rotation.deleted > 0) {
-      this.ctx.logger?.info?.(`spine: shadow 轮换 删除 ${rotation.deleted} 个文件，腾出 ${rotation.freed} 字节，用量 ${rotation.used + incoming}/${cap}`);
-    }
-    if (rotation.oversize) this.warnShadowOversize(warnKey, cap);
-    writeFileSync(file, body, { mode: 0o600 });
-    chmodSync(file, 0o600);
-    if (!existsSync(file)) throw new Error("spine: shadow backup was not written");
+      access,
+    );
   }
 
   async summarize(input, agent, signal) {
@@ -725,8 +938,20 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
       return { summary: [block], provider: "local", model: "spine-extract", rawOutput: [block] };
     }
     try {
-      this.saveShadow(this.restoreRawMessages(input.messages, state.key), false, freshShadowFile("official", state.key), state.key);
-    } catch {}
+      this.saveShadow(
+        this.restoreRawMessages(input.messages, state.key),
+        false,
+        freshShadowFile("official", state.key),
+        state.key,
+      );
+    } catch (error) {
+      if (
+        error?.code === "ESHADOWACCESS" ||
+        error?.code === "ESHADOWCLEANUP"
+      ) {
+        throw error;
+      }
+    }
     const joined = input.messages.map(messageText).join("\n\n");
     if (process.env.SPINE_THUNDER !== "1") return super.summarize(input, agent, signal);
     const next = joined;