blun-king-cli 9.1.458 → 9.1.460

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 = 2;
+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/bin/session-scrollback-archive.cjs

@@ -0,0 +1,206 @@
+'use strict';
+
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const ARCHIVE_SCHEMA_VERSION = 1;
+const INDEX_FILE = 'index.json';
+
+function sessionScrollbackArchiveDirectory(wirePath) {
+  return path.join(path.dirname(wirePath), 'tui-scrollback-v1');
+}
+
+function isNonNegativeInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+
+function writeAtomic(filePath, value) {
+  const temporaryPath = `${filePath}.tmp-${process.pid}-${crypto.randomBytes(8).toString('hex')}`;
+  try {
+    fs.writeFileSync(temporaryPath, value, {
+      encoding: 'utf8',
+      flag: 'wx',
+      mode: 0o600,
+    });
+    fs.renameSync(temporaryPath, filePath);
+  } finally {
+    try {
+      fs.rmSync(temporaryPath, { force: true });
+    } catch {}
+  }
+}
+
+class SessionScrollbackArchive {
+  constructor({ directory, reset = false, reuse = false }) {
+    if (typeof directory !== 'string' || directory.length === 0) {
+      throw new TypeError('session scrollback directory is required');
+    }
+    this.directory = path.resolve(directory);
+    this.chunks = [];
+    this.loadedChunks = new Map();
+    this.lineCount = 0;
+    this.loadedExisting = false;
+
+    if (reset) {
+      this.reset();
+    } else if (reuse) {
+      this.loadExisting();
+    }
+  }
+
+  get totalLines() {
+    return this.lineCount;
+  }
+
+  get loadedChunkCount() {
+    return this.loadedChunks.size;
+  }
+
+  append(lines) {
+    if (!Array.isArray(lines) || !lines.every((line) => typeof line === 'string')) {
+      return false;
+    }
+    if (lines.length === 0) return true;
+
+    fs.mkdirSync(this.directory, { recursive: true });
+    const file = `chunk-${String(this.chunks.length).padStart(8, '0')}-${crypto.randomBytes(6).toString('hex')}.json`;
+    const chunkPath = path.join(this.directory, file);
+    const chunk = {
+      file,
+      startLine: this.lineCount,
+      lineCount: lines.length,
+    };
+
+    try {
+      writeAtomic(chunkPath, JSON.stringify(lines));
+      const nextChunks = [...this.chunks, chunk];
+      const nextLineCount = this.lineCount + lines.length;
+      this.writeIndex(nextChunks, nextLineCount);
+      this.chunks = nextChunks;
+      this.lineCount = nextLineCount;
+      return true;
+    } catch {
+      try {
+        fs.rmSync(chunkPath, { force: true });
+      } catch {}
+      return false;
+    }
+  }
+
+  readRange(start, end) {
+    if (!Number.isFinite(start) || !Number.isFinite(end)) return [];
+    if (start >= end || start >= this.lineCount) return [];
+    const boundedStart = Math.max(0, Math.floor(start));
+    const boundedEnd = Math.min(this.lineCount, Math.floor(end));
+    const output = [];
+
+    for (let index = 0; index < this.chunks.length; index++) {
+      const chunk = this.chunks[index];
+      const chunkEnd = chunk.startLine + chunk.lineCount;
+      if (chunkEnd <= boundedStart) continue;
+      if (chunk.startLine >= boundedEnd) break;
+      const lines = this.readChunk(index);
+      const sliceStart = Math.max(0, boundedStart - chunk.startLine);
+      const sliceEnd = Math.min(lines.length, boundedEnd - chunk.startLine);
+      output.push(...lines.slice(sliceStart, sliceEnd));
+    }
+    return output;
+  }
+
+  reset() {
+    try {
+      fs.rmSync(this.directory, { recursive: true, force: true });
+    } catch {}
+    this.chunks = [];
+    this.loadedChunks.clear();
+    this.lineCount = 0;
+    this.loadedExisting = false;
+  }
+
+  clear() {
+    this.reset();
+  }
+
+  dispose() {
+    this.loadedChunks.clear();
+  }
+
+  loadExisting() {
+    const indexPath = path.join(this.directory, INDEX_FILE);
+    try {
+      const parsed = JSON.parse(fs.readFileSync(indexPath, 'utf8'));
+      if (
+        parsed?.schemaVersion !== ARCHIVE_SCHEMA_VERSION
+        || !isNonNegativeInteger(parsed.totalLines)
+        || !Array.isArray(parsed.chunks)
+      ) {
+        return;
+      }
+
+      let nextLine = 0;
+      const chunks = [];
+      for (const candidate of parsed.chunks) {
+        if (
+          typeof candidate?.file !== 'string'
+          || path.basename(candidate.file) !== candidate.file
+          || !candidate.file.startsWith('chunk-')
+          || !candidate.file.endsWith('.json')
+          || candidate.startLine !== nextLine
+          || !Number.isSafeInteger(candidate.lineCount)
+          || candidate.lineCount <= 0
+        ) {
+          return;
+        }
+        const chunkPath = path.join(this.directory, candidate.file);
+        if (!fs.statSync(chunkPath).isFile()) return;
+        chunks.push({
+          file: candidate.file,
+          startLine: candidate.startLine,
+          lineCount: candidate.lineCount,
+        });
+        nextLine += candidate.lineCount;
+      }
+      if (nextLine !== parsed.totalLines) return;
+
+      this.chunks = chunks;
+      this.lineCount = parsed.totalLines;
+      this.loadedExisting = true;
+    } catch {}
+  }
+
+  readChunk(index) {
+    const loaded = this.loadedChunks.get(index);
+    if (loaded !== undefined) return loaded;
+    const chunk = this.chunks[index];
+    if (chunk === undefined) return [];
+    try {
+      const value = JSON.parse(fs.readFileSync(path.join(this.directory, chunk.file), 'utf8'));
+      if (
+        !Array.isArray(value)
+        || value.length !== chunk.lineCount
+        || !value.every((line) => typeof line === 'string')
+      ) {
+        return [];
+      }
+      this.loadedChunks.set(index, value);
+      return value;
+    } catch {
+      return [];
+    }
+  }
+
+  writeIndex(chunks, totalLines) {
+    writeAtomic(path.join(this.directory, INDEX_FILE), JSON.stringify({
+      schemaVersion: ARCHIVE_SCHEMA_VERSION,
+      totalLines,
+      chunks,
+    }));
+  }
+}
+
+module.exports = {
+  ARCHIVE_SCHEMA_VERSION,
+  SessionScrollbackArchive,
+  sessionScrollbackArchiveDirectory,
+};

package/blun.mjs

@@ -10,6 +10,9 @@ 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 sessionScrollbackArchive from "./bin/session-scrollback-archive.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 +47,9 @@ const { goalAutostartDecision, goalContinuationDecision } = cognitiveGoalAutosta
 const { GoalTimeTriggerController } = cognitiveGoalTimeTriggerController;
 const { recordRuntimeExit } = runtimeExitLedger;
 const { resolveCompactionModelAlias } = compactionModelPolicy;
+const { createAgentResumeSnapshot, restoreAgentResumeSnapshot } = agentResumeSnapshot;
+const { loadResumeCheckpoint, writeResumeCheckpoint } = sessionResumeCheckpoint;
+const { SessionScrollbackArchive, sessionScrollbackArchiveDirectory } = sessionScrollbackArchive;
 import { EventEmitter as EventEmitter$1 } from "node:events";
 import { StringDecoder } from "node:string_decoder";
 import co from "node:assert";
@@ -234802,6 +234808,7 @@ var init_persistence = __esmMin((() => {
 		filePath;
 		options;
 		pendingRecords = [];
+		persistedRecordCount = 0;
 		shouldClear = false;
 		directorySynced = false;
 		flushPromise;
@@ -234811,10 +234818,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 +234905,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 +235238,8 @@ var init_records = __esmMin((() => {
 		persistence;
 		_restoring = null;
 		metadataInitialized = false;
+		resumeCheckpointRestored = false;
+		messageTimes = new WeakMap();
 		constructor(agent, persistence) {
 			this.agent = agent;
 			this.persistence = persistence;
@@ -235237,6 +235253,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 +235268,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 {
@@ -235259,14 +235277,18 @@ var init_records = __esmMin((() => {
 		}
 		async replay(options = {}) {
 			if (!this.persistence) throw new Error("No persistence provided for AgentRecords");
+			this.resumeCheckpointRestored = false;
 			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 +235317,46 @@ 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);
+			this.resumeCheckpointRestored = true;
+			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 +262554,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 +265832,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;
 			}
@@ -316765,6 +316827,8 @@ async function resumeSessionResult(summary, session, warning) {
 		const usage = await api.getUsage({ agentId });
 		agents[agentId] = {
 			type: agent.type,
+			resumeCheckpointRestored: agent.records.resumeCheckpointRestored === true,
+			sessionWirePath: agent.records.persistence instanceof FileSystemAgentRecordPersistence ? agent.records.persistence.filePath : void 0,
 			config,
 			context,
 			replay: agent.replayBuilder.buildResult(),
@@ -506036,6 +506100,27 @@ var ScrollbackBuffer = class {
 	archiveLines(lines) {
 		return this.archive.append(lines);
 	}
+	usePersistentArchive(directory, options) {
+		this.releaseArchive();
+		const archive = new SessionScrollbackArchive({
+			directory,
+			reset: options.reset,
+			reuse: options.reuse
+		});
+		this.archive = archive;
+		return archive.loadedExisting;
+	}
+	releaseArchive() {
+		if (this.archive instanceof DiskBackedLineArchive) this.archive.clear();
+		else this.archive.dispose();
+		this.archive = new DiskBackedLineArchive();
+		this.resetViewState();
+	}
+	dispose() {
+		if (this.archive instanceof DiskBackedLineArchive) this.archive.clear();
+		else this.archive.dispose();
+		this.resetViewState();
+	}
 	activate() {
 		this.active = true;
 		this.scrollOffset = 0;
@@ -506046,6 +506131,9 @@ var ScrollbackBuffer = class {
 	}
 	clear() {
 		this.archive.clear();
+		this.resetViewState();
+	}
+	resetViewState() {
 		this.snapshotLines = [];
 		this.publishedLineCount = 0;
 		this.deactivate();
@@ -506357,6 +506445,7 @@ var ScrollbackController = class {
 	state;
 	buffer;
 	disposeListener;
+	suppressReplayArchiveWrites = false;
 	constructor(state) {
 		this.state = state;
 	}
@@ -506371,16 +506460,52 @@ var ScrollbackController = class {
 	dispose() {
 		this.disposeListener?.();
 		this.disposeListener = void 0;
-		this.buffer?.clear();
+		this.buffer?.dispose();
 		if (this.state.ui instanceof BottomPinnedTUI) this.state.ui.scrollbackBuffer = void 0;
 		this.buffer = void 0;
 	}
 	reset() {
 		this.buffer?.clear();
+		this.suppressReplayArchiveWrites = false;
+	}
+	releaseSessionArchive() {
+		this.buffer?.releaseArchive();
+		this.suppressReplayArchiveWrites = false;
+	}
+	prepareNewSession(session) {
+		const sessionDirectory = session?.summary?.sessionDir;
+		if (typeof sessionDirectory !== "string" || sessionDirectory.length === 0) return false;
+		const wirePath = path.join(sessionDirectory, "agents", "main", "wire.jsonl");
+		this.buffer?.usePersistentArchive(sessionScrollbackArchiveDirectory(wirePath), {
+			reset: true,
+			reuse: false
+		});
+		this.suppressReplayArchiveWrites = false;
+		return true;
+	}
+	prepareSessionReplay(agent) {
+		const buffer = this.buffer;
+		if (buffer === void 0) return false;
+		const persistence = agent?.records?.persistence;
+		let directory;
+		if (typeof persistence?.filePath === "string") directory = sessionScrollbackArchiveDirectory(persistence.filePath);
+		else if (typeof agent?.sessionWirePath === "string") directory = sessionScrollbackArchiveDirectory(agent.sessionWirePath);
+		else return false;
+		const resumeCheckpointRestored = agent?.records?.resumeCheckpointRestored === true || agent?.resumeCheckpointRestored === true;
+		const loadedExisting = buffer.usePersistentArchive(directory, {
+			reset: !resumeCheckpointRestored,
+			reuse: resumeCheckpointRestored
+		});
+		this.suppressReplayArchiveWrites = resumeCheckpointRestored && loadedExisting;
+		return true;
+	}
+	finishSessionReplay() {
+		this.suppressReplayArchiveWrites = false;
 	}
 	archiveComponents(components) {
 		const buffer = this.buffer;
 		if (buffer === void 0 || components.length === 0) return components.length === 0;
+		if (this.suppressReplayArchiveWrites && this.state.appState.isReplaying) return true;
 		try {
 			const width = Math.max(1, this.state.terminal.columns);
 			const lines = components.flatMap((component) => component.render(width));
@@ -509666,6 +509791,7 @@ var SessionReplayRenderer = class {
 				this.host.showError(uiText("replay.error.unavailable"));
 				return false;
 			}
+			this.host.scrollbackController.prepareSessionReplay(main);
 			this.hydrateSnapshot(main);
 			await this.renderRecords(main);
 			this.applyTerminalBackgroundAgentStatuses(main);
@@ -509677,6 +509803,7 @@ var SessionReplayRenderer = class {
 			this.host.showError(uiText("replay.error.failed", { error: message }));
 			return false;
 		} finally {
+			this.host.scrollbackController.finishSessionReplay();
 			this.host.setAppState({ isReplaying: false });
 		}
 	}
@@ -516883,7 +517010,7 @@ var BlunTUI = class {
 		if (shouldReplayHistory) {
 			await this.sessionReplay.hydrateFromReplay(this.requireSession());
 			this.applyStartupPermissionAndPlanToAppState();
-		}
+		} else if (this.session !== void 0) this.scrollbackController.prepareNewSession(this.session);
 		const resumeState = this.session?.getResumeState();
 		if (resumeState?.warning !== void 0) this.showStatus(uiText("blunTui.warning", { warning: resumeState.warning }), "warning");
 		if (this.session !== void 0) {
@@ -518845,7 +518972,7 @@ var BlunTUI = class {
 			await this.refreshSkillCommands(this.session);
 			await this.refreshPluginCommands(this.session);
 		} catch {}
-		this.clearTranscriptAndRedraw();
+		this.clearTranscriptAndRedraw({ preserveScrollbackArchive: true });
 		try {
 			await this.sessionReplay.hydrateFromReplay(session);
 		} catch (error) {
@@ -518917,7 +519044,8 @@ var BlunTUI = class {
 			await this.refreshPluginCommands(this.session);
 		} catch {}
 		this.sessionEventHandler.startSubscription();
-		this.clearTranscriptAndRedraw();
+		this.clearTranscriptAndRedraw({ preserveScrollbackArchive: true });
+		this.scrollbackController.prepareNewSession(session);
 		this.showStatus(uiText("blunTui.session.started", { sessionId: session.id }));
 		this.showSessionWarnings(session);
 		this.showConfigWarningsIfAny();
@@ -519033,9 +519161,10 @@ var BlunTUI = class {
 	disposeTranscriptChildren() {
 		for (const child of this.state.transcriptContainer.children) if (hasDispose(child)) child.dispose();
 	}
-	clearTranscriptAndRedraw() {
+	clearTranscriptAndRedraw(options = {}) {
 		this.streamingUI.discardPending();
-		this.scrollbackController.reset();
+		if (options.preserveScrollbackArchive === true) this.scrollbackController.releaseSessionArchive();
+		else this.scrollbackController.reset();
 		this.state.transcriptEntries = [];
 		this.streamingUI.disposeActiveCompactionBlock();
 		this.streamingUI.resetLiveText();

package/package.json

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