foliko 2.0.30 → 2.0.32

package/src/agent/tool-loop.js

@@ -24,6 +24,20 @@ class ToolLoop extends EventEmitter {
     this.abortSignal = config.abortSignal || null;
     this._repairFn = config.repairToolCall || null;
     this._thinkingMode = config.thinkingMode === true;
+    // ★ 自愈开关：一旦服务端报"reasoning_content must be passed back"，
+    //   置 true 后本 loop 的所有请求都强制给每条 assistant 补 reasoning_content。
+    //   彻底兜底掉主/子 Agent、白名单漏判、跨轮持久化丢失等一切场景。
+    this._forceReasoning = false;
+  }
+
+  /**
+   * 判断是否是"thinking 模式必须回传 reasoning_content"这一类服务端 400。
+   * 兼容不同网关的措辞。
+   */
+  _isReasoningPassbackError(err) {
+    const msg = (err && (err.message || err.error?.message || '')) || '';
+    const s = String(msg).toLowerCase();
+    return s.includes('reasoning_content') && (s.includes('thinking') || s.includes('passed back') || s.includes('must be'));
   }
 
   _checkAbort() {
@@ -183,6 +197,20 @@ class ToolLoop extends EventEmitter {
     const api = [];
     if (systemPrompt) api.push({ role: 'system', content: systemPrompt });
 
+    // ★ 动态判定是否处于 thinking 模式。
+    //   isThinkingModel 是硬编码白名单，覆盖不到"服务端强制思考但模型名不在名单"的场景，
+    //   导致 this._thinkingMode=false → 不补 reasoning_content → 报
+    //   "reasoning_content in the thinking mode must be passed back"。
+    //   只要本批消息里任意一条 assistant 已带 reasoning（服务端回过），就认定思考已激活，
+    //   给缺失的 assistant 消息（压缩摘要、上一轮纯文本答复等）补占位 reasoning_content。
+    const msgHasReasoning = (m) => {
+      if (!m || m.role !== 'assistant') return false;
+      if (m.reasoning_content || m.reasoning) return true;
+      if (Array.isArray(m.content)) return m.content.some(c => c && c.type === 'reasoning' && c.text);
+      return false;
+    };
+    const thinkingActive = this._thinkingMode || this._forceReasoning || messages.some(msgHasReasoning);
+
     for (const msg of messages) {
       if (msg.role === 'system') {
         api.push({ role: 'system', content: typeof msg.content === 'string' ? msg.content : '' });
@@ -194,24 +222,18 @@ class ToolLoop extends EventEmitter {
           api.push({ role: 'user', content: text || '' });
         }
       } else if (msg.role === 'assistant') {
-        // ★ 检测是否有 reasoning 内容（thinking mode 必须携带）
-        const hasReasoningInContent = Array.isArray(msg.content) && msg.content.some(p => p && p.type === 'reasoning');
-        const hasReasoningTopLevel = msg.reasoning_content || msg.reasoning;
+        // ★ 提取 text + reasoning + tool_calls（兼容 content=string、content=array、顶层字段）
+        let text = '';
+        let reasoningText = '';
+        const toolCalls = [];
 
         if (typeof msg.content === 'string') {
-          if (msg.tool_calls && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
-            // thinking mode 下，无 reasoning 则自动补 placeholder
-            const reasonVal = hasReasoningTopLevel || (this._thinkingMode ? '...' : '');
-            api.push({ role: 'assistant', content: msg.content || null, tool_calls: msg.tool_calls, ...(reasonVal ? { reasoning_content: reasonVal } : {}) });
-          } else {
-            api.push({ role: 'assistant', content: msg.content });
-          }
+          text = msg.content;
         } else if (Array.isArray(msg.content)) {
-          let text = '';
-          const toolCalls = [];
           for (const part of msg.content) {
             if (!part) continue;
             if (part.type === 'text') text += part.text;
+            else if (part.type === 'reasoning') reasoningText += part.text || '';
             else if (part.type === 'tool-call' || part.type === 'tool-use') {
               toolCalls.push({
                 id: part.toolCallId,
@@ -223,15 +245,28 @@ class ToolLoop extends EventEmitter {
               });
             }
           }
+        }
+
+        // 顶层 reasoning_content / reasoning 兜底（content 数组里没提取到时）
+        if (!reasoningText) reasoningText = msg.reasoning_content || msg.reasoning || '';
 
-          if (toolCalls.length > 0) {
-            const reasonVal = hasReasoningTopLevel || (this._thinkingMode ? '...' : '');
-            api.push({ role: 'assistant', content: text || null, tool_calls: toolCalls, ...(reasonVal ? { reasoning_content: reasonVal } : {}) });
-          } else {
-            api.push({ role: 'assistant', content: text });
+        // ★ 合并顶层 tool_calls（OpenAI 格式，来自 session 文件）
+        const existingIds = new Set(toolCalls.map(tc => tc.id));
+        if (msg.tool_calls && Array.isArray(msg.tool_calls)) {
+          for (const tc of msg.tool_calls) {
+            if (!existingIds.has(tc.id)) toolCalls.push(tc);
+            existingIds.add(tc.id);
           }
+        }
+
+        // thinking 激活时，缺失 reasoning 一律补 '...' 占位，确保被服务端接受
+        const reasonVal = reasoningText || (thinkingActive ? '...' : '');
+        const reasonField = reasonVal ? { reasoning_content: reasonVal } : {};
+
+        if (toolCalls.length > 0) {
+          api.push({ role: 'assistant', content: text || null, tool_calls: toolCalls, ...reasonField });
         } else {
-          api.push({ role: 'assistant', content: String(msg.content ?? '') });
+          api.push({ role: 'assistant', content: text || '', ...reasonField });
         }
       } else if (msg.role === 'tool') {
         if (Array.isArray(msg.content)) {
@@ -432,6 +467,7 @@ class ToolLoop extends EventEmitter {
     let fullText = '';
     let fullReasoning = '';
     let totalUsage = null;
+    let finishedNaturally = false; // 是否自然结束（模型给出最终答复），用于区分 maxSteps 耗尽
 
     while (step < this.maxSteps) {
       this._checkAbort();
@@ -442,7 +478,7 @@ class ToolLoop extends EventEmitter {
       }
 
       // 2. 构建 API 请求
-      const apiMessages = this._buildApiMessages(messages, systemPrompt);
+      let apiMessages = this._buildApiMessages(messages, systemPrompt);
       const apiTools = this._buildApiTools(this.tools);
       const apiOptions = this._prepareApiOptions(options);
 
@@ -456,12 +492,22 @@ class ToolLoop extends EventEmitter {
           stream: false,
         });
       } catch (apiErr) {
-        log.error(`[ToolLoop] API call failed: ${apiErr.message}`);
-        const recent = apiMessages.slice(-3).map(m => ({
-          role: m.role, hasTc: !!(m.tool_calls?.length), hasReason: !!m.reasoning_content,
-        }));
-        log.error(`[ToolLoop] last msgs: ${JSON.stringify(recent)}`);
-        throw apiErr;
+        // ★ 自愈：服务端要求回传 reasoning_content → 置强制开关、重建消息、重试一次
+        if (!this._forceReasoning && this._isReasoningPassbackError(apiErr)) {
+          this._forceReasoning = true;
+          log.warn('[ToolLoop] reasoning_content required by server → force-inject & retry');
+          apiMessages = this._buildApiMessages(messages, systemPrompt);
+          response = await client.chat.completions.create({
+            model, messages: apiMessages, tools: apiTools, ...apiOptions, stream: false,
+          });
+        } else {
+          log.error(`[ToolLoop] API call failed: ${apiErr.message}`);
+          const recent = apiMessages.slice(-3).map(m => ({
+            role: m.role, hasTc: !!(m.tool_calls?.length), hasReason: !!m.reasoning_content,
+          }));
+          log.error(`[ToolLoop] last msgs: ${JSON.stringify(recent)}`);
+          throw apiErr;
+        }
       }
 
       // 3. 解析响应
@@ -482,7 +528,10 @@ class ToolLoop extends EventEmitter {
       if (reasoningContent) fullReasoning += reasoningContent;
 
       // 4. 处理工具调用
-      if (choice.finish_reason === 'tool_calls' && message.tool_calls && message.tool_calls.length > 0) {
+      // ★ 只要模型产出了 tool_calls 就执行，不依赖 finish_reason === 'tool_calls'。
+      //   部分 OpenAI 兼容 / reasoning 供应商即使有 tool_calls 也会返回
+      //   finish_reason: 'stop'，若严格判断会把工具调用丢弃 → 循环提前退出、任务未完成。
+      if (message.tool_calls && message.tool_calls.length > 0) {
         // 插入 assistant 消息（保留原格式，后面的 _processMessage 会存盘）
         const assistantMsg = {
           role: 'assistant',
@@ -505,6 +554,14 @@ class ToolLoop extends EventEmitter {
       } else {
         // 没有工具调用 → 完成
         fullText = message.content || '';
+        // ★ 把最终回复也写进 messages，否则持久化历史缺失助手每轮答复、
+        //   下一轮模型看不到自己上次说了什么（多轮记忆丢失）。
+        if (fullText || reasoningContent) {
+          const finalMsg = { role: 'assistant', content: fullText };
+          if (reasoningContent) finalMsg.reasoning_content = reasoningContent;
+          messages.push(finalMsg);
+        }
+        finishedNaturally = true;
         break;
       }
     }
@@ -515,6 +572,9 @@ class ToolLoop extends EventEmitter {
       steps: step,
       usage: totalUsage,
       reasoningText: fullReasoning || undefined,
+      // ★ 区分正常完成与 maxSteps 耗尽：耗尽时最后一步是工具调用、无最终答复，
+      //   调用方（SubAgent 等）不应把它当成功。
+      stopReason: finishedNaturally ? 'stop' : 'max_steps',
     };
   }
 
@@ -529,6 +589,7 @@ class ToolLoop extends EventEmitter {
     let fullText = '';
     let fullReasoning = '';
     let totalUsage = null;
+    let finishedNaturally = false;
 
     while (step < this.maxSteps) {
       this._checkAbort();
@@ -539,7 +600,7 @@ class ToolLoop extends EventEmitter {
       }
 
       // 2. 构建请求
-      const apiMessages = this._buildApiMessages(messages, systemPrompt);
+      let apiMessages = this._buildApiMessages(messages, systemPrompt);
       const apiTools = this._buildApiTools(this.tools);
       const apiOptions = this._prepareApiOptions(options);
 
@@ -554,13 +615,24 @@ class ToolLoop extends EventEmitter {
           stream_options: { include_usage: true },
         });
       } catch (apiErr) {
-        log.error(`[ToolLoop] stream call failed: ${apiErr.message}`);
-        log.error(`[ToolLoop] model=${model} msgs=${apiMessages.length}`);
-        const recent = apiMessages.slice(-3).map(m => ({
-          role: m.role, hasTc: !!(m.tool_calls?.length), hasReason: !!m.reasoning_content,
-        }));
-        log.error(`[ToolLoop] last msgs: ${JSON.stringify(recent)}`);
-        throw apiErr;
+        // ★ 自愈：服务端要求回传 reasoning_content → 置强制开关、重建消息、重试一次
+        if (!this._forceReasoning && this._isReasoningPassbackError(apiErr)) {
+          this._forceReasoning = true;
+          log.warn('[ToolLoop] reasoning_content required by server → force-inject & retry (stream)');
+          apiMessages = this._buildApiMessages(messages, systemPrompt);
+          stream = await client.chat.completions.create({
+            model, messages: apiMessages, tools: apiTools, ...apiOptions,
+            stream: true, stream_options: { include_usage: true },
+          });
+        } else {
+          log.error(`[ToolLoop] stream call failed: ${apiErr.message}`);
+          log.error(`[ToolLoop] model=${model} msgs=${apiMessages.length}`);
+          const recent = apiMessages.slice(-3).map(m => ({
+            role: m.role, hasTc: !!(m.tool_calls?.length), hasReason: !!m.reasoning_content,
+          }));
+          log.error(`[ToolLoop] last msgs: ${JSON.stringify(recent)}`);
+          throw apiErr;
+        }
       }
 
       // 3. 处理流式响应（累计 tool_calls delta）
@@ -584,8 +656,14 @@ class ToolLoop extends EventEmitter {
         }
 
         // Reasoning content
+        // ★ 与 text-delta 对称：用 fullReasoning 作为"已发射长度"游标，只发新增部分。
+        //   否则每个 chunk 都 slice(旧游标) → 把本 step 从头到现在的 reasoning 重复发出。
         if (result.hasReasoning) {
-          yield { type: 'thinking', text: state.fullReasoning.slice(fullReasoning.length) };
+          const delta = state.fullReasoning.slice(fullReasoning.length);
+          if (delta) {
+            fullReasoning += delta;
+            yield { type: 'thinking', text: delta };
+          }
         }
 
         // Text delta
@@ -605,9 +683,12 @@ class ToolLoop extends EventEmitter {
       totalUsage = state.totalUsage;
       fullReasoning = state.fullReasoning;
 
-      const toolCalls = Object.values(toolCallAccum).filter(tc => tc.id);
+      const toolCalls = Object.values(toolCallAccum).filter(tc => tc.id && tc.function?.name);
 
-      if (finishReason === 'tool_calls' && toolCalls.length > 0) {
+      // ★ 只要累积到有效 tool_calls 就执行，不依赖 finishReason === 'tool_calls'。
+      //   部分供应商（尤其内联 <think> 的 reasoning 模型）即使调用工具也返回
+      //   finish_reason: 'stop'，严格判断会丢弃工具调用 → 提前退出、任务未完成。
+      if (toolCalls.length > 0) {
         // 插入 assistant 消息（含 tool_calls）
         const assistantMsg = { role: 'assistant', content: fullText || '', tool_calls: toolCalls };
         // ★ 保存 reasoning_content（下次 API 调用时需要传回）
@@ -624,6 +705,14 @@ class ToolLoop extends EventEmitter {
       } else {
         // 无工具调用 → 完成（与 generate() 保持一致：确保 fullText 有值）
         fullText = state.fullText || fullText;
+        // ★ 把最终回复也写进 messages，否则持久化历史缺失助手每轮答复、
+        //   下一轮模型看不到自己上次说了什么（多轮记忆丢失）。
+        if (fullText || fullReasoning) {
+          const finalMsg = { role: 'assistant', content: fullText };
+          if (fullReasoning) finalMsg.reasoning_content = fullReasoning;
+          messages.push(finalMsg);
+        }
+        finishedNaturally = true;
         break;
       }
     }
@@ -635,12 +724,18 @@ class ToolLoop extends EventEmitter {
       outputTokens: totalUsage?.completionTokens || 0,
     };
 
+    // ★ maxSteps 耗尽时提示调用方（区分正常完成）
+    if (!finishedNaturally) {
+      yield { type: 'max-steps', steps: step };
+    }
+
     return {
       text: fullText,
       response: { messages },
       steps: step,
       usage: totalUsage,
       reasoningText: fullReasoning || undefined,
+      stopReason: finishedNaturally ? 'stop' : 'max_steps',
     };
   }
 }

package/src/common/atomic-write.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const fs = require('fs');
+
+/**
+ * 原子写文件：写 tmp → fsync → rename。
+ *
+ * 直接 fs.writeFileSync 会先把目标文件截断再写；进程被杀 / 断电落在中途时，
+ * 磁盘上会留下被截断的半文件（甚至 0 字节），加载时按行解析要么整段丢、
+ * 要么把坏行静默跳过 → 静默丢数据。
+ *
+ * rename 在同一文件系统上是原子的：崩溃时要么看到旧文件、要么看到完整新文件，
+ * 不会出现半截。fsync 进一步保证内容真正落盘（防 rename 先于数据落盘的重排）。
+ *
+ * @param {string} filePath 目标路径
+ * @param {string|Buffer} content 完整内容
+ */
+function atomicWriteFileSync(filePath, content) {
+  const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  let fd;
+  try {
+    fd = fs.openSync(tmp, 'w');
+    fs.writeFileSync(fd, content);
+    try { fs.fsyncSync(fd); } catch { /* 某些文件系统/平台不支持 fsync，忽略 */ }
+  } finally {
+    if (fd !== undefined) {
+      try { fs.closeSync(fd); } catch { /* ignore */ }
+    }
+  }
+  fs.renameSync(tmp, filePath);
+}
+
+module.exports = { atomicWriteFileSync };

package/src/context/compressor.js

@@ -194,9 +194,10 @@ class ContextCompressor {
     this._compactionSettings = config.compactionSettings || DEFAULT_COMPACTION_SETTINGS;
 
     this._compressionCount = 0;
-    this._compressionInProgress = false;
-    this._compressionPromise = null;
-    this._compressionTimeoutId = null;
+    // ★ 按 sessionId 隔离在途压缩：旧实现用单个全局 promise/flag，
+    //   session B 在 A 压缩进行中调用会拿到 A 的 promise、对着 A 的 messages → 串味。
+    this._compressionPromises = new Map(); // sessionId -> 在途 promise
+    this._compressionTimeouts = new Map(); // sessionId -> setTimeout 句柄
     this._maxToolResultSize = config.maxToolResultSize || 4000;
     this._tokenCounter = new TokenCounter();
   }
@@ -213,20 +214,22 @@ class ContextCompressor {
   }
 
   async compress(sessionId, messages, messageStore) {
-    if (this._compressionInProgress && this._compressionPromise) {
-      logger.debug('Compression already in progress, waiting...');
-      return this._compressionPromise;
+    // 同一 session 的并发压缩复用同一 promise；不同 session 互不干扰。
+    const existing = this._compressionPromises.get(sessionId);
+    if (existing) {
+      logger.debug(`Compression already in progress for ${sessionId}, waiting...`);
+      return existing;
     }
 
     if (messages.length <= this._keepRecentMessages) return;
 
-    this._compressionInProgress = true;
-    this._compressionPromise = this._executeWithTimeout(sessionId, messages, messageStore).finally(() => {
-      this._compressionInProgress = false;
-      this._compressionPromise = null;
-      if (this._compressionTimeoutId) { clearTimeout(this._compressionTimeoutId); this._compressionTimeoutId = null; }
+    const p = this._executeWithTimeout(sessionId, messages, messageStore).finally(() => {
+      this._compressionPromises.delete(sessionId);
+      const t = this._compressionTimeouts.get(sessionId);
+      if (t) { clearTimeout(t); this._compressionTimeouts.delete(sessionId); }
     });
-    return this._compressionPromise;
+    this._compressionPromises.set(sessionId, p);
+    return p;
   }
 
   async _executeWithTimeout(sessionId, messages, messageStore) {
@@ -234,10 +237,11 @@ class ContextCompressor {
       return await Promise.race([
         this._doCompress(sessionId, messages, messageStore),
         new Promise((_, reject) => {
-          this._compressionTimeoutId = setTimeout(() => {
-            this._compressionTimeoutId = null;
+          const tid = setTimeout(() => {
+            this._compressionTimeouts.delete(sessionId);
             reject(new Error(`Compression timeout (${COMPRESSION_TIMEOUT_MS}ms)`));
           }, COMPRESSION_TIMEOUT_MS);
+          this._compressionTimeouts.set(sessionId, tid);
         }),
       ]);
     } catch (err) {
@@ -247,9 +251,9 @@ class ContextCompressor {
   }
 
   cancelCompression() {
-    if (this._compressionTimeoutId) { clearTimeout(this._compressionTimeoutId); this._compressionTimeoutId = null; }
-    this._compressionInProgress = false;
-    this._compressionPromise = null;
+    for (const t of this._compressionTimeouts.values()) clearTimeout(t);
+    this._compressionTimeouts.clear();
+    this._compressionPromises.clear();
   }
 
   async _doCompress(sessionId, messages, messageStore) {
@@ -390,7 +394,7 @@ class ContextCompressor {
   }
 
   getStats() {
-    return { compressionCount: this._compressionCount, inProgress: this._compressionInProgress };
+    return { compressionCount: this._compressionCount, inProgress: this._compressionPromises.size > 0 };
   }
 }
 

package/src/framework/framework.js

@@ -1076,7 +1076,25 @@ class Framework extends EventEmitter {
     }
     if (!manager) {
       const { SessionManager } = require('../session/session');
-      manager = new SessionManager(cwd, sessionDir, sessionFile, true);
+      const fs = require('fs');
+      try {
+        manager = new SessionManager(cwd, sessionDir, sessionFile, true);
+      } catch (err) {
+        // ★ 恢复分支同样可能因坏文件在构造时(_loadEntriesFromFile)抛错。
+        //   之前这里不在 try 内 → 直接崩。改为：隔离坏文件后重新新建，最后兜底内存 session。
+        this.logger.warn(`[Framework] Session '${sessionId}' file unreadable (${err.message}); quarantining and starting fresh`);
+        try {
+          if (fs.existsSync(sessionFile)) fs.renameSync(sessionFile, `${sessionFile}.corrupt-${Date.now()}`);
+        } catch (e) {
+          this.logger.warn(`[Framework] quarantine failed: ${e.message}`);
+        }
+        try {
+          manager = new SessionManager(cwd, sessionDir, sessionFile, true);
+        } catch (e2) {
+          this.logger.warn(`[Framework] fresh session create failed: ${e2.message}; using in-memory`);
+          manager = SessionManager.inMemory(cwd);
+        }
+      }
     }
     this._sessionContexts.set(sessionId, manager);
     this.touchSession(sessionId);

package/src/plugin/manager.js

@@ -594,8 +594,18 @@ class PluginManager {
     try {
       const stateFile = this._getStateFile();
       if (fs.existsSync(stateFile)) {
-        this._stateCache = safeJsonParse(fs.readFileSync(stateFile, 'utf-8'), {});
-        return this._stateCache;
+        const raw = fs.readFileSync(stateFile, 'utf-8');
+        if (raw.trim() === '') { this._stateCache = {}; return this._stateCache; }
+        try {
+          this._stateCache = JSON.parse(raw);
+          return this._stateCache;
+        } catch (parseErr) {
+          // ★ 坏文件不能静默当空对象 → 否则下次 _saveState 覆盖它、
+          //   插件启停/配置全丢。先隔离坏文件保留现场，再以默认值启动。
+          this._log.error(`Plugin state file corrupt (${parseErr.message}); quarantining`);
+          try { fs.renameSync(stateFile, `${stateFile}.corrupt-${Date.now()}`); }
+          catch (e) { this._log.error('quarantine state file failed:', e.message); }
+        }
       }
     } catch (err) {
       this._log.error('Failed to load state:', err.message);

package/src/session/session.js

@@ -7,6 +7,7 @@
 const fs = require('fs');
 const path = require('path');
 const { JsonlSessionStorage } = require('../storage/jsonl');
+const { atomicWriteFileSync } = require('../common/atomic-write');
 const {
   EntryTypes,
   generateEntryId,
@@ -202,9 +203,9 @@ class SessionManager {
 
   _rewriteFile() {
     if (!this.persist || !this.sessionFile) return;
-    // 性能优化：单次写入代替多次追加
+    // 性能优化：单次写入代替多次追加。原子写避免崩溃时留下半截文件。
     const content = this.fileEntries.map(e => JSON.stringify(e)).join('\n') + '\n';
-    fs.writeFileSync(this.sessionFile, content);
+    atomicWriteFileSync(this.sessionFile, content);
   }
 
   _persist(entry) {
@@ -221,7 +222,7 @@ class SessionManager {
     // 性能优化：使用批量写入代替多次追加
     if (!this.flushed) {
       const batch = this.fileEntries.map(e => `${JSON.stringify(e)}\n`).join('');
-      fs.writeFileSync(this.sessionFile, batch);
+      atomicWriteFileSync(this.sessionFile, batch);
       this.flushed = true;
     } else {
       fs.appendFileSync(this.sessionFile, `${JSON.stringify(entry)}\n`);
@@ -440,7 +441,11 @@ class SessionManager {
    * Build the session context (what gets sent to the LLM)
    */
   buildSessionContext() {
-    return buildSessionContext(this.getEntries(), this.leafId, this.byId);
+    // ★ 走活跃分支（leafId 到根的路径），而不是把所有分支的 entries 拍平。
+    //   否则被丢弃分支的消息会混进上下文，compaction/model 也可能取到废弃分支的值。
+    //   entry.js 的 buildSessionContext 只接收单个数组参数，之前多传的 leafId/byId 被静默忽略。
+    const pathEntries = this.leafId ? this.getBranch(this.leafId) : this.getEntries();
+    return buildSessionContext(pathEntries);
   }
 
   /**

package/src/storage/manager.js

@@ -6,6 +6,7 @@
 const fs = require('fs');
 const path = require('path');
 const { generateEntryId } = require('../common/id');
+const { atomicWriteFileSync } = require('../common/atomic-write');
 
 class StorageEntry {
   constructor(key, value, timestamp) {
@@ -94,7 +95,8 @@ class StorageManager {
   _rewrite() {
     if (!this.persist || !this.filePath) return;
     const lines = this.allEntries.map(e => JSON.stringify(e)).join('\n') + '\n';
-    fs.writeFileSync(this.filePath, lines);
+    // 原子写：compaction 全量重写时崩溃不会留下半截文件（否则内存已"压缩"、磁盘却残缺）。
+    atomicWriteFileSync(this.filePath, lines);
   }
 
   /**