dsh-live-compact 1.1.5 → 1.1.6

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # 版本变更
 
+## 1.1.6
+
+- **billion-context 共存**：检测 `bili-native` / `billion-context` 的实际 LOADING/ACTIVE 状态；对方接管官方压缩时，Live Compact 保留官方引擎并让位，finishTurn、compact、shadow 捕获、pruner、cursor 和 recovery 路径均不再改会话。支持 `SPINE_STAND_DOWN=1` 强制让位，并补充一次性告警和回归测试。
+- **P0：隔离组接管与边界修复**：接管直接 `agentPresets.register()` 和 Include 加载的 `compaction` 隔离组，覆盖 Deep PTC 的 compaction 与 toolResultPruner 共存；修复 checkpoint、最新回合和 turn boundary 的误判，不把历史完成回合当成当前未完成回合。
+- **P1：原始结果与压缩路径加固**：同一会话重复 `toolCallId` 对应不同原文时闭合失败，原文、元数据、owner 和卡片采用私有临时文件、权限核验、fsync 和原子发布；临时 I/O 错误可重试，永久 ACL/清理错误保持 fail-closed；增加 30 秒 shadow worker 超时、长 read 非法切点回退、准确 `keptTokens` 和 turn baseline 收敛，并保留 Thunder 事实来源与显式决策边界。
+- **P1：model-level provider endpoint（#45）**：按精确的 provider + model catalog 地址判断 cloud/local，不改变宿主实际请求路由；provider-level 地址继续作为回退。
+- 默认 TUI 行为不变；真实 TUI × Live Compact 联合验收、原用户 Windows 长会话复测和 #27/#34 现场复测仍按开放边界跟进。手动指定切点的 feature request（#48）不纳入本版。
+
 ## 1.1.5
 
 - #27：把默认/共享根的容量扫描、轮换删除和 cut/official 发布事务移入按 root 串行的受管 worker，保留完整扫描与原有协调协议；worker 复用并在空闲时回收。补齐失败派发、迟到退出和 worker 重建的生命周期处理。

package/README.md

@@ -4,6 +4,18 @@
 
 版本变更见 [CHANGELOG.md](CHANGELOG.md)。
 
+## 测评实证
+
+完整数据、原始口径和限制见 [docs/benchmarks.md](docs/benchmarks.md)，结构化数字见 [docs/benchmark-results.json](docs/benchmark-results.json)。
+
+- **1.0.5 失忆对比**：同一真实 DeepSeek 会话，15 道回忆题两边都是 15/15；Live Compact 的日志中段细节两次都是 3/3，原版一次 1/3、一次 3/3。
+- **历史 DSH 长链路**：早期 150 道短题和 20 道 WebUniverse 连续任务都保留了原版／Live Compact 对照表；它们是历史实测，不是 1.1.6 的新验收。
+- **OpenCode 移植参考**：独立项目 [opencode-live-compact](https://github.com/Haoming9527/opencode-live-compact) 把插件移植到 OpenCode，和 OpenCode 自带的 autocompact 做了对照：在 OpenCode 2.2.6 + GPT-6 Luna 上跑 Aider 150 和 Web-Bench React 20，任务分别 150/150、20/20 且最终浏览器测试 59/59；估算费用分别低 14.3% 和 42.1%。这是 OpenCode 项目的结果，用来说明移植后的可复核测评方法，不冒充 DSH 运行结果。
+
+![早期 DSH 两场实测](docs/slide-results.jpg)
+
+![OpenCode Aider / Web-Bench 对照](docs/benchmarks-opencode-2026-11-09.png)
+
 ## 云端和本地怎么用
 
 - **用 DeepSeek、GLM 这类云端 API**，按下面的命令安装即可。先看答案是否正确，再一起看缓存命中、未命中输入和实际费用。命中率的百分比不是费用本身，输入变少时要连同 token 数一起比较。
@@ -16,13 +28,13 @@
 headless：
 
 ```sh
-dsh plugin --profile headless add dsh-live-compact@1.1.5
+dsh plugin --profile headless add dsh-live-compact@1.1.6
 ```
 
 网页端：
 
 ```sh
-dsh plugin --profile web add dsh-live-compact@1.1.5
+dsh plugin --profile web add dsh-live-compact@1.1.6
 ```
 
 想先装到本机看版本：
@@ -150,7 +162,7 @@ Windows 会重新设置备份访问权限，失败时停止写备份并保留原
 
 插件小切参数在每次轮后维护开始时取得本引擎的一致快照，保存后下一次维护生效，多个引擎互不覆盖。官方大压缩参数沿用宿主的构造时快照，保存后需要重建引擎或会话。宿主支持的 `retainRatio`、`maxTokens`、摘要模型路由、`modelPolicies`、溢出重试等配置继续由宿主校验并保留；`retainRatio` 与 `retainTokens` 互斥。
 
-接管开关只影响未来加载的官方预设。新预设按 **预设引擎显式配置 > 根插件显式配置 > 有效环境变量 > 默认值** 取值；已有预设保留加载时的数值，根设置后续修改需要重新加载预设。原生客户端 slot、资源声明和安装方式沿用现有接口。
+接管开关只影响未来加载的预设及 `compaction` 隔离组；直接注册预设和 Include 加载的组也按原位换包。新预设按 **预设引擎显式配置 > 根插件显式配置 > 有效环境变量 > 默认值** 取值；已有预设保留加载时的数值，根设置后续修改需要重新加载预设。原生客户端 slot、资源声明和安装方式沿用现有接口。
 
 每个新的 `compact-checkpoint` 只让轮后小切跳过一次，`spine-checkpoint` 不触发这个跳过。
 
@@ -174,8 +186,8 @@ Windows 会重新设置备份访问权限，失败时停止写备份并保留原
 从 npm 装。headless 和网页是两个 profile，要各装一次。桌面端是另一个 profile，普通 `dsh plugin --profile desktop` 会被拒绝。
 
 ```sh
-dsh plugin --profile headless add dsh-live-compact@1.1.5
-dsh plugin --profile web add dsh-live-compact@1.1.5
+dsh plugin --profile headless add dsh-live-compact@1.1.6
+dsh plugin --profile web add dsh-live-compact@1.1.6
 ```
 
 想先装到本机看版本：
@@ -188,15 +200,15 @@ dsh-live-compact --version
 上不了 npm 时的镜像安装命令：
 
 ```sh
-dsh plugin --profile headless add https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.1.5.tgz
-dsh plugin --profile web add https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.1.5.tgz
-npm install -g --force "https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.1.5.tgz"
+dsh plugin --profile headless add https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.1.6.tgz
+dsh plugin --profile web add https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.1.6.tgz
+npm install -g --force "https://download.merkyorlynn.com/downloads/plugins/dsh-live-compact-1.1.6.tgz"
 dsh-live-compact --version
 ```
 
 需要 DSH `>=0.2.0-rc.2 <0.3.0`。装上后跑长任务，日志里出现 `spine cut …ms` 才算这刀生效。页面：https://download.merkyorlynn.com/live-compact.html
 
-DSH-TUI 同样换不掉预设里的原版压缩，先不要装。
+DSH-TUI 先不要装。本包已补预设压缩隔离组的接管；TUI 仍需适配 `spine-checkpoint` 的局部卡片显示，两仓联合验收后再开放支持。
 
 被切掉的原文会写到 `~/.dsh/compaction-spine/shadow`。Unix 权限为目录 0700 / 文件 0600；Windows 新建/修正后的备份允许当前用户、SYSTEM、Administrators，历史文件及缓存限制见上面的 ACL 说明。上限 256MB。快满时删最老的备份。卡片里的序号是会话日志的事件号。要在当前会话的备份里找一行，用 `import { searchShadow } from "dsh-live-compact/shadow-search"`。插件自己不会去搜。
 

package/gate.js

@@ -4,9 +4,55 @@ import { configSnapshot, engineConfig } from "./settings.js";
 
 const OURS = "dsh-live-compact";
 const PRESET_IDS = new Set(["standard", "ptc", "minimal", "cordis", "preset-standard", "preset-ptc", "preset-minimal", "preset-cordis"]);
+const COMPETING_COMPRESSORS = new Set(["bili-native", "billion-context"]);
+const COMPETING_FIBER_STATES = new Set([1, 2]); // Cordis 4.1: LOADING=1, ACTIVE=2.
+const standDownNotices = new WeakMap();
 export const GATE_SERVICE = "liveCompactPresetGate";
 export const PRESET_ENGINE_CONFIG = Object.freeze(engineConfig());
 
+/**
+ * Return the exact active compressor runtimes that own the session when they
+ * are loading or active. Cordis keeps one runtime per plugin callback and
+ * exposes every live fiber through `ctx.registry.values()`; a package on disk
+ * or a failed/unloading fiber is not an active compressor.
+ */
+export function activeCompactionPeers(ctx) {
+  const peers = [];
+  if (process.env.SPINE_STAND_DOWN === "1") peers.push("SPINE_STAND_DOWN");
+  const registry = ctx?.registry;
+  if (!registry || typeof registry.values !== "function") return peers;
+  try {
+    for (const runtime of registry.values()) {
+      const name = runtime?.name;
+      if (!COMPETING_COMPRESSORS.has(name)) continue;
+      const active = [...(runtime?.fibers || [])].some((fiber) => COMPETING_FIBER_STATES.has(fiber?.state));
+      if (active && !peers.includes(name)) peers.push(name);
+    }
+  } catch {
+    // Cordis 4.1 always exposes an iterable registry. If an older/partial host
+    // cannot enumerate it, preserve the single-plugin path and do not guess a
+    // competing package from installation state.
+  }
+  return peers;
+}
+
+export function compactionStandDown(ctx) {
+  return activeCompactionPeers(ctx).length > 0;
+}
+
+export function warnCompactionStandDown(ctx, logger = ctx?.logger) {
+  const peers = activeCompactionPeers(ctx);
+  if (!peers.length) return peers;
+  const root = ctx?.root || ctx;
+  const key = peers.join(",");
+  if (root && standDownNotices.get(root) === key) return peers;
+  if (root) standDownNotices.set(root, key);
+  logger?.warn?.(peers[0] === "SPINE_STAND_DOWN"
+    ? "spine: SPINE_STAND_DOWN=1，已有压缩插件接管，本插件不切、不改预设。"
+    : `spine: 已有压缩插件接管（${peers.join(", ")}），本插件不切、不改预设。`);
+  return peers;
+}
+
 const require = createRequire(import.meta.url);
 
 export function packageLoadable(load = (name) => require(name)) {
@@ -66,8 +112,9 @@ function rewriteNode(node, loadable, rootConfig) {
   return next;
 }
 
-export function rewritePresetConfig(config, loadable = packageLoadable(), rootConfig = {}) {
-  if (!isPreset(config)) return config;
+export function rewritePresetConfig(config, loadable = packageLoadable(), rootConfig = {}, entry) {
+  const group = Array.isArray(config) && entry?.group === true && entry.isolate?.compaction === true;
+  if (!isPreset(config) && !group) return config;
   return rewriteNode(config, loadable, rootConfig);
 }
 
@@ -75,6 +122,7 @@ function engineEntry(node) {
   if (!node || typeof node !== "object") return null;
   if (node.name === OURS) return node;
   const nested = [];
+  if (Array.isArray(node)) nested.push(...node);
   if (Array.isArray(node.plugins)) nested.push(...node.plugins);
   if (Array.isArray(node.config)) nested.push(...node.config);
   else if (node.config && typeof node.config === "object") nested.push(node.config);
@@ -113,13 +161,18 @@ export function installPresetGate(ctx, config = {}, { legacy = false } = {}) {
     return typeof value === "boolean" ? value : value.get();
   };
   const seen = new Set();
-  gate.disposeListener = ctx.on("internal/config", function (_raw, next) {
+  gate.disposeListener = ctx.on("internal/config", function (fiber, next) {
     const resolved = next();
+    if (compactionStandDown(ctx)) {
+      warnCompactionStandDown(ctx);
+      return resolved;
+    }
     if (!gate.active || !enabled()) return resolved;
     const loadable = packageLoadable();
-    const rewritten = rewritePresetConfig(resolved, loadable, config);
-    const id = rewritten?.id || rewritten?.config?.id;
-    if (isPreset(resolved) && id && !seen.has(String(id))) {
+    const entry = fiber?.entry?.options;
+    const rewritten = rewritePresetConfig(resolved, loadable, config, entry);
+    const id = rewritten?.id || rewritten?.config?.id || entry?.id;
+    if (rewritten !== resolved && id && !seen.has(String(id))) {
       seen.add(String(id));
       const engine = engineEntry(rewritten);
       if (engine) {

package/index.js

@@ -39,6 +39,7 @@ import {
 } from "./shadow.js";
 import { buildSendLess, decideThunder } from "./thunder.js";
 import { inCooldown, skipLiveOfficialCompaction } from "./cooldown.js";
+import { activeCompactionPeers, warnCompactionStandDown } from "./gate.js";
 
 const { BasicCompactionEngine } = await loadBase();
 const { CompactionId, toolPairingBalancedAfter, toolPairingBalancedBefore } = await loadCompaction();
@@ -56,6 +57,7 @@ const CAPTURE_RESULT_BATCH = 1;
 const RECOVER_RAW_BATCH = 1;
 const CAPTURE_RETRY_LIMIT = 8;
 const RECOVERY_ACL_REAUTH_LIMIT = 32;
+const SHADOW_WORKER_TIMEOUT_MS = 30000;
 
 const shadowWorkers = new Map();
 
@@ -88,7 +90,10 @@ function shadowWorkerFor(root) {
       clearTimeout(entry.idleTimer);
       entry.idleTimer = null;
     }
-    for (const { reject } of entry.pending.values()) reject(error);
+    for (const { reject, timer } of entry.pending.values()) {
+      if (timer) clearTimeout(timer);
+      reject(error);
+    }
     entry.pending.clear();
     removeEntry();
     worker.terminate().catch(() => {});
@@ -96,6 +101,7 @@ function shadowWorkerFor(root) {
   worker.on("message", (message) => {
     const task = entry.pending.get(message?.id);
     if (!task) return;
+    if (task.timer) clearTimeout(task.timer);
     entry.pending.delete(message.id);
     if (message?.ok) {
       task.resolve(message.result);
@@ -130,10 +136,16 @@ function runShadowWorker(payload) {
   }
   const id = entry.nextId++;
   return new Promise((resolve, reject) => {
-    entry.pending.set(id, { resolve, reject });
+    const timer = setTimeout(() => {
+      const error = Object.assign(new Error("spine: shadow worker timed out"), { code: "ESHADOWWORKER" });
+      failShadowWorker(entry, error);
+    }, SHADOW_WORKER_TIMEOUT_MS);
+    timer.unref?.();
+    entry.pending.set(id, { resolve, reject, timer });
     try {
       entry.worker.postMessage({ id, payload });
     } catch (error) {
+      clearTimeout(timer);
       entry.pending.delete(id);
       reject(error);
       entry.scheduleIdleExit();
@@ -141,6 +153,24 @@ function runShadowWorker(payload) {
   });
 }
 
+function failShadowWorker(entry, error) {
+  if (!entry || entry.retired) return;
+  entry.retired = true;
+  if (entry.idleTimer) {
+    clearTimeout(entry.idleTimer);
+    entry.idleTimer = null;
+  }
+  for (const { reject, timer } of entry.pending.values()) {
+    if (timer) clearTimeout(timer);
+    reject(error);
+  }
+  entry.pending.clear();
+  for (const [key, value] of shadowWorkers) {
+    if (value === entry) shadowWorkers.delete(key);
+  }
+  entry.worker.terminate().catch(() => {});
+}
+
 function recoveryRetryable(record, dir, toolCallId) {
   if (record?.retryable === true || record?.reason === "unwritable") return true;
   // A completely absent backup has never been captured and can be retried.
@@ -150,6 +180,11 @@ function recoveryRetryable(record, dir, toolCallId) {
   return false;
 }
 
+function captureErrorRetryable(error) {
+  const code = error?.code;
+  return code === "ESHADOWBUSY" || ["EAGAIN", "EBUSY", "EINTR", "EIO"].includes(code);
+}
+
 function eventContent(session, seq) {
   const event = session.eventAt(seq);
   if (event?.type === "assistant/message") return event.data?.message?.content ?? event.data?.content;
@@ -170,7 +205,27 @@ function isCheckpoint(session, seq) {
   // 自己的卡片，以及已经写过的官方标记，都要停住。新卡片不再用官方标记。
   // 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);
+  // The legacy text marker is only meaningful on a user/message card and only
+  // at the beginning of its text. A tool result or an ordinary sentence that
+  // merely mentions the marker must not create a permanent cut boundary.
+  if (event?.type !== "user/message") return false;
+  const text = eventText(session, seq).trimStart();
+  return text === MARK || text.startsWith(`${MARK}\n`) || text.startsWith(`${MARK}\r\n`);
+}
+
+function latestTurnCompleted(events) {
+  let lastStart = -1;
+  let lastEnd = -1;
+  let reason;
+  for (let index = 0; index < (events || []).length; index += 1) {
+    const event = events[index];
+    if (event?.type === "turn/start") lastStart = index;
+    if (event?.type === "turn/end") {
+      lastEnd = index;
+      reason = event.data?.reason?.kind;
+    }
+  }
+  return lastEnd > lastStart && reason === "completed";
 }
 
 function spineCheckpointSource(compactionId) {
@@ -367,8 +422,6 @@ function selectNewestChunk(session, measurement, key = DEFAULT_KEY, context = {}
   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 && classifications[end].isGenuineUserBoundary && !(floorCard >= 0 && end - 1 <= floorCard)) end -= 1;
     if (floorCard >= 0 && end <= floorCard) return null;
@@ -456,6 +509,9 @@ function selectNewestChunk(session, measurement, key = DEFAULT_KEY, context = {}
   };
   let usedLongCut = false;
   let picked = null;
+  const fallbackWithoutLongRead = () => context.disableLongRead
+    ? null
+    : selectNewestChunk(session, measurement, key, { ...context, disableLongRead: true });
   if (longSpan) {
     const longPicked = cutLongReadRound(items, longSpan.start, longSpan.end, cutOptions);
     if (longPicked && longPicked.start >= longSpan.start && longPicked.end <= longSpan.end) {
@@ -481,27 +537,39 @@ function selectNewestChunk(session, measurement, key = DEFAULT_KEY, context = {}
         }
       }
     }
-    if (pairStart < 0) return null;
-    if (usedLongCut && pairStart < longSpan.start) return null;
-    if (!pointerSpanAllowed(items, pairStart, picked.end, context.engine || "cloud")) return null;
-    if (!cutOk(toolPairingBalancedBefore, session, nodes[pairStart])) return null;
+    if (pairStart < 0) return usedLongCut ? fallbackWithoutLongRead() : null;
+    if (usedLongCut && pairStart < longSpan.start) return fallbackWithoutLongRead();
+    if (!pointerSpanAllowed(items, pairStart, picked.end, context.engine || "cloud")) return usedLongCut ? fallbackWithoutLongRead() : null;
+    if (!cutOk(toolPairingBalancedBefore, session, nodes[pairStart])) return usedLongCut ? fallbackWithoutLongRead() : null;
     picked.start = pairStart;
   }
-  if (usedLongCut && (picked.start < longSpan.start || picked.end > longSpan.end)) return null;
+  if (usedLongCut && (picked.start < longSpan.start || picked.end > longSpan.end)) return fallbackWithoutLongRead();
   const start = picked.start;
   end = picked.end;
   const tokens = items.slice(start, end + 1).reduce((sum, item) => sum + item.tokens, 0);
   const pieces = spanPieces(start, end);
-  if (picked.pointerOnly && pieces.some((piece) => piece.role === "tool" && isToolFailure(piece.text, piece.isError))) return null;
+  if (picked.pointerOnly && pieces.some((piece) => piece.role === "tool" && isToolFailure(piece.text, piece.isError))) {
+    return usedLongCut ? fallbackWithoutLongRead() : null;
+  }
   let card = picked.pointerOnly
     ? { ok: true, text: pointerOnlyText(pieces), hardLines: [], missing: [], needsBackup: false, rawPaths: [] }
     : buildCard(pieces.map((piece) => piece.text).join("\n"), liveText(start, end), pieces, extras);
-  if (card.ok !== true) return null;
+  if (card.ok !== true) return usedLongCut ? fallbackWithoutLongRead() : null;
   card = attachBackupHint(card, freshShadowFile("cut", key));
   if (!card.text.includes("不是备份文件路径")) card = { ...card, text: `${card.text}\n序号是本会话日志里的事件号，不是备份文件路径。` };
   if (!cutOk(toolPairingBalancedAfter, session, nodes[end])) return null;
   let after = 0;
   for (let index = end + 1; index < priced.length; index += 1) after += priced[index].tokens;
+  // `keptTokens` must describe retained rounds to the right of the actual
+  // cut. A long-read cut can be newer than the ordinary rounds selected above;
+  // counting those older rounds made `tailBeyondKept` negative and disabled
+  // the tail guard.
+  for (const round of rounds) {
+    const roundStart = visible[round.start]?.index;
+    const roundEnd = visible[round.end]?.index;
+    if (!Number.isInteger(roundStart) || !Number.isInteger(roundEnd) || roundStart <= end) continue;
+    for (let index = roundStart; index <= roundEnd; index += 1) keptTokens += priced[index].tokens;
+  }
   let prefix = 0;
   for (let index = 0; index < start; index += 1) prefix += priced[index].tokens;
   return { start: nodes[start], end: nodes[end], tokens, after, keptTokens, card, prefix };
@@ -544,6 +612,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
       });
       ctx.on("session/event", (session, event) => {
         try {
+          if (this.standDown?.()) return;
           this.noteEvent(session, event);
           if (event?.type !== "tool/result") return;
           const id = event.data?.message?.toolCallId;
@@ -557,6 +626,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
           job = new Promise((resolve) => {
             scheduleImmediate(() => {
               try {
+                if (this.standDown?.()) return;
                 const current = this.rawSeen.get(key);
                 if (!current || current.retryable) {
                   const record = this.captureOne(session, event);
@@ -580,10 +650,11 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
       });
       ctx.on("agent/status", ({ agent, status }) => {
         if (status !== "idle") return;
+        if (this.standDown?.()) return;
         const state = this.stateFor(agent);
         if (state.warming) return;
         const events = agent.session.snapshotEvents();
-        const done = events.some((event) => event.type === "turn/end" && event.data?.reason?.kind === "completed");
+        const done = latestTurnCompleted(events);
         if (!done) return;
         state.warming = true;
         const job = this.finishTurn(agent, events, { deferCapture: true })
@@ -600,6 +671,24 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
     }
   }
 
+  standDown() {
+    const peers = activeCompactionPeers(this.ctx);
+    if (peers.length) warnCompactionStandDown(this.ctx);
+    return peers.length > 0;
+  }
+
+  ownedSignal(signal) {
+    const controller = new AbortController();
+    const dispose = this.ctx.on("internal/status", () => {
+      if (this.standDown?.()) controller.abort();
+    }, { global: true });
+    if (this.standDown?.()) controller.abort();
+    return {
+      signal: signal ? AbortSignal.any([signal, controller.signal]) : controller.signal,
+      dispose,
+    };
+  }
+
   stateFor(agent) {
     const key = sessionKey(agent);
     let state = this.sessionState.get(key);
@@ -700,6 +789,10 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
     scheduleImmediate(() => {
       task.scheduled = false;
       try {
+        if (this.standDown?.()) {
+          this.finishCaptureCatchup(task);
+          return;
+        }
         const latest = task.freezeSnapshot ? null : task.session.snapshotEvents?.();
         const latestTail = Number.isInteger(latest?.at?.(-1)?.seq) ? latest.at(-1).seq : -1;
         const latestSurfaceTail = task.session.surface?.nodes?.at?.(-1) ?? -1;
@@ -779,18 +872,20 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
     this.pendingCatchups.delete(task.key);
     this.pendingCatchupJobs.delete(task.promise);
     task.resolve();
-    if (task.retryRequested && task.progressed) this.scheduleMaintenanceRetry(task.agent);
+    if (!this.standDown?.() && task.retryRequested && task.progressed) this.scheduleMaintenanceRetry(task.agent);
   }
 
   scheduleMaintenanceRetry(agent) {
+    if (this.standDown?.()) return;
     const state = this.stateFor(agent);
     if (state.retryScheduled) return;
     state.retryScheduled = true;
     scheduleImmediate(() => {
       state.retryScheduled = false;
+      if (this.standDown?.()) return;
       if (state.warming) return;
       const events = agent.session.snapshotEvents();
-      const done = events.some((event) => event.type === "turn/end" && event.data?.reason?.kind === "completed");
+      const done = latestTurnCompleted(events);
       if (!done) return;
       state.warming = true;
       const job = this.finishTurn(agent, events, { deferCapture: true })
@@ -804,6 +899,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
   }
 
   async finishTurn(agent, events, options = {}) {
+    if (this.standDown?.()) return null;
     const settings = readSettings(this.liveConfig);
     const state = this.stateFor(agent);
     const signal = AbortSignal.timeout(30000);
@@ -824,16 +920,28 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
     const calls = indexToolCalls(ev);
     try {
       await agent.runMaintenance(async (agentSignal) => {
+        if (this.standDown?.()) return;
         const op = AbortSignal.any([agentSignal, signal]);
         let measurement = this.ctx.tokenMeter.measure(agent.session);
-        if (measurement.totalTokens < settings.minTokens || measurement.totalTokens >= settings.bigGate) return;
+        const settleTurnBaseline = () => {
+          state.turnBase = measurement.totalTokens;
+          state.maxTurnGrowth = 0;
+        };
+        if (measurement.totalTokens < settings.minTokens || measurement.totalTokens >= settings.bigGate) {
+          settleTurnBaseline();
+          return;
+        }
         // Restored cards establish a baseline; a live card still skips once,
         // even when maintenance or engine construction is delayed.
         if (skipLiveOfficialCompaction(agent.session)) {
           this.ctx.logger?.info?.("spine cooldown: live official compaction seen, skip this pass");
+          settleTurnBaseline();
+          return;
+        }
+        if (inCooldown(agent.session, { windowMs: settings.cooldownMs })) {
+          settleTurnBaseline();
           return;
         }
-        if (inCooldown(agent.session, { windowMs: settings.cooldownMs })) return;
         this.ensurePruneGuard();
         const resolved = this.engineFor(agent);
         if (state.engine !== resolved.engine || state.engineSource !== resolved.source) {
@@ -880,7 +988,8 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
             state.localOnly = true;
             state.approvedCard = chunk.card;
             await this.flushPendingCaptures(agent.session, this.chunkToolCallIds(agent.session, chunk));
-            await this.commitSelectedSpan(agent, chunk, op);
+            const committed = await this.commitSelectedSpan(agent, chunk, op);
+            if (committed === false) break;
             measurement = this.ctx.tokenMeter.measure(agent.session);
             const after = measurement.totalTokens;
             reduced = after < before;
@@ -915,6 +1024,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
         }
         if (drainNotes.length) flushDrainStats(shadowDirectory(), drainNotes, { sid: state.key, drain });
         state.turnBase = measurement.totalTokens;
+        state.maxTurnGrowth = 0;
         await this.ctx.sessions?.flush?.(agent.session);
         this.rememberPrefix(agent);
       });
@@ -956,6 +1066,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
   }
 
   async commitSelectedSpan(agent, chunk, signal) {
+    if (this.standDown?.()) return false;
     signal?.throwIfAborted();
     const session = agent.session;
     if (chunk.card?.ok !== true || !chunk.card.text) throw new Error("spine: approved card missing; leaving the span");
@@ -1022,6 +1133,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
     }
     const summarized = await this.summarize({ messages, liveCompact: { card: chunk.card } }, agent, signal);
     signal?.throwIfAborted();
+    if (this.standDown?.()) return false;
     assertCurrentSpan(shadowedSeqs);
     const compactionId = CompactionId(randomUUID());
     const checkpointMessage = createUserMessage({
@@ -1081,11 +1193,27 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
   }
 
   async compactIfNeeded(agent, trigger, signal) {
+    if (this.standDown?.()) return null;
     const state = this.stateFor(agent);
     state.liveAgent = agent;
     state.localOnly = false;
     this.ensurePruneGuard();
-    return super.compactIfNeeded(agent, trigger, signal);
+    const owned = this.ownedSignal(signal);
+    try {
+      return await super.compactIfNeeded(agent, trigger, owned.signal);
+    } finally {
+      owned.dispose?.();
+    }
+  }
+
+  async compactNow(agent, signal, sourceCommandId) {
+    if (this.standDown?.()) return null;
+    const owned = this.ownedSignal(signal);
+    try {
+      return await super.compactNow(agent, owned.signal, sourceCommandId);
+    } finally {
+      owned.dispose?.();
+    }
   }
 
   // Preserve explicit URL precedence. Only the exact account provider gets
@@ -1094,9 +1222,11 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
     const header = agent?.session?.requestHeader?.()?.config || {};
     const context = agent?.session?.requestContext?.() || {};
     const provider = header.provider || context.provider || "";
+    const model = header.model || context.model || "";
     const listed = this.listedProviders();
     const baseURL = resolveProviderBaseURL({
       provider,
+      model,
       headerURL: header.baseURL || context.baseURL || "",
       listed,
       layers: this.providerLayers(),
@@ -1168,10 +1298,21 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
       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);
+        return list.map((entry) => {
+          let models = [];
+          try {
+            const declared = typeof entry?.getModels === "function" ? entry.getModels() : entry?.models || [];
+            models = (Array.isArray(declared) ? declared : []).map((model) => ({
+              id: model?.id || "",
+              baseURL: model?.baseUrl || model?.baseURL || "",
+            })).filter((model) => model.id && model.baseURL);
+          } catch {}
+          return {
+            id: entry?.id || "",
+            baseURL: entry?.baseUrl || entry?.baseURL || "",
+            models,
+          };
+        }).filter((entry) => entry.id && (entry.baseURL || entry.models.length));
       } catch {}
     }
     return [];
@@ -1201,6 +1342,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
   }
 
   captureOne(session, event, access = {}) {
+    if (this.standDown?.()) return null;
     const id = event?.data?.message?.toolCallId;
     if (!id) return null;
     const key = session?.id || DEFAULT_KEY;
@@ -1247,7 +1389,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
       }
       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, retryable: error?.code === "ESHADOWBUSY" };
+      const record = { ok: false, reason: "unwritable", toolCallId: id, retryable: captureErrorRetryable(error) };
       this.rawSeen.set(mapKey, record);
       return record;
     }
@@ -1307,6 +1449,15 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
   }
 
   captureNewBatch(session, events, settings = readSettings(this.liveConfig), limits = {}) {
+    if (this.standDown?.()) {
+      return {
+        seen: new Set(),
+        progressed: false,
+        retryable: false,
+        done: true,
+        nextIndex: Number.isInteger(limits.startIndex) ? limits.startIndex : 0,
+      };
+    }
     if (!Array.isArray(events)) events = [];
     const key = session?.id || DEFAULT_KEY;
     const cursor = this.captureCursorStart(session, events, settings);
@@ -1371,6 +1522,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
   }
 
   captureNew(session, events, settings = readSettings(this.liveConfig)) {
+    if (this.standDown?.()) return new Set();
     if (!Array.isArray(events)) events = [];
     const key = session?.id || DEFAULT_KEY;
     const cursor = this.captureCursorStart(session, events, settings);
@@ -1426,6 +1578,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
   }
 
   writeCaptureCursor(key, cursor, access = {}) {
+    if (this.standDown?.()) return;
     if (this.persistCapture !== true || !Number.isSafeInteger(cursor) || cursor < 0) return;
     let tmp;
     let fd;
@@ -1452,6 +1605,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
   }
 
   recoverVisibleRaw(session, access = {}) {
+    if (this.standDown?.()) return;
     const dir = sessionDir(shadowDirectory(), session?.id || DEFAULT_KEY);
     const ids = [...new Set(this.surfaceToolIds(session))];
     if (ids.length && existsSync(dir)) ensureShadowDir(dir, access);
@@ -1486,6 +1640,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
   }
 
   recoverVisibleRawBatch(session, access = {}, startIndex = 0, limit = RECOVER_RAW_BATCH, visibleIds = null) {
+    if (this.standDown?.()) return { nextIndex: startIndex, done: true, progressed: false };
     const ids = visibleIds || [...new Set(this.surfaceToolIds(session))];
     const dir = sessionDir(shadowDirectory(), session?.id || DEFAULT_KEY);
     if (ids.length && startIndex === 0 && existsSync(dir)) {
@@ -1536,6 +1691,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
   }
 
   captureSession(session) {
+    if (this.standDown?.()) return new Set();
     const key = session?.id || DEFAULT_KEY;
     const events = session?.snapshotEvents?.() || [];
     const fingerprint = this.captureRecoveryFingerprint(session, events);
@@ -1592,6 +1748,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
   }
 
   ensurePruneGuard() {
+    if (this.standDown?.()) return;
     if (this.pruneGuarded) return;
     let pruner;
     try {
@@ -1609,6 +1766,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
     function guarded(session) {
       const engine = pruner.__spineEngine;
       try {
+        if (engine.standDown?.()) return;
         engine.captureSession(session);
         return runPruneAfterCapture(engine.surfaceToolIds(session), engine.rawVerifiedSet(session), () => original(session));
       } catch (error) {
@@ -1651,6 +1809,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
     access = {},
     rotationIO = {},
   ) {
+    if (this.standDown?.()) return { ok: false, reason: "stand-down" };
     return saveShadowImpl.call(
       this,
       messages,
@@ -1672,6 +1831,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
     access = {},
     rotationIO = {},
   ) {
+    if (this.standDown?.()) return { ok: false, reason: "stand-down" };
     if (!access.runner && (access.platform ?? process.platform) === "win32" && shadowAccessFused()) {
       const error = new Error("spine: shadow permission already failed; backup refused");
       error.code = "ESHADOWACCESS";
@@ -1767,7 +1927,7 @@ export default class SpineCompactionEngine extends BasicCompactionEngine {
       role: message?.role ?? message?.message?.role,
       text: messageText(message),
     })));
-    const facts = [...new Set([...(trunk.hardLines || []), ...(trunk.missing || [])])];
+    const facts = [...(trunk.hardFacts || []), ...(trunk.missingFacts || [])];
     const slim = buildSendLess({ taskLine, uncovered: trunk.uncovered, facts });
     return this.summarizeOfficial({
       ...input,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-live-compact",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "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>",
@@ -43,7 +43,7 @@
     "compaction"
   ],
   "scripts": {
-    "test:gate": "node test/p0-gate.mjs && node test/p0-blockers.mjs && node test/excerpt.mjs && node test/shadow-worker.mjs && node test/shadow-worker-pool.mjs && node test/shadow-worker-fuse.mjs && node --test test/failed-diagnostics.test.mjs test/public-exports.test.mjs test/cooldown.test.mjs test/gate-config.test.mjs test/drain-stopline.mjs test/scan-once.mjs test/issue-19.mjs test/issue-20.mjs test/issue-34.mjs test/windows-acl.test.mjs test/issue-27.mjs test/issue-29.mjs test/issue-29-notice.mjs test/client-settings.test.mjs test/settings-integration.test.mjs test/runtime-lifecycle.mjs test/shadow-lifecycle.mjs test/finalize-over-32000.mjs",
+    "test:gate": "node test/p0-gate.mjs && node test/p0-blockers.mjs && node test/excerpt.mjs && node test/shadow-worker.mjs && node test/shadow-worker-pool.mjs && node test/shadow-worker-fuse.mjs && node --test test/failed-diagnostics.test.mjs test/public-exports.test.mjs test/cooldown.test.mjs test/gate-config.test.mjs test/stand-down.test.mjs test/drain-stopline.mjs test/scan-once.mjs test/issue-19.mjs test/issue-20.mjs test/issue-34.mjs test/windows-acl.test.mjs test/issue-27.mjs test/issue-29.mjs test/issue-29-notice.mjs test/client-settings.test.mjs test/settings-integration.test.mjs test/runtime-lifecycle.mjs test/shadow-lifecycle.mjs test/finalize-over-32000.mjs test/p1-fable-review.mjs",
     "test:compat41": "node test/compat-cordis41.mjs",
     "test:live-gate": "python3 -B -m unittest discover -s test/live-fill -p test_*.py"
   },

package/plan.js

@@ -734,11 +734,18 @@ export function providerURLFromPatch(text, provider) {
 
 // 内置目录只在这家没有自己的地址时使用。调用方传入 {id, baseURL}，这里不读包。
 // Use a built-in catalog URL only when this provider has no URL of its own.
-export function catalogProviderURL(provider, catalog) {
+export function catalogProviderURL(provider, catalog, model = "") {
   const name = String(provider || "");
   if (!name || !catalog) return "";
   const list = Array.isArray(catalog) ? catalog : [];
   const match = list.find((entry) => entry?.id === name || entry?.provider === name);
+  const modelName = String(model || "");
+  if (match && modelName) {
+    const models = Array.isArray(match.models) ? match.models : [];
+    const modelMatch = models.find((entry) => entry?.id === modelName || entry?.model === modelName);
+    const modelURL = modelMatch?.baseURL || modelMatch?.baseUrl || "";
+    if (modelURL) return String(modelURL);
+  }
   return String(match?.baseURL || match?.baseUrl || "");
 }
 
@@ -748,6 +755,7 @@ export function catalogProviderURL(provider, catalog) {
 // Official DeepSeek and the built-in catalog apply only when the profile has no URL. Empty stays unresolved.
 export function resolveProviderBaseURL({
   provider = "",
+  model = "",
   headerURL = "",
   listed = [],
   layers = [],
@@ -775,7 +783,7 @@ export function resolveProviderBaseURL({
   if (provider === "deepseek-account" && launch) return launch;
   const fallback = fallbackProviderURL(provider);
   if (fallback) return fallback;
-  return catalogProviderURL(provider, catalog);
+  return catalogProviderURL(provider, catalog, model);
 }
 
 export function resolveEngine({ provider = "", baseURL = "", env = process.env } = {}) {
@@ -1185,6 +1193,17 @@ function hasProtectedToolFact(line) {
   return /必须|不要|禁止|口令|方案|[a-z]{2,}-[a-z0-9]+-\d+|\bpinned\s+to\b/i.test(line);
 }
 
+// A model/version/region token by itself is ordinary prose. Only retain an
+// assistant line as an unresolved decision when the line contains a decision
+// verb or the explicit Chinese plan form; this avoids treating `us-east-1`
+// and `claude-3-5` as commands that block the cut.
+function unresolvedAssistantDecision(line) {
+  const text = String(line || "");
+  if (/方案\s*[A-Za-z0-9]/.test(text)) return true;
+  if (/(?:决定|采用|选用|选择|固定为|改用|切换到|定为|使用|确定)/.test(text)) return true;
+  return /\b(?:pinned\s+to|decid(?:e|ed|es)|adopt(?:ed|s)?|selected|choose|chosen|will\s+use|must\s+use)\b/i.test(text);
+}
+
 function normalizeSourceLine(role, text) {
   return (role === "tool" ? text.replace(/^[ \t]*\d+:[ \t]*/, "") : text).trim();
 }
@@ -1316,7 +1335,7 @@ export function buildCard(
     if (source.role !== "assistant") continue;
     source.text.split(/\r?\n/).forEach((line) => {
       if (liveLines.has(line.trim())) return;
-      if (/[a-z]{2,}-[a-z0-9]+-\d+/i.test(line) || /方案\s*[A-Za-z0-9]/.test(line)) {
+      if (unresolvedAssistantDecision(line)) {
         coverage.ok = false;
         coverage.missing.push({ sourceId: source.id, text: line, reason: "assistant-decision-not-retained" });
       }
@@ -1373,10 +1392,15 @@ export function buildCard(
     failureDiagnosticsComplete: incompleteFailures.length === 0,
     scope: TRUNK_SCOPE,
     hardLines: hard.map((item) => item.line),
+    hardFacts: hard.map((item) => ({ role: item.role, line: item.line })),
     hardCount: hard.length,
     omittedHard,
     deferred,
     missing,
+    missingFacts: coverage.missing.map((item) => ({
+      role: sourceById.get(item.sourceId)?.role || "unknown",
+      line: item.text,
+    })),
     omittedOrdinaryToolLines: omittedOrdinaryToolLines,
     uncovered: split.uncovered,
     keptChars: used,

package/raw.js

@@ -20,6 +20,10 @@ import {
 
 export const PRUNE_MARKER = "[... tool result middle pruned ...]";
 
+function transientCaptureError(error) {
+  return ["ESHADOWBUSY", "EAGAIN", "EBUSY", "EINTR", "EIO"].includes(error?.code);
+}
+
 export function contentHash(text) {
   const hash = createHash("sha256");
   hash.update(typeof text === "string" ? Buffer.from(text, "utf8") : text);
@@ -122,7 +126,7 @@ export function captureToolResult(options) {
     ensureShadowDir(dir, access);
   } catch (error) {
     if (error?.code === "ESHADOWACCESS" || error?.code === "ESHADOWCLEANUP") throw error;
-    return { ok: false, reason: "unwritable", toolCallId };
+    return { ok: false, reason: "unwritable", toolCallId, retryable: transientCaptureError(error) };
   }
   let entered = false;
   try {
@@ -131,7 +135,7 @@ export function captureToolResult(options) {
       return captureToolResultLocked({ ...options, root });
     });
   } catch (error) {
-    if (!entered || error?.code === "ESHADOWBUSY") return { ok: false, reason: "unwritable", toolCallId, retryable: error?.code === "ESHADOWBUSY" };
+    if (!entered || transientCaptureError(error)) return { ok: false, reason: "unwritable", toolCallId, retryable: transientCaptureError(error) };
     throw error; // In particular, preserve exceptions from failed raw cleanup.
   }
 }
@@ -153,6 +157,8 @@ function captureToolResultLocked({
   const body = String(text ?? "");
   const file = join(dir, rawName(toolCallId));
   const metaPath = `${file}.meta.json`;
+  const bytes = Buffer.from(body, "utf8");
+  const hash = contentHash(bytes);
 
   if (!existsSync(file) && body.includes(PRUNE_MARKER)) {
     return { ok: false, reason: "already-pruned", toolCallId };
@@ -163,10 +169,24 @@ function captureToolResultLocked({
   let createdRaw = false;
 
   try {
-    if (existsSync(file)) return readProtectedExisting();
-
-    const bytes = Buffer.from(body, "utf8");
-    const hash = contentHash(bytes);
+    if (existsSync(file)) {
+      const existing = readProtectedExisting();
+      if (!existing.ok) {
+        // A raw without its meta marker is an incomplete publication. When
+        // the current event still has the original body, discard the orphan
+        // and rebuild the pair; a malformed/valid meta file remains fail-closed.
+        if (existing.reason === "missing-meta" && !body.includes(PRUNE_MARKER)) {
+          discardShadowFiles([file, metaPath], new Error("incomplete raw/meta pair"));
+        } else {
+          return existing;
+        }
+      }
+      if (existing.ok && body.includes(PRUNE_MARKER)) return existing;
+      if (existing.ok && (existing.sha256 !== hash || existing.bytes !== bytes.length)) {
+        return { ok: false, reason: "duplicate-tool-call-id", toolCallId, retryable: false };
+      }
+      if (existing.ok) return existing;
+    }
 
     writeShadowFile(file, bytes, access, { exclusive: true, root });
     createdRaw = true;
@@ -208,7 +228,7 @@ function captureToolResultLocked({
       return readProtectedExisting();
     }
 
-    return { ok: false, reason: "unwritable", toolCallId, retryable: error?.code === "ESHADOWBUSY" };
+    return { ok: false, reason: "unwritable", toolCallId, retryable: transientCaptureError(error) };
   }
 }
 

package/shadow.js

@@ -972,7 +972,24 @@ export function ensureShadowDir(dir, access = {}) {
   return dir;
 }
 
-export function tightenCreatedShadow(file, fd, access, { remember = true } = {}) {
+export function tightenCreatedShadow(file, fd, access, { remember = true, skipRunner = false } = {}) {
+  if (skipRunner) {
+    try {
+      const entry = accessEntry(file);
+      const opened = fstatSync(fd, { bigint: true });
+      if (!entry.identity || entry.identity !== accessIdentity(opened) || opened.nlink !== 1n) {
+        throw new Error("spine: shadow published file identity changed");
+      }
+      if (remember) lockedFiles.set(entry.canonical, entry);
+      return;
+    } catch (cause) {
+      tripFuse();
+      const error = new Error("spine: shadow permission action failed; backup refused", { cause });
+      error.code = "ESHADOWACCESS";
+      error.step = "file";
+      throw error;
+    }
+  }
   if ((access.platform ?? process.platform) === "win32" && !access.runner && !shadowAccessFused()) {
     try {
       if (shadowDirLocked(dirname(file))) {
@@ -1043,12 +1060,13 @@ function writeShadowFileLocked(file, body, access, { exclusive, write, unlink, a
   const dir = dirname(file);
   const parentIdentity = rememberShadowParent(dir);
 
-  const target = exclusive
-    ? file
-    : join(
-        dir,
-        `.${basename(file)}-${randomBytes(8).toString("hex")}.tmp`,
-      );
+  // Always stage the body in a private temporary file. Publishing the final
+  // name only after the bytes are flushed prevents readers from observing a
+  // half-written raw or meta file after a process interruption.
+  const target = join(
+    dir,
+    `.${basename(file)}-${randomBytes(8).toString("hex")}.tmp`,
+  );
 
   let fd = null;
   let created = false;
@@ -1058,25 +1076,34 @@ function writeShadowFileLocked(file, body, access, { exclusive, write, unlink, a
     fd = openSync(target, "wx", 0o600);
     created = true;
 
-    if (!exclusive) {
-      renameSync(target, file);
-      protectedPath = file;
-    }
-
-    // Keep the caller's spelling for the permission cache/runner.
-    // The opened descriptor and cleanup path remain in the canonical root.
-    tightenCreatedShadow(accessPath, fd, access);
     verifyRotationScope();
     if (parentIdentity && directoryIdentity(dir) !== parentIdentity) {
       retireRotationScope();
       throw coordinationError(new Error("shadow session directory identity changed"));
     }
+    // Confirm ACL/mode before any secret bytes are written to the staged file.
+    tightenCreatedShadow(target, fd, access);
     // Full replacement bytes are a conservative charge, even for overwrites,
     // partial writes and failed cleanup. Metadata/owner/stats are not capacity.
     if (shadowUsage && isPluginShadowName(basename(file))) {
       shadowUsage.bytes += typeof body === "string" ? Buffer.byteLength(body, "utf8") : body.byteLength;
     }
     write(fd, body);
+    fsyncSync(fd);
+
+    // The rotation/root lock provides the no-overwrite boundary for exclusive
+    // raw files. Refuse a file that appeared after admission; never replace it.
+    if (exclusive && existsSync(file)) {
+      const error = new Error("shadow file already exists");
+      error.code = "EEXIST";
+      throw error;
+    }
+    renameSync(target, file);
+    protectedPath = file;
+
+    // Keep the caller's spelling for the permission cache/runner. The opened
+    // descriptor and the final path now refer to the same published object.
+    tightenCreatedShadow(file, fd, access, { skipRunner: true });
 
     const opened = fd;
     fd = null;

package/thunder.js

@@ -34,7 +34,14 @@ function estimateTokens(text) {
 }
 
 export function buildSendLess({ taskLine, uncovered, facts, proseTokens = PROSE_TOKEN_CAP }) {
-  const kept = (facts || []).filter(Boolean);
+  const kept = (facts || []).filter(Boolean).map((fact) => {
+    if (typeof fact === "object" && fact !== null) {
+      const role = String(fact.role || "unknown");
+      const line = String(fact.line || "");
+      return line ? `[${role}] ${line}` : "";
+    }
+    return `[unknown] ${String(fact)}`;
+  }).filter(Boolean);
   let prose = uncovered || "";
   if (estimateTokens(prose) > proseTokens) {
     let low = 0;