"src/auto-reply/reply/session-updates.ts",

"src/auto-reply/reply/session-usage.ts",

"src/tui/embedded-backend.ts",

"src/config/sessions/cleanup-service.ts",

]);

export const migratedTranscriptWriterFiles = new Set([

const writeSourceRoots = resolveSourceRoots(repoRoot, [

"src/agents",

"src/auto-reply",

"src/config/sessions",

"src/tui",

]);

const transcriptWriterSourceRoots = resolveSourceRoots(repoRoot, [

import { beforeEach, describe, expect, it, vi } from "vitest";

import type { OpenClawConfig } from "../types.openclaw.js";

import { purgeAgentSessionStoreEntries } from "./cleanup-service.js";

const sessionAccessorMocks = vi.hoisted(() => ({

applySessionEntryLifecycleMutation: vi.fn(async () => ({

removedEntries: 0,

removedSessionKeys: [],

archivedTranscriptDirectories: [],

unreferencedArtifacts: null,

maintenanceReport: null,

afterCount: 0,

})),

purgeDeletedAgentSessionEntries: vi.fn(async () => ({

removedEntries: 0,

removedSessionKeys: [],

archivedTranscriptDirectories: [],

unreferencedArtifacts: null,

maintenanceReport: null,

afterCount: 0,

})),

}));

vi.mock("./session-accessor.js", () => sessionAccessorMocks);

describe("purgeAgentSessionStoreEntries", () => {

beforeEach(() => {

vi.clearAllMocks();

});

it("purges deleted-agent entries through the storage boundary", async () => {

const cfg = {

session: { store: "/tmp/openclaw-agent-purge-sessions.json" },

agents: {

list: [

{ id: "main", workspace: "/workspace/main" },

{ id: "ops", workspace: "/workspace/ops" },

],

},

} satisfies OpenClawConfig;

await purgeAgentSessionStoreEntries(cfg, "ops");

expect(sessionAccessorMocks.purgeDeletedAgentSessionEntries).toHaveBeenCalledWith({

cfg,

agentId: "ops",

storeAgentId: "main",

storePath: "/tmp/openclaw-agent-purge-sessions.json",

});

expect(sessionAccessorMocks.applySessionEntryLifecycleMutation).not.toHaveBeenCalled();

});

});

import fs from "node:fs";

import path from "node:path";

import { resolveDefaultAgentId } from "../../agents/agent-scope.js";

import { resolveStoredSessionOwnerAgentId } from "../../gateway/session-store-key.js";

import { getLogger } from "../../logging/logger.js";

import { normalizeAgentId, parseAgentSessionKey } from "../../routing/session-key.js";

import type { OpenClawConfig } from "../types.openclaw.js";

} from "./paths.js";

import {

applySessionEntryLifecycleMutation,

purgeDeletedAgentSessionEntries,

type SessionEntryLifecycleRemoval,

} from "./session-accessor.js";

import { cloneSessionStoreRecord } from "./store-cache.js";

pruneStaleEntries,

type ResolvedSessionMaintenanceConfig,

} from "./store-maintenance.js";

import { loadSessionStore, updateSessionStore } from "./store.js";

import { loadSessionStore } from "./store.js";

import {

resolveSessionStoreTargets,

type SessionStoreTarget,

? normalizedAgentId

: normalizeAgentId(resolveDefaultAgentId(cfg));

const storePath = resolveStorePath(cfg.session?.store, { agentId: normalizedAgentId });

await updateSessionStore(storePath, (store) => {

for (const key of Object.keys(store)) {

if (

resolveStoredSessionOwnerAgentId({

cfg,

agentId: storeAgentId,

sessionKey: key,

}) === normalizedAgentId

) {

delete store[key];

}

}

await purgeDeletedAgentSessionEntries({

cfg,

agentId: normalizedAgentId,

storeAgentId,

storePath,

});

} catch (err) {

getLogger().debug("session store purge skipped during agent delete", err);

import path from "node:path";

import { afterEach, beforeEach, describe, expect, it } from "vitest";

import { onSessionTranscriptUpdate } from "../../sessions/transcript-events.js";

import type { OpenClawConfig } from "../types.openclaw.js";

import {

appendTranscriptMessage,

appendTranscriptEvent,

loadTranscriptEvents,

patchSessionEntry,

persistSessionTranscriptTurn,

purgeDeletedAgentSessionEntries,

publishTranscriptUpdate,

readSessionUpdatedAt,

replaceSessionEntry,

});

});

it("purges deleted-agent entries from the current locked store", async () => {

const cfg = {

session: { store: storePath },

agents: {

list: [

{ id: "main", workspace: path.join(tempDir, "main") },

{ id: "ops", workspace: path.join(tempDir, "ops") },

],

},

} satisfies OpenClawConfig;

const now = Date.now();

fs.writeFileSync(

storePath,

JSON.stringify({

main: { sessionId: "main-legacy", updatedAt: now },

"agent:ops:main": { sessionId: "ops-session", updatedAt: now },

}),

"utf8",

);

const result = await purgeDeletedAgentSessionEntries({

cfg,

agentId: "ops",

storeAgentId: "main",

storePath,

});

expect(result.removedSessionKeys).toEqual(["agent:ops:main"]);

expect(loadSessionStore(storePath)).toEqual({

main: expect.objectContaining({ sessionId: "main-legacy" }),

});

});

it("creates durable session ids for metadata-only inserts", async () => {

const scope = {

sessionKey: "agent:main:main",

loadSessionStore,

applySessionEntryPatchProjection as applyFileSessionEntryPatchProjection,

patchSessionEntry as patchFileSessionEntry,

purgeDeletedAgentSessionEntries as purgeFileDeletedAgentSessionEntries,

readSessionUpdatedAt as readFileSessionUpdatedAt,

resolveSessionStoreEntry,

resetSessionEntryLifecycle as resetFileSessionEntryLifecycle,

type DeleteSessionEntryLifecycleResult,

type ResetSessionEntryLifecycleMutation,

type ResetSessionEntryLifecycleResult,

type DeletedAgentSessionEntryPurgeParams,

type SessionArchivedTranscriptCleanupRule,

type SessionEntryLifecycleMutationResult,

type SessionEntryLifecycleRemoval,

};

export type {

DeletedAgentSessionEntryPurgeParams,

SessionArchivedTranscriptCleanupRule,

SessionEntryLifecycleMutationResult,

SessionEntryLifecycleRemoval,

return await applyFileSessionEntryLifecycleMutation(params);

}

/** Purges session entries owned by a deleted agent at the storage boundary. */

export async function purgeDeletedAgentSessionEntries(

params: DeletedAgentSessionEntryPurgeParams,

): Promise<SessionEntryLifecycleMutationResult> {

return await purgeFileDeletedAgentSessionEntries(params);

}

/** Reads parsed transcript records from an explicit or derived transcript target. */

export async function loadTranscriptEvents(

scope: SessionTranscriptReadScope,

normalizeOptionalString,

} from "@openclaw/normalization-core/string-coerce";

import type { MsgContext } from "../../auto-reply/templating.js";

import { resolveStoredSessionOwnerAgentId } from "../../gateway/session-store-key.js";

import { writeTextAtomic } from "../../infra/json-files.js";

import { createSubsystemLogger } from "../../logging/subsystem.js";

import { resolveAgentIdFromSessionKey } from "../../routing/session-key.js";

import type { DeliveryContext } from "../../utils/delivery-context.types.js";

import { getFileStatSnapshot } from "../cache-utils.js";

import { getRuntimeConfig } from "../io.js";

import type { OpenClawConfig } from "../types.openclaw.js";

import { formatSessionArchiveTimestamp } from "./artifacts.js";

import {

enforceSessionDiskBudget,

artifactCleanupError?: unknown;

};

export type DeletedAgentSessionEntryPurgeParams = {

/** Runtime config used to preserve legacy default-agent key ownership rules. */

cfg: OpenClawConfig;

/** Deleted agent whose session entries should be purged. */

agentId: string;

/** Agent id represented by the current store path for legacy unscoped keys. */

storeAgentId: string;

/** Resolved session store path to mutate. */

storePath: string;

};

function cloneSessionEntry(entry: SessionEntry): SessionEntry {

return cloneSessionStoreRecord({ entry }).entry;

}

};

}

/**

* Purges entries owned by a deleted agent while holding the store writer lock.

* This preserves the old delete-time current-store owner check without

* exposing a mutable whole-store callback to callers.

*/

export async function purgeDeletedAgentSessionEntries(

params: DeletedAgentSessionEntryPurgeParams,

): Promise<SessionEntryLifecycleMutationResult> {

const storePath = path.resolve(params.storePath);

const removedSessionKeys: string[] = [];

let maintenanceReport: SessionMaintenanceApplyReport | null = null;

let afterCount = 0;

await runExclusiveSessionStoreWrite(storePath, async () => {

const store = loadMutableSessionStoreForWriter(storePath);

for (const sessionKey of Object.keys(store)) {

const ownerAgentId = resolveStoredSessionOwnerAgentId({

cfg: params.cfg,

agentId: params.storeAgentId,

sessionKey,

});

if (ownerAgentId === params.agentId) {

delete store[sessionKey];

removedSessionKeys.push(sessionKey);

}

}

await saveSessionStoreUnlocked(storePath, store, {

onMaintenanceApplied: (report) => {

maintenanceReport = report;

},

});

afterCount = Object.keys(store).length;

});

return {

removedEntries: removedSessionKeys.length,

removedSessionKeys,

archivedTranscriptDirectories: [],

unreferencedArtifacts: null,

maintenanceReport,

afterCount,

};

}

async function archiveUnreferencedLifecycleTranscriptArtifacts(params: {

storePath: string;

transcriptContentMarker: string;

);

});

it("ratchets only the auto-reply files migrated to session accessor writes", () => {

it("ratchets only files migrated to session accessor writes", () => {

expect(migratedSessionAccessorWriteFiles).toEqual(

new Set([

"src/agents/command/attempt-execution.shared.ts",

"src/auto-reply/reply/session-updates.ts",

"src/auto-reply/reply/session-usage.ts",

"src/tui/embedded-backend.ts",

"src/config/sessions/cleanup-service.ts",

]),

);

});