- H2: A rolling session with durable history

Reset advances the live `sessionKey -> sessionId` mapping but keeps the previous SQLite session, transcript, trajectory, and search rows. That history remains searchable under the same session key; ordinary entry and session lists show only the new live mapping. Retained reset history is bounded by the disk budget, not by `resetArchiveRetention`, which only ages archive artifacts. Explicit deletion is different: it writes and verifies a compressed transcript archive (`*.jsonl.deleted.<timestamp>.zst` when zstd is available) before removing the deleted session's rows.

`maxDiskBytes` enforcement uses physical bytes: the per-agent SQLite main file, its `-wal` file, and counted files in the agent sessions directory. It never estimates row JSON sizes or subtracts logical row sizes from that total.

Committed writes and deletion first land in the WAL. Cleanup checkpoints it so the WAL can shrink immediately, then uses incremental vacuum to return eligible free tail pages from the main file; pages that are not yet reclaimable stay in the main file and therefore remain counted on the next physical measurement. `mode: "warn"` reports the current physical overage without checkpointing, writing an archive, or deleting rows.

now?: number;

export async function runPrCiSweeper({

github,

context,

core,

dryRun = false,

appSlug = "",

// Injectable clock: fixture-based tests pin a fixed instant so lookback

// classification cannot rot as wall-clock time passes the fixture dates.

now = Date.now(),

}) {

export function isRetainedSessionTranscriptArchiveName(fileName: string): boolean {

return hasArchiveSuffix(fileName, "deleted") || hasArchiveSuffix(fileName, "reset");

import {

enforceSqliteSessionHistoryDiskBudget,

inspectSqliteSessionHistoryDiskBudget,

} from "./session-history-eviction.js";

? await inspectSqliteSessionHistoryDiskBudget({

mode: params.mode,

: { diskBudget: null, wouldMutate: false };

const budgetEvictedKeys = new Set<string>();

(diskBudget?.removedFiles ?? 0) > 0 ||

diskBudgetPreview.wouldMutate;

const appliedDiskBudget = await enforceSqliteSessionHistoryDiskBudget({

agentId: target.agentId,

storePath: target.storePath,

mode,

maintenance,

});

diskBudget: appliedDiskBudget,

removedSessionKeys.size > 0 ||

unreferencedArtifacts.removedFiles > 0 ||

(appliedDiskBudget?.removedEntries ?? 0) > 0 ||

(appliedDiskBudget?.removedFiles ?? 0) > 0 ||

// Checkpoint/incremental-vacuum reclamation mutates the store

// even when no session or archive was removed.

(appliedDiskBudget != null &&

appliedDiskBudget.totalBytesAfter < appliedDiskBudget.totalBytesBefore),

diskBudget: appliedDiskBudget,

(appliedDiskBudget?.removedEntries ?? 0) > 0 ||

(appliedDiskBudget?.removedFiles ?? 0) > 0 ||

// Checkpoint/incremental-vacuum reclamation mutates the store

// even when no session or archive was removed.

(appliedDiskBudget != null &&

appliedDiskBudget.totalBytesAfter < appliedDiskBudget.totalBytesBefore),

import {

enforceSessionDiskBudget,

measureSessionPhysicalDiskUsage,

pruneUnreferencedSessionArtifacts,

} from "./disk-budget.js";

import { resolveSqliteTargetFromSessionStorePath } from "./session-sqlite-target.js";

it("counts the SQLite main file and WAL as physical session usage", async () => {

await withTempDir({ prefix: "openclaw-disk-budget-sqlite-" }, async (dir) => {

const storePath = path.join(dir, "sessions.json");

const databasePath = resolveSqliteTargetFromSessionStorePath(storePath).path;

if (!databasePath) {

throw new Error("expected a SQLite database path");

}

await fs.writeFile(databasePath, Buffer.alloc(321));

await fs.writeFile(`${databasePath}-wal`, Buffer.alloc(654));

const usage = await measureSessionPhysicalDiskUsage(storePath);

expect(usage).toEqual({

databaseMainBytes: 321,

databaseWalBytes: 654,

sessionFilesBytes: 0,

totalBytes: 975,

});

});

});

it("excludes migration archives from physical SQLite usage (#106875)", async () => {

await withTempDir({ prefix: "openclaw-disk-budget-sqlite-" }, async (dir) => {

const storePath = path.join(dir, "sessions.json");

const databasePath = resolveSqliteTargetFromSessionStorePath(storePath).path;

if (!databasePath) {

throw new Error("expected a SQLite database path");

}

await fs.writeFile(databasePath, Buffer.alloc(100));

// Rollback archives are recovery artifacts outside the session budget;

// counting them would evict live history to pay for unreclaimable bytes.

await fs.writeFile(path.join(dir, "legacy.jsonl.migrated"), Buffer.alloc(4096));

await fs.writeFile(path.join(dir, "legacy.jsonl.migrated.2"), Buffer.alloc(4096));

const usage = await measureSessionPhysicalDiskUsage(storePath);

expect(usage.totalBytes).toBe(100);

expect(usage.sessionFilesBytes).toBe(0);

});

});

isRetainedSessionTranscriptArchiveName,

import { resolveSqliteTargetFromSessionStorePath } from "./session-sqlite-target.js";

export type SessionPhysicalDiskUsage = {

databaseMainBytes: number;

databaseWalBytes: number;

sessionFilesBytes: number;

totalBytes: number;

async function readSqliteDatabaseFiles(storePath: string): Promise<SessionsDirFileStat[]> {

const databasePath = resolveSqliteTargetFromSessionStorePath(storePath).path;

if (!databasePath) {

return [];

}

const files: SessionsDirFileStat[] = [];

for (const filePath of [databasePath, `${databasePath}-wal`]) {

const stat = await fs.promises.stat(filePath).catch(() => null);

if (!stat?.isFile()) {

continue;

}

files.push({

path: filePath,

canonicalPath: canonicalizePathForComparison(filePath),

name: path.basename(filePath),

size: stat.size,

mtimeMs: stat.mtimeMs,

});

}

return files;

export async function measureSessionPhysicalDiskUsage(

storePath: string,

): Promise<SessionPhysicalDiskUsage> {

const sessionsDirFiles = await readSessionsDirFiles(path.dirname(storePath));

const promptBlobFiles = await readSessionPromptBlobFiles(path.dirname(storePath));

const databaseFiles = await readSqliteDatabaseFiles(storePath);

const databasePath = resolveSqliteTargetFromSessionStorePath(storePath).path;

const databaseMainPath = databasePath ? canonicalizePathForComparison(databasePath) : undefined;

const databaseWalPath = databasePath

? canonicalizePathForComparison(`${databasePath}-wal`)

: undefined;

const uniqueFiles = new Map<string, SessionsDirFileStat>();

for (const file of [...sessionsDirFiles, ...promptBlobFiles, ...databaseFiles]) {

uniqueFiles.set(file.canonicalPath, file);

}

const databaseMainBytes = databaseMainPath ? (uniqueFiles.get(databaseMainPath)?.size ?? 0) : 0;

const databaseWalBytes = databaseWalPath ? (uniqueFiles.get(databaseWalPath)?.size ?? 0) : 0;

const totalBytes = [...uniqueFiles.values()].reduce((sum, file) => sum + file.size, 0);

return {

databaseMainBytes,

databaseWalBytes,

sessionFilesBytes: totalBytes - databaseMainBytes - databaseWalBytes,

totalBytes,

};

export async function hasRetainedSessionTranscriptArchives(storePath: string): Promise<boolean> {

const files = await readSessionsDirFiles(path.dirname(storePath));

return files.some((file) => isRetainedSessionTranscriptArchiveName(file.name));

export async function pruneSessionTranscriptArchivesToHighWater(params: {

highWaterBytes: number;

storePath: string;

}): Promise<{ removedFiles: number; usage: SessionPhysicalDiskUsage }> {

// Oldest-first is the hard-cap sacrifice order: under extreme pressure this

// may prune an archive the current pass just extracted, which is preferred

// over evicting additional sessions' searchable rows to spare a copy.

const files = (await readSessionsDirFiles(path.dirname(params.storePath)))

.filter((file) => isRetainedSessionTranscriptArchiveName(file.name))

.toSorted((left, right) => left.mtimeMs - right.mtimeMs);

let usage = await measureSessionPhysicalDiskUsage(params.storePath);

let removedFiles = 0;

for (const file of files) {

if (usage.totalBytes <= params.highWaterBytes) {

break;

}

if ((await removeFileIfExists(file.path)) <= 0) {

continue;

}

removedFiles += 1;

usage = await measureSessionPhysicalDiskUsage(params.storePath);

}

return { removedFiles, usage };