From e5882a3ccd758f263325dbf7e296da37a22111c8 Mon Sep 17 00:00:00 2001
From: EdgeMLHacker <126883848+Apageoflove@users.noreply.github.com>
Date: Fri, 6 Nov 2026 08:44:56 +0800
Subject: [PATCH] =?UTF-8?q?fix(minimax-bot):=20=E5=9D=8F=E6=96=87=E4=BB=B6?=
 =?UTF-8?q?=E4=B8=8D=E5=86=8D=E8=AE=A9=E6=8F=92=E4=BB=B6=E8=B5=B7=E4=B8=8D?=
 =?UTF-8?q?=E6=9D=A5=EF=BC=8C=E8=B4=A6=E6=9C=AC=E5=86=99=E5=A4=B1=E8=B4=A5?=
 =?UTF-8?q?=E4=B8=8D=E5=86=8D=E5=B8=A6=E8=B5=B0=E5=B7=B2=E7=BB=8F=E8=B7=91?=
 =?UTF-8?q?=E5=AE=8C=E7=9A=84=E5=9B=9E=E5=90=88?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

读不出来的状态文件改成改名留证、从默认值起，写盘在 rename 之前先 fsync；台账写
不进去时只记一条 warn，不再把已经跑完的回合、群里后面的成员和跑完的后台报告一
并带走。版本 0.7.24。
---
 .../minimax-bot/.minimax-plugin/plugin.json   |   2 +-
 plugins/minimax-ai/minimax-bot/README.md      |   5 +
 .../minimax-bot/miniapp/node/engine.mjs       |  73 +++++-----
 .../minimax-bot/miniapp/node/mcp.mjs          |   2 +-
 .../minimax-bot/miniapp/node/server.mjs       |   3 +-
 .../minimax-bot/miniapp/node/store.mjs        |  51 ++++++-
 plugins/minimax-ai/minimax-bot/package.json   |   2 +-
 .../tests/ledger-write-failure.test.mjs       | 127 ++++++++++++++++++
 .../tests/store-corrupt-recovery.test.mjs     |  56 ++++++++
 .../minimax-bot/tests/unknown-zombie.test.mjs |   5 +
 10 files changed, 284 insertions(+), 42 deletions(-)
 create mode 100644 plugins/minimax-ai/minimax-bot/tests/ledger-write-failure.test.mjs
 create mode 100644 plugins/minimax-ai/minimax-bot/tests/store-corrupt-recovery.test.mjs

diff --git a/plugins/minimax-ai/minimax-bot/.minimax-plugin/plugin.json b/plugins/minimax-ai/minimax-bot/.minimax-plugin/plugin.json
index a5927be..28e60b4 100644
--- a/plugins/minimax-ai/minimax-bot/.minimax-plugin/plugin.json
+++ b/plugins/minimax-ai/minimax-bot/.minimax-plugin/plugin.json
@@ -2,7 +2,7 @@
   "schemaVersion": 1,
   "name": "minimax-bot",
   "displayName": "MiniMax Bot",
-  "version": "0.7.21",
+  "version": "0.7.24",
   "description": "Turn MiniMax Code into an always-on team of Bots. A Chief Bot helps you build the team; in group chats the admin answers and @mentions hand work to other members. Every Bot has its own octopus avatar and memory, with scheduled tasks and usage stats.",
   "author": "MiniMax Code",
   "icon": "icon.png",
diff --git a/plugins/minimax-ai/minimax-bot/README.md b/plugins/minimax-ai/minimax-bot/README.md
index ef2d94d..0cd26a7 100644
--- a/plugins/minimax-ai/minimax-bot/README.md
+++ b/plugins/minimax-ai/minimax-bot/README.md
@@ -76,6 +76,11 @@ A shutdown no longer throws away work that never started. Such a task stays queu
 
 The usage ledger counts the time the model really ran. A retried turn waits between the attempts, and that wait was counted as the model's time: a turn that waited half a minute between two attempts was written down as a turn of half a minute, and the panel averaged that up. The duration is now the time the model ran and the panel's average follows it; the wait between the attempts is kept beside it in the ledger (`usage.jsonl`), not inside the duration. A turn the model never ran has no duration to report, so it is left out of the average instead of counting as zero seconds.
 
+## 0.7.24 A file that cannot be read, and a ledger that cannot be written
+
+- A `state.json` or a chat file that cannot be parsed no longer keeps the Mini App from starting. The unreadable file is kept as `*.corrupt-<time>` instead of being thrown away, and the store starts from the defaults: an unreadable chat starts empty, the other chats still load. The file was written with a rename, but nothing was flushed before it, so a power loss could leave an empty file behind; the bytes are flushed before the rename now, and the directory after it where the platform allows it.
+- A failed ledger write no longer fails the turn that already ran. The reply keeps its outcome, a group round goes on to the next member, and a finished background job still saves its status and delivers its report. The miss goes to the log.
+
 ## 0.7.10 Optional group notes
 
 - A group can keep a note of what it said. After every round the group records the closing lines of the replies, and every Bot of the group gets that record in its standing brief.
diff --git a/plugins/minimax-ai/minimax-bot/miniapp/node/engine.mjs b/plugins/minimax-ai/minimax-bot/miniapp/node/engine.mjs
index 6607583..d4f8f82 100644
--- a/plugins/minimax-ai/minimax-bot/miniapp/node/engine.mjs
+++ b/plugins/minimax-ai/minimax-bot/miniapp/node/engine.mjs
@@ -875,22 +875,28 @@ export class Engine {
       }
     } finally {
       // The model ran: the ledger must say so even when a later step of this turn fails.
-      await this.store.recordUsage({
-        ts: Date.now(),
-        turnId: message.id,
-        botId: bot.id,
-        botName: bot.name,
-        chatId,
-        kind: input.kind,
-        status,
-        durationMs: message.durationMs,
-        chars: finalText.length,
-        tools,
-        // One turn, but the model may have been called more than once to finish it.
-        attempts: modelCalls,
-        // The wait between two attempts is recorded on its own: it is not the model's time.
-        sleptMs,
-      });
+      // The ledger is metering, not the turn's outcome: a failed write (a full disk) must
+      // not take the turn that already ran down with it. The miss goes to the log.
+      try {
+        await this.store.recordUsage({
+          ts: Date.now(),
+          turnId: message.id,
+          botId: bot.id,
+          botName: bot.name,
+          chatId,
+          kind: input.kind,
+          status,
+          durationMs: message.durationMs,
+          chars: finalText.length,
+          tools,
+          // One turn, but the model may have been called more than once to finish it.
+          attempts: modelCalls,
+          // The wait between two attempts is recorded on its own: it is not the model's time.
+          sleptMs,
+        });
+      } catch (error) {
+        this.logger.warn('minimax_bot.usage_write_failed', { chatId, code: error?.code ?? 'unknown' });
+      }
       this.broadcast({ type: 'usage.changed' });
     }
     this.broadcast({ type: 'message.upsert', chatId, message });
@@ -1909,21 +1915,26 @@ export class Engine {
     if (report) helper.report = report;
     if (turnStartedAt) {
       // A background job is an Agent turn like any other: meter it here, or the usage panel
-      // counts fewer turns than the model actually ran.
-      await this.store.recordUsage({
-        ts: Date.now(),
-        turnId: helper.id,
-        botId: helper.botId,
-        botName: turnBotName,
-        chatId: helper.chatId,
-        kind: 'helper-run',
-        status: helperTurnStatus(helper.status),
-        durationMs: turnMs,
-        chars: turnText.length,
-        tools: turnTools,
-        // A background job runs the model once; it has no retry loop of its own.
-        attempts: 1,
-      });
+      // counts fewer turns than the model actually ran. A failed write must not keep the
+      // finished job from saving its status and delivering its report.
+      try {
+        await this.store.recordUsage({
+          ts: Date.now(),
+          turnId: helper.id,
+          botId: helper.botId,
+          botName: turnBotName,
+          chatId: helper.chatId,
+          kind: 'helper-run',
+          status: helperTurnStatus(helper.status),
+          durationMs: turnMs,
+          chars: turnText.length,
+          tools: turnTools,
+          // A background job runs the model once; it has no retry loop of its own.
+          attempts: 1,
+        });
+      } catch (error) {
+        this.logger.warn('minimax_bot.usage_write_failed', { chatId: helper.chatId, code: error?.code ?? 'unknown' });
+      }
       this.broadcast({ type: 'usage.changed' });
     }
     if (this.disposed) return;
diff --git a/plugins/minimax-ai/minimax-bot/miniapp/node/mcp.mjs b/plugins/minimax-ai/minimax-bot/miniapp/node/mcp.mjs
index 7a47310..95087f5 100644
--- a/plugins/minimax-ai/minimax-bot/miniapp/node/mcp.mjs
+++ b/plugins/minimax-ai/minimax-bot/miniapp/node/mcp.mjs
@@ -662,7 +662,7 @@ export function createMcpHandler({ team, engine }) {
           result = {
             protocolVersion: PROTOCOL_VERSIONS.includes(requested) ? requested : PROTOCOL_VERSIONS[0],
             capabilities: { tools: { listChanged: false } },
-            serverInfo: { name: 'minimax-bot', version: '0.7.21' },
+            serverInfo: { name: 'minimax-bot', version: '0.7.24' },
             instructions: t('mcp.instructions'),
           };
           break;
diff --git a/plugins/minimax-ai/minimax-bot/miniapp/node/server.mjs b/plugins/minimax-ai/minimax-bot/miniapp/node/server.mjs
index 4f7f13e..4ec12d1 100644
--- a/plugins/minimax-ai/minimax-bot/miniapp/node/server.mjs
+++ b/plugins/minimax-ai/minimax-bot/miniapp/node/server.mjs
@@ -114,7 +114,8 @@ function chatReferences(messages, src) {
  */
 export async function start(context) {
   const clientDir = join(context.pluginRoot, 'miniapp/client');
-  const store = new Store(context.dataDir);
+  // The store writes the ledger; when that write fails it says so through the host's log.
+  const store = new Store(context.dataDir, context.logger);
   const memory = new MemoryStore(context.dataDir);
   await store.init();
   await memory.init();
diff --git a/plugins/minimax-ai/minimax-bot/miniapp/node/store.mjs b/plugins/minimax-ai/minimax-bot/miniapp/node/store.mjs
index ce5017a..538a978 100644
--- a/plugins/minimax-ai/minimax-bot/miniapp/node/store.mjs
+++ b/plugins/minimax-ai/minimax-bot/miniapp/node/store.mjs
@@ -1,7 +1,7 @@
 // @ts-check
 import { randomUUID } from 'node:crypto';
-import { appendFile, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { appendFile, mkdir, open, readFile, rename, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
 import { userReaction } from '../client/emoji-data.js';
 
 import { resolveLocale, setLocale, t } from './i18n.mjs';
@@ -120,8 +120,18 @@ export function newId(prefix) {
 async function writeJsonAtomic(path, value) {
   const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
   try {
-    await writeFile(tmp, JSON.stringify(value, null, 2), 'utf8');
+    // Flush the bytes before the rename: a power loss after an unflushed rename is what
+    // leaves a 0-byte file behind.
+    const handle = await open(tmp, 'w');
+    try {
+      await handle.writeFile(JSON.stringify(value, null, 2), 'utf8');
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
     await rename(tmp, path);
+    // Best effort: some platforms (Windows) cannot sync a directory handle.
+    await open(dirname(path), 'r').then((dir) => dir.sync().finally(() => dir.close())).catch(() => {});
   } catch (error) {
     await rm(tmp, { force: true }).catch(() => {});
     throw error;
@@ -129,14 +139,22 @@ async function writeJsonAtomic(path, value) {
 }
 
 async function readJson(path, fallback) {
+  let text;
   try {
-    return JSON.parse(await readFile(path, 'utf8'));
+    text = await readFile(path, 'utf8');
   } catch (error) {
     if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
       return fallback;
     }
     throw error;
   }
+  try {
+    return JSON.parse(text);
+  } catch {
+    // Keep the unreadable bytes as evidence instead of deleting them; start from defaults.
+    await rename(path, `${path}.corrupt-${Date.now()}`).catch(() => {});
+    return fallback;
+  }
 }
 
 function defaultState() {
@@ -213,9 +231,11 @@ function knownText(message) {
 }
 
 export class Store {
-  /** @param {string} dataDir */
-  constructor(dataDir) {
+  /** @param {string} dataDir @param {{ warn: (...args: any[]) => void }} [logger] */
+  constructor(dataDir, logger) {
     this.dir = dataDir;
+    /** The ledger must be able to say it lost a row; without a host logger it stays quiet. */
+    this.logger = logger ?? { warn() {} };
     this.statePath = join(dataDir, 'state.json');
     this.messagesDir = join(dataDir, 'messages');
     this.usagePath = join(dataDir, 'usage.jsonl');
@@ -240,6 +260,16 @@ export class Store {
     this.state.settings = { ...defaultState().settings, ...(this.state.settings ?? {}) };
     setLocale(resolveLocale(this.state));
     let migrated = false;
+    // The fields init walks must have the shape it walks: a wrong shape starts from defaults
+    // rather than throwing half way through startup.
+    for (const key of ['bots', 'groups', 'schedules']) {
+      if (!Array.isArray(this.state[key])) { this.state[key] = []; migrated = true; }
+    }
+    const sessions = this.state.sessions;
+    if (!sessions || typeof sessions !== 'object' || Array.isArray(sessions)) {
+      this.state.sessions = {};
+      migrated = true;
+    }
     // A helper's Agent run does not survive the Mini App process; one left running was cut off.
     this.state.helpers = Array.isArray(this.state.helpers) ? this.state.helpers : [];
     for (const helper of this.state.helpers) {
@@ -620,7 +650,14 @@ export class Store {
   // ---------- usage ----------
   recordUsage(entry) {
     return this.enqueue(async () => {
-      await appendFile(this.usagePath, `${JSON.stringify(entry)}\n`, 'utf8');
+      // The ledger is metering: a failed append (a full disk) must not fail the caller's turn,
+      // but the miss goes to the log. The id is added only on success, so a retry can still write.
+      try {
+        await appendFile(this.usagePath, `${JSON.stringify(entry)}\n`, 'utf8');
+      } catch (error) {
+        this.logger.warn('minimax_bot.usage_write_failed', { code: error?.code ?? 'unknown' });
+        return;
+      }
       if (entry.turnId) this.usageIds.add(entry.turnId);
     });
   }
diff --git a/plugins/minimax-ai/minimax-bot/package.json b/plugins/minimax-ai/minimax-bot/package.json
index af689e4..57df2a6 100644
--- a/plugins/minimax-ai/minimax-bot/package.json
+++ b/plugins/minimax-ai/minimax-bot/package.json
@@ -1,6 +1,6 @@
 {
   "name": "minimax-bot",
-  "version": "0.7.21",
+  "version": "0.7.24",
   "private": true,
   "type": "module",
   "mcode": {
diff --git a/plugins/minimax-ai/minimax-bot/tests/ledger-write-failure.test.mjs b/plugins/minimax-ai/minimax-bot/tests/ledger-write-failure.test.mjs
new file mode 100644
index 0000000..a7663ce
--- /dev/null
+++ b/plugins/minimax-ai/minimax-bot/tests/ledger-write-failure.test.mjs
@@ -0,0 +1,127 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { mkdtemp, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { Store } from '../miniapp/node/store.mjs';
+import { MemoryStore } from '../miniapp/node/memory.mjs';
+import { Engine } from '../miniapp/node/engine.mjs';
+import { setLocale } from '../miniapp/node/i18n.mjs';
+
+// The ledger is metering, not the turn's outcome: a failed write (a full disk) must not fail a
+// turn that already ran, stop a group round, or keep a finished background job from reporting.
+
+async function until(predicate) {
+  for (let i = 0; i < 400; i += 1) {
+    if (await predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, 5));
+  }
+  throw new Error('The expected state did not arrive');
+}
+
+async function fixture(t, { stub = true } = {}) {
+  const dir = await mkdtemp(join(tmpdir(), 'bot-ledger-failure-'));
+  const warnings = [];
+  const logger = { warn: (...args) => warnings.push(args), info() {}, error() {} };
+  const store = new Store(dir, logger);
+  const memory = new MemoryStore(dir);
+  await store.init();
+  await memory.init();
+  setLocale('en');
+  const engine = new Engine({ store, memory, logger, broadcast() {}, retryDelaysMs: [] });
+  t.after(async () => {
+    engine.dispose();
+    await until(() => engine.running.size === 0 && engine.helperRuns.size === 0 && engine.tickets.size === 0);
+    await store.writeChain;
+    await rm(dir, { recursive: true, force: true });
+  });
+  if (stub) {
+    // The whole ledger write fails, exactly like a full disk; the guard must live at the call site.
+    store.recordUsage = async () => { throw Object.assign(new Error('ENOSPC'), { code: 'ENOSPC' }); };
+  }
+  return { dir, store, engine, warnings };
+}
+
+const loggedMiss = (warnings) => warnings.some(([event]) => event === 'minimax_bot.usage_write_failed');
+
+test('a full ledger does not fail the turn that already ran', async (t) => {
+  const { store, engine, warnings } = await fixture(t);
+  const bot = { id: 'bot_a', name: 'Alice', role: 'Writer' };
+  store.state.bots = [bot];
+  engine.agent = { async run(input, options) {
+    const ids = { sessionId: 's-ledger', turnId: 't-ledger' };
+    options.onEvent({ type: 'turn.started', ...ids });
+    return { ...ids, status: 'finished', text: 'All done' };
+  } };
+  const result = await engine.runBotTurn({ bot, chatId: `bot:${bot.id}`, text: 'hi', kind: 'private' });
+  assert.equal(result.status, 'done', 'the reply keeps its outcome');
+  const messages = await store.getMessages(`bot:${bot.id}`);
+  assert.equal(messages.find((m) => m.id === result.messageId)?.status, 'done');
+  assert.ok(loggedMiss(warnings), 'the miss goes to the log');
+});
+
+test('a full ledger does not stop the group round before the next member', async (t) => {
+  const { store, engine, warnings } = await fixture(t);
+  const a = { id: 'bot_a', name: 'Alice', role: 'Writer' };
+  const b = { id: 'bot_b', name: 'Bob', role: 'Reviewer' };
+  const group = { id: 'grp_round', name: 'Round', adminId: a.id, memberIds: [a.id, b.id], replyMode: 'all' };
+  store.state.bots = [a, b];
+  store.state.groups = [group];
+  const calls = [];
+  engine.agent = { async run(input, options) {
+    calls.push(input.text);
+    const ids = { sessionId: `s-${calls.length}`, turnId: `t-${calls.length}` };
+    options.onEvent({ type: 'turn.started', ...ids });
+    return { ...ids, status: 'finished', text: `Reply ${calls.length}` };
+  } };
+  await engine.driveGroup(group, engine.groupQueue(group, 'hi'));
+  assert.equal(calls.length, 2, 'the round continues with the next member');
+  assert.ok(loggedMiss(warnings), 'the miss goes to the log');
+});
+
+test('a full ledger does not keep a finished background job from saving and reporting', async (t) => {
+  const { dir, store, engine, warnings } = await fixture(t);
+  const bot = { id: 'bot_a', name: 'Alice', role: 'Writer' };
+  store.state.bots = [bot];
+  const chatId = `bot:${bot.id}`;
+  const calls = [];
+  engine.agent = { async run(input, options) {
+    calls.push(input.text);
+    const ids = { sessionId: `s-${calls.length}`, turnId: `t-${calls.length}` };
+    options.onEvent({ type: 'turn.started', ...ids });
+    if (input.text.startsWith('<minimax-bot-helper>')) return { ...ids, status: 'finished', text: 'BACKGROUND_ANSWER' };
+    if (input.text.endsWith('START_BACKGROUND')) {
+      await engine.startHelper(bot, { task: 'Look this up' });
+      return { ...ids, status: 'finished', text: 'Started' };
+    }
+    return { ...ids, status: 'finished', text: 'Relay' };
+  } };
+  await engine.runBotTurn({ bot, chatId, text: 'START_BACKGROUND', kind: 'private' });
+  await until(() => store.state.helpers[0]?.status === 'done');
+  const messages = await store.getMessages(chatId);
+  assert.ok(messages.some((m) => m.role === 'helper'), 'the finished job delivers its report');
+  const onDisk = JSON.parse(await readFile(join(dir, 'state.json'), 'utf8'));
+  assert.equal(onDisk.helpers.find((h) => h.id === store.state.helpers[0].id)?.status, 'done', 'the status is saved, not left running');
+  assert.ok(loggedMiss(warnings), 'the miss goes to the log');
+});
+
+test('a real failing ledger append is logged, not silently dropped', async (t) => {
+  // No stub: the real Store.recordUsage must survive the failed append AND log the miss,
+  // which is what the README promises for a full disk in production.
+  const { dir, store, engine, warnings } = await fixture(t, { stub: false });
+  const bot = { id: 'bot_a', name: 'Alice', role: 'Writer' };
+  store.state.bots = [bot];
+  // appendFile onto a directory fails (EISDIR) the way a full disk fails the append.
+  store.usagePath = dir;
+  engine.agent = { async run(input, options) {
+    const ids = { sessionId: 's-real', turnId: 't-real' };
+    options.onEvent({ type: 'turn.started', ...ids });
+    return { ...ids, status: 'finished', text: 'All done' };
+  } };
+  const result = await engine.runBotTurn({ bot, chatId: `bot:${bot.id}`, text: 'hi', kind: 'private' });
+  assert.equal(result.status, 'done', 'the reply keeps its outcome');
+  const messages = await store.getMessages(`bot:${bot.id}`);
+  assert.equal(messages.find((m) => m.id === result.messageId)?.status, 'done');
+  assert.ok(loggedMiss(warnings), 'the real store path must log the lost row');
+  assert.equal(store.usageIds.size, 0, 'a failed append must not claim the turn id, so a retry can still write');
+});
\ No newline at end of file
diff --git a/plugins/minimax-ai/minimax-bot/tests/store-corrupt-recovery.test.mjs b/plugins/minimax-ai/minimax-bot/tests/store-corrupt-recovery.test.mjs
new file mode 100644
index 0000000..9537a87
--- /dev/null
+++ b/plugins/minimax-ai/minimax-bot/tests/store-corrupt-recovery.test.mjs
@@ -0,0 +1,56 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { Store } from '../miniapp/node/store.mjs';
+
+// A state.json or chat file that cannot be parsed must not keep the Mini App from starting:
+// the unreadable file is kept as *.corrupt-<time> and the store starts from defaults.
+
+test('a 0-byte state.json is quarantined so the plugin still starts', async (t) => {
+  const dir = await mkdtemp(join(tmpdir(), 'bot-corrupt-state-'));
+  t.after(() => rm(dir, { recursive: true, force: true }));
+  const seed = new Store(dir);
+  await seed.init();
+  await seed.save();
+  await writeFile(join(dir, 'state.json'), '', 'utf8'); // what a crash after rename-without-fsync leaves
+  const store = new Store(dir);
+  await store.init(); // red on baseline: throws SyntaxError, the whole Mini App refuses to start
+  assert.equal(store.state.bots.length, 1, 'the store reseeds its Chief');
+  assert.ok((await readdir(dir)).some((name) => name.includes('corrupt')), 'the unreadable file is kept as evidence');
+});
+
+test('one truncated chat file does not take every chat down', async (t) => {
+  const dir = await mkdtemp(join(tmpdir(), 'bot-corrupt-chat-'));
+  t.after(() => rm(dir, { recursive: true, force: true }));
+  const seed = new Store(dir);
+  await seed.init();
+  const chat = seed.chatIds()[0];
+  await seed.appendMessage(chat, { role: 'user', text: 'keep me' });
+  // A second chat with a healthy file: it must still load.
+  const other = 'bot:bot_other';
+  await writeFile(seed.messagePath(other), JSON.stringify([{ id: 'msg_other', role: 'user', text: 'other chat', ts: 1, status: 'done' }]));
+  await writeFile(seed.messagePath(chat), '{"id":"msg_x","text":"hal', 'utf8');
+  const store = new Store(dir);
+  await store.init(); // red on baseline: one bad chat file kills the whole warm-up
+  assert.deepEqual(await store.getMessages(chat), [], 'the unreadable chat starts empty');
+  assert.equal((await store.getMessages(other)).length, 1, 'the other chat loads normally');
+  assert.ok((await readdir(join(dir, 'messages'))).some((name) => name.includes('corrupt')), 'the truncated file is kept as evidence');
+});
+
+test('a state.json whose sessions is null starts, and setSession does not throw', async (t) => {
+  const dir = await mkdtemp(join(tmpdir(), 'bot-shape-sessions-'));
+  t.after(() => rm(dir, { recursive: true, force: true }));
+  const seed = new Store(dir);
+  await seed.init();
+  await seed.save();
+  const state = JSON.parse(await readFile(join(dir, 'state.json'), 'utf8'));
+  state.sessions = null;
+  await writeFile(join(dir, 'state.json'), JSON.stringify(state));
+  const store = new Store(dir);
+  await store.init();
+  const botId = store.state.bots[0].id;
+  await store.setSession(`bot:${botId}`, botId, { sessionId: 's-shape' }); // red on baseline: TypeError on null
+  assert.equal(store.getSession(`bot:${botId}`, botId)?.sessionId, 's-shape');
+});
\ No newline at end of file
diff --git a/plugins/minimax-ai/minimax-bot/tests/unknown-zombie.test.mjs b/plugins/minimax-ai/minimax-bot/tests/unknown-zombie.test.mjs
index 639e59c..5c03caf 100644
--- a/plugins/minimax-ai/minimax-bot/tests/unknown-zombie.test.mjs
+++ b/plugins/minimax-ai/minimax-bot/tests/unknown-zombie.test.mjs
@@ -123,6 +123,11 @@ test("a task left running by a crash converges after the restart", async (t) =>
   assert.equal(persisted.taskBatches[0].tasks[0].status, "running");
   t.after(async () => {
     engine.dispose();
+    // The aborted turn still finishes its bookkeeping, and that write lands after the
+    // dispose returned. Wait for it, the way the shutdown path does, before removing the
+    // directory it writes into.
+    await until(() => idle(engine), "idle").catch(() => {});
+    await store.writeChain;
     await rm(dir, { recursive: true, force: true });
   });