blun-king-cli 9.1.458 → 9.1.459

package/bin/agent-resume-snapshot.cjs

@@ -0,0 +1,210 @@
+'use strict';
+
+const AGENT_RESUME_SNAPSHOT_SCHEMA_VERSION = 1;
+
+function copyJsonObject(value, fallback) {
+  if (value === undefined) return fallback;
+  return JSON.parse(JSON.stringify(value));
+}
+
+function captureMessageTimes(agent) {
+  const replayTimes = new Map();
+  for (const record of agent.replayBuilder.records) {
+    if (record?.type === 'message' && Number.isFinite(record.time)) {
+      replayTimes.set(record.message, record.time);
+    }
+  }
+  return agent.context.history.map((message) => {
+    const time = agent.records.messageTimes?.get(message) ?? replayTimes.get(message);
+    return Number.isFinite(time) ? time : null;
+  });
+}
+
+function createAgentResumeSnapshot(agent) {
+  const userTools = [...agent.tools.userTools.values()].map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.parameters,
+  }));
+  return {
+    schemaVersion: AGENT_RESUME_SNAPSHOT_SCHEMA_VERSION,
+    context: {
+      history: agent.context.history,
+      tokenCount: agent.context.tokenCount,
+      tokenCountCoveredMessageCount: agent.context.tokenCountCoveredMessageCount,
+      lastAssistantAt: agent.context._lastAssistantAt,
+      messageTimes: captureMessageTimes(agent),
+    },
+    config: {
+      cwd: agent.config._cwd,
+      modelAlias: agent.config._modelAlias,
+      profileName: agent.config._profileName,
+      thinkingEffort: agent.config._thinkingEffort,
+      actionStyle: agent.config._actionStyle,
+      systemPrompt: agent.config._systemPrompt,
+    },
+    permission: {
+      hasModeOverride: agent.permission.modeOverride !== undefined,
+      modeOverride: agent.permission.modeOverride,
+      sessionApprovalRulePatterns: [...agent.permission.localSessionApprovalRulePatterns],
+    },
+    plan: {
+      active: agent.planMode._isActive,
+      id: agent.planMode._planId,
+      filePath: agent.planMode._planFilePath,
+    },
+    swarm: { active: agent.swarmMode.active },
+    usage: { byModel: agent.usage.byModel },
+    tools: {
+      userTools,
+      enabledTools: [...agent.tools.enabledTools],
+      mcpAccessPatterns: [...agent.tools.mcpAccessPatterns],
+      store: agent.tools.store,
+      allowedTools: agent.tools.allowedTools,
+      excludedTools: [...agent.tools.excludedTools],
+    },
+    goal: agent.goal.state ?? null,
+    turn: {
+      turnId: agent.turn.turnId,
+      telegramDeliveryIdentities: agent.turn.telegramDeliveryLedger.snapshot(),
+    },
+    microCompaction: { cutoff: agent.microCompaction.cutoff },
+  };
+}
+
+function isValidSnapshot(snapshot) {
+  return snapshot !== null
+    && typeof snapshot === 'object'
+    && snapshot.schemaVersion === AGENT_RESUME_SNAPSHOT_SCHEMA_VERSION
+    && snapshot.context !== null
+    && typeof snapshot.context === 'object'
+    && Array.isArray(snapshot.context.history)
+    && snapshot.config !== null
+    && typeof snapshot.config === 'object'
+    && typeof snapshot.config.cwd === 'string'
+    && snapshot.permission !== null
+    && typeof snapshot.permission === 'object'
+    && snapshot.tools !== null
+    && typeof snapshot.tools === 'object'
+    && Array.isArray(snapshot.tools.userTools)
+    && snapshot.turn !== null
+    && typeof snapshot.turn === 'object';
+}
+
+function restoreAgentResumeSnapshot(agent, snapshot) {
+  if (!isValidSnapshot(snapshot)) return false;
+
+  const previousRestoring = agent.records._restoring;
+  agent.records._restoring = { time: Date.now() };
+  try {
+    agent.config._cwd = snapshot.config.cwd;
+    agent.config._modelAlias = snapshot.config.modelAlias;
+    agent.config._profileName = snapshot.config.profileName;
+    agent.config._thinkingEffort = snapshot.config.thinkingEffort ?? 'off';
+    agent.config._actionStyle = snapshot.config.actionStyle ?? 'default';
+    agent.config._systemPrompt = snapshot.config.systemPrompt ?? '';
+    agent.kaos.chdir(snapshot.config.cwd);
+
+    agent.context._history = snapshot.context.history;
+    agent.context._tokenCount = Number.isFinite(snapshot.context.tokenCount)
+      ? snapshot.context.tokenCount
+      : 0;
+    agent.context.tokenCountCoveredMessageCount = Number.isInteger(
+      snapshot.context.tokenCountCoveredMessageCount,
+    ) ? Math.max(
+      0,
+      Math.min(snapshot.context.history.length, snapshot.context.tokenCountCoveredMessageCount),
+    ) : 0;
+    agent.context._lastAssistantAt = Number.isFinite(snapshot.context.lastAssistantAt)
+      ? snapshot.context.lastAssistantAt
+      : null;
+    const messageTimes = Array.isArray(snapshot.context.messageTimes)
+      ? snapshot.context.messageTimes
+      : [];
+    if (agent.records.messageTimes?.set) {
+      snapshot.context.history.forEach((message, index) => {
+        const time = messageTimes[index];
+        if (Number.isFinite(time)) agent.records.messageTimes.set(message, time);
+      });
+    }
+    agent.context.openSteps.clear();
+    agent.context.pendingToolResultIds.clear();
+    agent.context.deferredMessages = [];
+    agent.context.markPendingTokenEstimateDirty();
+    agent.injection.onContextClear();
+
+    agent.permission.modeOverride = snapshot.permission.hasModeOverride === true
+      ? snapshot.permission.modeOverride
+      : undefined;
+    agent.permission.localSessionApprovalRulePatterns = new Set(
+      Array.isArray(snapshot.permission.sessionApprovalRulePatterns)
+        ? snapshot.permission.sessionApprovalRulePatterns
+        : [],
+    );
+
+    agent.planMode._isActive = snapshot.plan?.active === true;
+    agent.planMode._planId = agent.planMode._isActive ? snapshot.plan?.id ?? null : null;
+    agent.planMode._planFilePath = agent.planMode._isActive
+      ? snapshot.plan?.filePath ?? null
+      : null;
+    agent.swarmMode.active = snapshot.swarm?.active ?? null;
+    agent.usage.byModel = copyJsonObject(snapshot.usage?.byModel, {});
+    agent.usage.currentTurn = undefined;
+
+    agent.tools.userTools.clear();
+    for (const tool of snapshot.tools.userTools) {
+      if (!tool || typeof tool.name !== 'string' || !tool.name) continue;
+      agent.tools.registerUserTool({
+        name: tool.name,
+        description: typeof tool.description === 'string' ? tool.description : '',
+        parameters: tool.parameters ?? { type: 'object' },
+      });
+    }
+    agent.tools.enabledTools = new Set(
+      Array.isArray(snapshot.tools.enabledTools) ? snapshot.tools.enabledTools : [],
+    );
+    agent.tools.mcpAccessPatterns = Array.isArray(snapshot.tools.mcpAccessPatterns)
+      ? [...snapshot.tools.mcpAccessPatterns]
+      : [];
+    agent.tools.store = copyJsonObject(snapshot.tools.store, {});
+    agent.tools.allowedTools = Array.isArray(snapshot.tools.allowedTools)
+      ? [...snapshot.tools.allowedTools]
+      : undefined;
+    agent.tools.excludedTools = Array.isArray(snapshot.tools.excludedTools)
+      ? [...snapshot.tools.excludedTools]
+      : [];
+    if (agent.config.hasProvider) agent.tools.initializeBuiltinTools();
+
+    agent.goal.state = snapshot.goal === null
+      ? undefined
+      : copyJsonObject(snapshot.goal, undefined);
+    agent.turn.turnId = Number.isInteger(snapshot.turn.turnId) ? snapshot.turn.turnId : -1;
+    agent.turn.activeTurn = 'resuming';
+    agent.turn.steerBuffer.length = 0;
+    agent.turn.telegramDeliveryLedger.restore(snapshot.turn.telegramDeliveryIdentities);
+    agent.microCompaction.cutoff = Number.isInteger(snapshot.microCompaction?.cutoff)
+      ? Math.max(0, Math.min(snapshot.context.history.length, snapshot.microCompaction.cutoff))
+      : 0;
+
+    agent.toolResultBatchOffload.reset(agent.context._history);
+    agent.userMessageOffload.reset(agent.context._history);
+    agent.assistantMessageOffload.reset(agent.context._history);
+    agent.replayBuilder.records = agent.context._history.map((message, index) => {
+      const time = messageTimes[index];
+      return Number.isFinite(time)
+        ? { type: 'message', message, time }
+        : { type: 'message', message };
+    });
+    agent.replayBuilder.frozen = false;
+    agent.replayBuilder.segmentStart = 0;
+    return true;
+  } finally {
+    agent.records._restoring = previousRestoring;
+  }
+}
+
+module.exports = {
+  AGENT_RESUME_SNAPSHOT_SCHEMA_VERSION,
+  createAgentResumeSnapshot,
+  restoreAgentResumeSnapshot,
+};

package/bin/repeated-user-message-projection.cjs

@@ -67,6 +67,22 @@ class TelegramDeliveryLedger {
     }
     return identity;
   }
+
+  snapshot() {
+    return [...this.identities];
+  }
+
+  restore(identities) {
+    this.identities.clear();
+    if (!Array.isArray(identities)) return;
+    for (const identity of identities) {
+      if (typeof identity !== 'string' || !identity || this.identities.has(identity)) continue;
+      this.identities.add(identity);
+      while (this.identities.size > this.limit) {
+        this.identities.delete(this.identities.values().next().value);
+      }
+    }
+  }
 }
 
 function repeatedUserMessageKey(message) {

package/bin/session-resume-checkpoint.cjs

@@ -0,0 +1,254 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const RESUME_CHECKPOINT_SCHEMA_VERSION = 1;
+const MAX_RESUME_SNAPSHOT_BYTES = 4 * 1024 * 1024;
+const MAX_RESUME_CHECKPOINT_BYTES = MAX_RESUME_SNAPSHOT_BYTES + 256 * 1024;
+const WIRE_SAMPLE_BYTES = 4096;
+
+function resumeCheckpointPath(wirePath) {
+  return path.join(path.dirname(wirePath), 'resume-checkpoint.json');
+}
+
+function sha256(value) {
+  return crypto.createHash('sha256').update(value).digest('hex');
+}
+
+function invalid(reason) {
+  return { ok: false, reason };
+}
+
+function isNonNegativeInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+
+function sampleRanges(offset) {
+  if (offset === 0) return [];
+  const length = Math.min(WIRE_SAMPLE_BYTES, offset);
+  const starts = [
+    0,
+    Math.max(0, Math.floor((offset - length) / 2)),
+    Math.max(0, offset - length),
+  ];
+  return [...new Set(starts)].map((start) => ({
+    start,
+    length: Math.min(length, offset - start),
+  }));
+}
+
+async function readExact(handle, start, length) {
+  const buffer = Buffer.alloc(length);
+  let filled = 0;
+  while (filled < length) {
+    const { bytesRead } = await handle.read(
+      buffer,
+      filled,
+      length - filled,
+      start + filled,
+    );
+    if (bytesRead === 0) break;
+    filled += bytesRead;
+  }
+  return filled === length ? buffer : buffer.subarray(0, filled);
+}
+
+async function captureWireSamples(handle, offset) {
+  const samples = [];
+  for (const range of sampleRanges(offset)) {
+    const bytes = await readExact(handle, range.start, range.length);
+    if (bytes.length !== range.length) {
+      throw new Error('wire_changed_during_checkpoint');
+    }
+    samples.push({ ...range, sha256: sha256(bytes) });
+  }
+  return samples;
+}
+
+async function writeAtomic(filePath, bytes) {
+  const directory = path.dirname(filePath);
+  const temporaryPath = `${filePath}.tmp-${process.pid}-${crypto.randomBytes(8).toString('hex')}`;
+  let handle;
+  try {
+    handle = await fs.promises.open(temporaryPath, 'wx', 0o600);
+    await handle.writeFile(bytes);
+    await handle.sync();
+    await handle.close();
+    handle = undefined;
+    await fs.promises.rename(temporaryPath, filePath);
+  } finally {
+    if (handle) await handle.close().catch(() => {});
+    await fs.promises.rm(temporaryPath, { force: true }).catch(() => {});
+  }
+}
+
+async function writeResumeCheckpoint({ wirePath, wireOffset, recordCount, snapshot }) {
+  if (!isNonNegativeInteger(recordCount)) {
+    return { written: false, reason: 'record_count_invalid' };
+  }
+  if (wireOffset !== undefined && !isNonNegativeInteger(wireOffset)) {
+    return { written: false, reason: 'wire_offset_invalid' };
+  }
+
+  let snapshotJson;
+  try {
+    snapshotJson = JSON.stringify(snapshot);
+  } catch {
+    return { written: false, reason: 'snapshot_not_serializable' };
+  }
+  if (snapshotJson === undefined) {
+    return { written: false, reason: 'snapshot_not_serializable' };
+  }
+  const snapshotBytes = Buffer.byteLength(snapshotJson, 'utf8');
+  if (snapshotBytes > MAX_RESUME_SNAPSHOT_BYTES) {
+    return { written: false, reason: 'snapshot_too_large' };
+  }
+
+  const handle = await fs.promises.open(wirePath, 'r');
+  let stat;
+  let offset;
+  let samples;
+  try {
+    stat = await handle.stat();
+    offset = wireOffset ?? stat.size;
+    if (offset > stat.size) {
+      return { written: false, reason: 'wire_truncated' };
+    }
+    if (offset > 0) {
+      const boundary = await readExact(handle, offset - 1, 1);
+      if (boundary.length !== 1 || boundary[0] !== 0x0a) {
+        return { written: false, reason: 'wire_not_line_terminated' };
+      }
+    }
+    samples = await captureWireSamples(handle, offset);
+  } finally {
+    await handle.close();
+  }
+
+  const payload = {
+    schemaVersion: RESUME_CHECKPOINT_SCHEMA_VERSION,
+    createdAt: new Date().toISOString(),
+    wire: {
+      offset,
+      recordCount,
+      sizeAtCheckpoint: offset,
+      identity: {
+        ino: Number.isSafeInteger(stat.ino) ? stat.ino : null,
+        birthtimeMs: Number.isFinite(stat.birthtimeMs) ? stat.birthtimeMs : null,
+        samples,
+      },
+    },
+    snapshot,
+    snapshotSha256: sha256(snapshotJson),
+  };
+  const checkpointBytes = Buffer.from(`${JSON.stringify(payload)}\n`, 'utf8');
+  if (checkpointBytes.length > MAX_RESUME_CHECKPOINT_BYTES) {
+    return { written: false, reason: 'checkpoint_too_large' };
+  }
+
+  await writeAtomic(resumeCheckpointPath(wirePath), checkpointBytes);
+  return {
+    written: true,
+    offset,
+    recordCount,
+    checkpointPath: resumeCheckpointPath(wirePath),
+  };
+}
+
+async function loadResumeCheckpoint({ wirePath }) {
+  const checkpointPath = resumeCheckpointPath(wirePath);
+  let checkpointStat;
+  try {
+    checkpointStat = await fs.promises.stat(checkpointPath);
+  } catch (error) {
+    return invalid(error && error.code === 'ENOENT' ? 'checkpoint_missing' : 'checkpoint_unreadable');
+  }
+  if (checkpointStat.size > MAX_RESUME_CHECKPOINT_BYTES) {
+    return invalid('checkpoint_too_large');
+  }
+
+  let checkpoint;
+  try {
+    checkpoint = JSON.parse(await fs.promises.readFile(checkpointPath, 'utf8'));
+  } catch (error) {
+    return invalid(error instanceof SyntaxError ? 'checkpoint_invalid_json' : 'checkpoint_unreadable');
+  }
+  if (!checkpoint || checkpoint.schemaVersion !== RESUME_CHECKPOINT_SCHEMA_VERSION) {
+    return invalid('checkpoint_schema_unsupported');
+  }
+  const wire = checkpoint.wire;
+  if (
+    !wire
+    || !isNonNegativeInteger(wire.offset)
+    || !isNonNegativeInteger(wire.recordCount)
+    || !wire.identity
+    || !Array.isArray(wire.identity.samples)
+    || typeof checkpoint.snapshotSha256 !== 'string'
+  ) {
+    return invalid('checkpoint_invalid_shape');
+  }
+
+  let snapshotJson;
+  try {
+    snapshotJson = JSON.stringify(checkpoint.snapshot);
+  } catch {
+    return invalid('checkpoint_invalid_snapshot');
+  }
+  if (snapshotJson === undefined || Buffer.byteLength(snapshotJson, 'utf8') > MAX_RESUME_SNAPSHOT_BYTES) {
+    return invalid('checkpoint_invalid_snapshot');
+  }
+  if (sha256(snapshotJson) !== checkpoint.snapshotSha256) {
+    return invalid('checkpoint_snapshot_mismatch');
+  }
+
+  let handle;
+  try {
+    handle = await fs.promises.open(wirePath, 'r');
+    const stat = await handle.stat();
+    if (stat.size < wire.offset) return invalid('wire_truncated');
+    if (wire.offset > 0) {
+      const boundary = await readExact(handle, wire.offset - 1, 1);
+      if (boundary.length !== 1 || boundary[0] !== 0x0a) {
+        return invalid('wire_offset_not_line_boundary');
+      }
+    }
+    for (const sample of wire.identity.samples) {
+      if (
+        !sample
+        || !isNonNegativeInteger(sample.start)
+        || !isNonNegativeInteger(sample.length)
+        || sample.start + sample.length > wire.offset
+        || typeof sample.sha256 !== 'string'
+      ) {
+        return invalid('checkpoint_invalid_shape');
+      }
+      const bytes = await readExact(handle, sample.start, sample.length);
+      if (bytes.length !== sample.length || sha256(bytes) !== sample.sha256) {
+        return invalid('wire_identity_mismatch');
+      }
+    }
+  } catch (error) {
+    return invalid(error && error.code === 'ENOENT' ? 'wire_missing' : 'wire_unreadable');
+  } finally {
+    if (handle) await handle.close().catch(() => {});
+  }
+
+  return {
+    ok: true,
+    offset: wire.offset,
+    recordCount: wire.recordCount,
+    snapshot: checkpoint.snapshot,
+    checkpointPath,
+  };
+}
+
+module.exports = {
+  MAX_RESUME_CHECKPOINT_BYTES,
+  MAX_RESUME_SNAPSHOT_BYTES,
+  RESUME_CHECKPOINT_SCHEMA_VERSION,
+  loadResumeCheckpoint,
+  resumeCheckpointPath,
+  writeResumeCheckpoint,
+};

package/blun.mjs

@@ -10,6 +10,8 @@ import cognitiveGoalAutostartPolicy from "./bin/cognitive-goal-autostart-policy.
 import cognitiveGoalTimeTriggerController from "./bin/cognitive-goal-time-trigger-controller.cjs";
 import runtimeExitLedger from "./bin/runtime-exit-ledger.cjs";
 import compactionModelPolicy from "./bin/compaction-model-policy.cjs";
+import agentResumeSnapshot from "./bin/agent-resume-snapshot.cjs";
+import sessionResumeCheckpoint from "./bin/session-resume-checkpoint.cjs";
 import crypto$1, { createHash, randomBytes, randomInt, randomUUID, timingSafeEqual } from "node:crypto";
 import * as fs$16 from "node:fs";
 import Kt, { accessSync, appendFileSync, chmodSync, closeSync, constants, copyFileSync, createReadStream, createWriteStream, existsSync, fsyncSync, linkSync, lstatSync, mkdirSync, openSync, promises, readFileSync, readSync, readdirSync, realpathSync, renameSync, rmSync, statSync, unlinkSync, writeFileSync, writeSync } from "node:fs";
@@ -44,6 +46,8 @@ const { goalAutostartDecision, goalContinuationDecision } = cognitiveGoalAutosta
 const { GoalTimeTriggerController } = cognitiveGoalTimeTriggerController;
 const { recordRuntimeExit } = runtimeExitLedger;
 const { resolveCompactionModelAlias } = compactionModelPolicy;
+const { createAgentResumeSnapshot, restoreAgentResumeSnapshot } = agentResumeSnapshot;
+const { loadResumeCheckpoint, writeResumeCheckpoint } = sessionResumeCheckpoint;
 import { EventEmitter as EventEmitter$1 } from "node:events";
 import { StringDecoder } from "node:string_decoder";
 import co from "node:assert";
@@ -234802,6 +234806,7 @@ var init_persistence = __esmMin((() => {
 		filePath;
 		options;
 		pendingRecords = [];
+		persistedRecordCount = 0;
 		shouldClear = false;
 		directorySynced = false;
 		flushPromise;
@@ -234811,10 +234816,15 @@ var init_persistence = __esmMin((() => {
 			this.options = options;
 		}
 		async *read() {
+			yield* this.readFrom(0, 0);
+		}
+		async *readFrom(offset = 0, lineNumber = 0) {
 			await this.flush();
 			let line = "";
-			let lineNumber = 0;
-			const stream = createReadStream(this.filePath, { encoding: "utf8" });
+			const stream = createReadStream(this.filePath, {
+				encoding: "utf8",
+				start: offset
+			});
 			try {
 				for await (const chunk of stream) {
 					line += chunk;
@@ -234893,6 +234903,8 @@ var init_persistence = __esmMin((() => {
 			try {
 				if (content.length > 0) await fh.writeFile(content, "utf8");
 				await fh.sync();
+				if (shouldClear) this.persistedRecordCount = batch.length;
+				else this.persistedRecordCount += batch.length;
 			} finally {
 				await fh.close();
 			}
@@ -235224,6 +235236,7 @@ var init_records = __esmMin((() => {
 		persistence;
 		_restoring = null;
 		metadataInitialized = false;
+		messageTimes = new WeakMap();
 		constructor(agent, persistence) {
 			this.agent = agent;
 			this.persistence = persistence;
@@ -235237,6 +235250,7 @@ var init_records = __esmMin((() => {
 				...record,
 				time: Date.now()
 			};
+			if (stamped.type === "context.append_message") this.messageTimes.set(stamped.message, stamped.time);
 			if (this.persistence !== void 0 && !this.metadataInitialized && stamped.type !== "metadata") {
 				this.persistence.append({
 					type: "metadata",
@@ -235251,6 +235265,7 @@ var init_records = __esmMin((() => {
 		restore(record) {
 			this._restoring = { time: record.time ?? Date.now() };
 			try {
+				if (record.type === "context.append_message" && Number.isFinite(record.time)) this.messageTimes.set(record.message, record.time);
 				restoreAgentRecord(this.agent, record);
 				return this.agent.replayBuilder.finishRestoringRecord(record.type);
 			} finally {
@@ -235260,13 +235275,16 @@ var init_records = __esmMin((() => {
 		async replay(options = {}) {
 			if (!this.persistence) throw new Error("No persistence provided for AgentRecords");
 			const rewriteMigratedRecords = options.rewriteMigratedRecords ?? true;
+			if (rewriteMigratedRecords && await this.tryReplayResumeCheckpoint()) return {};
 			let migrations = [];
 			let hasMetadata = false;
 			let shouldRewrite = false;
 			let warning;
 			const replayedRecords = rewriteMigratedRecords ? [] : void 0;
 			let completed = true;
+			let replayedRecordCount = 0;
 			for await (const record of this.persistence.read()) {
+				replayedRecordCount++;
 				if (!hasMetadata) {
 					if (record.type !== "metadata") throw new Error("AgentRecords replay expected metadata as the first record");
 					hasMetadata = true;
@@ -235295,9 +235313,45 @@ var init_records = __esmMin((() => {
 				this.persistence.rewrite(replayedRecords);
 				await this.persistence.flush();
 			}
+			if (completed && this.persistence instanceof FileSystemAgentRecordPersistence) this.persistence.persistedRecordCount = replayedRecordCount;
 			if (completed && this.agent.blobStore !== void 0) for (const msg of this.agent.context.history) await this.agent.blobStore.rehydrateParts(msg.content);
 			return { warning };
 		}
+		async tryReplayResumeCheckpoint() {
+			if (!(this.persistence instanceof FileSystemAgentRecordPersistence)) return false;
+			if (this.agent.replayBuilder.options.range !== void 0) return false;
+			const checkpoint = await loadResumeCheckpoint({ wirePath: this.persistence.filePath });
+			if (!checkpoint.ok) return false;
+			if (!restoreAgentResumeSnapshot(this.agent, checkpoint.snapshot)) return false;
+			this.metadataInitialized = true;
+			let tailRecordCount = 0;
+			for await (const record of this.persistence.readFrom(checkpoint.offset, checkpoint.recordCount)) {
+				this.restore(record);
+				tailRecordCount++;
+			}
+			this.persistence.persistedRecordCount = checkpoint.recordCount + tailRecordCount;
+			if (this.agent.blobStore !== void 0) for (const msg of this.agent.context.history) await this.agent.blobStore.rehydrateParts(msg.content);
+			return true;
+		}
+		async writeResumeCheckpoint() {
+			if (!(this.persistence instanceof FileSystemAgentRecordPersistence)) return;
+			if (this.agent.replayBuilder.options.range !== void 0) return;
+			try {
+				await this.flush();
+				const wireOffset = statSync(this.persistence.filePath).size;
+				const recordCount = this.persistence.persistedRecordCount;
+				const snapshot = createAgentResumeSnapshot(this.agent);
+				const result = await writeResumeCheckpoint({
+					wirePath: this.persistence.filePath,
+					wireOffset,
+					recordCount,
+					snapshot
+				});
+				if (!result.written) this.agent.log.warn("resume checkpoint was not written", { reason: result.reason });
+			} catch (error) {
+				this.agent.log.warn("resume checkpoint write failed", { error });
+			}
+		}
 		async flush() {
 			await this.persistence?.flush();
 		}
@@ -262495,6 +262549,7 @@ var init_turn = __esmMin((() => {
 			this.cognitiveLocalClaimsByTurn.delete(turnId);
 			this.stepFailureByTurn.delete(turnId);
 			await this.agent.records.flush();
+			await this.agent.records.writeResumeCheckpoint();
 			return {
 				event: ended,
 				stopReason: completedStopReason,
@@ -265772,6 +265827,8 @@ var init_agent = __esmMin((() => {
 				await this.cron?.loadFromDisk();
 				this.context.finishResume();
 				this.turn.finishResume();
+				await this.records.flush();
+				await this.records.writeResumeCheckpoint();
 			} finally {
 				this.replayBuilder.postRestoring = false;
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.458",
+  "version": "9.1.459",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {