]);

export const migratedSessionAccessorFiles = new Set([

"src/agents/embedded-agent-runner/compaction-successor-transcript.ts",

"src/agents/embedded-agent-runner/tool-result-truncation.ts",

"src/agents/embedded-agent-runner/transcript-rewrite.ts",

"src/agents/embedded-agent-runner/transcript-runtime-state.ts",

"src/commands/export-trajectory.ts",

"src/commands/health.ts",

"src/commands/sandbox-explain.ts",

"src/config/sessions/combined-store-gateway.ts",

"src/cron/isolated-agent/delivery-target.ts",

"src/cron/service/timer.ts",

"src/gateway/session-compaction-checkpoints.ts",

"src/gateway/session-utils.ts",

"src/gateway/sessions-resolve.ts",

"src/gateway/server-methods/sessions.ts",

const sourceRoots = resolveSourceRoots(repoRoot, [

"extensions/discord/src/monitor",

"extensions/telegram/src",

"src/agents/embedded-agent-runner",

"src/commands",

"src/config/sessions",

"src/cron",

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

import { makeAgentAssistantMessage } from "../test-helpers/agent-message-fixtures.js";

import {

rotateRuntimeTranscriptAfterCompaction,

rotateTranscriptAfterCompaction,

rotateTranscriptFileAfterCompaction,

shouldRotateCompactionTranscript,

}

describe("rotateTranscriptAfterCompaction", () => {

it("does not create session metadata for missing runtime transcripts", async () => {

const dir = await createTmpDir();

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

await fs.writeFile(storePath, "{}\n", "utf8");

const result = await rotateRuntimeTranscriptAfterCompaction({

scope: {

agentId: "main",

sessionId: "missing-session",

sessionKey: "agent:main:missing",

storePath,

},

});

expect(result.rotated).toBe(false);

expect(await fs.readFile(storePath, "utf8")).toBe("{}\n");

});

it("can rotate a persisted transcript without opening a manager", async () => {

const dir = await createTmpDir();

const { sessionFile } = createCompactedSession(dir);

TranscriptFileState,

writeTranscriptFileAtomic,

} from "./transcript-file-state.js";

import {

resolveRuntimeTranscriptReadTarget,

type RuntimeTranscriptScope,

} from "./transcript-runtime-state.js";

type ReadonlySessionManagerForRotation = Pick<

TranscriptFileState,

});

}

/**

* Rotates a runtime transcript after compaction using agent/session identity.

*/

export async function rotateRuntimeTranscriptAfterCompaction(params: {

sessionManager?: ReadonlySessionManagerForRotation;

scope: RuntimeTranscriptScope;

now?: () => Date;

}): Promise<CompactionTranscriptRotation> {

const target = await resolveRuntimeTranscriptReadTarget(params.scope);

let sessionManager = params.sessionManager;

if (!sessionManager) {

try {

sessionManager = await readTranscriptFileState(target.sessionFile);

} catch (err) {

if ((err as NodeJS.ErrnoException).code === "ENOENT") {

return { rotated: false, reason: "missing session file" };

}

throw err;

}

}

return await rotateTranscriptAfterCompaction({

sessionManager,

sessionFile: target.sessionFile,

...(params.now ? { now: params.now } : {}),

});

}

function findLatestCompactionIndex(entries: SessionEntry[]): number {

for (let index = entries.length - 1; index >= 0; index -= 1) {

if (entries[index]?.type === "compaction") {

let resolveAutoLiveToolResultMaxChars: typeof import("./tool-result-truncation.js").resolveAutoLiveToolResultMaxChars;

let getToolResultTextLength: typeof import("./tool-result-truncation.js").getToolResultTextLength;

let truncateOversizedToolResultsInMessages: typeof import("./tool-result-truncation.js").truncateOversizedToolResultsInMessages;

let truncateOversizedToolResultsInRuntimeTranscript: typeof import("./tool-result-truncation.js").truncateOversizedToolResultsInRuntimeTranscript;

let truncateOversizedToolResultsInSession: typeof import("./tool-result-truncation.js").truncateOversizedToolResultsInSession;

let isOversizedToolResult: typeof import("./tool-result-truncation.js").isOversizedToolResult;

let sessionLikelyHasOversizedToolResults: typeof import("./tool-result-truncation.js").sessionLikelyHasOversizedToolResults;

resolveAutoLiveToolResultMaxChars,

getToolResultTextLength,

truncateOversizedToolResultsInMessages,

truncateOversizedToolResultsInRuntimeTranscript,

truncateOversizedToolResultsInSession,

isOversizedToolResult,

sessionLikelyHasOversizedToolResults,

});

describe("truncateOversizedToolResultsInSession", () => {

it("does not create session metadata for missing runtime transcripts", async () => {

const dir = await createTmpDir();

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

await fs.writeFile(storePath, "{}\n", "utf8");

const result = await truncateOversizedToolResultsInRuntimeTranscript({

scope: {

agentId: "main",

sessionId: "missing-session",

sessionKey: "agent:main:missing",

storePath,

},

contextWindowTokens: 100,

});

expect(result.truncated).toBe(false);

expect(await fs.readFile(storePath, "utf8")).toBe("{}\n");

});

it("readably truncates aggregate medium tool results in a session file", async () => {

// Persisted truncation rewrites JSONL directly and emits the transcript

// update event instead of reopening through SessionManager internals.

rewriteTranscriptEntriesInSessionManager,

rewriteTranscriptEntriesInState,

} from "./transcript-rewrite.js";

import {

resolveRuntimeTranscriptReadTarget,

type RuntimeTranscriptScope,

} from "./transcript-runtime-state.js";

/**

* Maximum share of the context window a single tool result should occupy.

}

}

/**

* Truncates oversized tool results for a runtime transcript scope.

*/

export async function truncateOversizedToolResultsInRuntimeTranscript(params: {

scope: RuntimeTranscriptScope;

contextWindowTokens: number;

maxCharsOverride?: number;

aggregateMaxCharsOverride?: number;

config?: SessionWriteLockAcquireTimeoutConfig;

}): Promise<{ truncated: boolean; truncatedCount: number; reason?: string }> {

let sessionLock: Awaited<ReturnType<typeof acquireSessionWriteLock>> | undefined;

try {

const target = await resolveRuntimeTranscriptReadTarget(params.scope);

sessionLock = await acquireSessionWriteLock({

sessionFile: target.sessionFile,

...resolveSessionWriteLockOptions(params.config),

});

const state = await readTranscriptFileState(target.sessionFile);

return await truncateOversizedToolResultsInTranscriptState({

state,

contextWindowTokens: params.contextWindowTokens,

maxCharsOverride: params.maxCharsOverride,

aggregateMaxCharsOverride: params.aggregateMaxCharsOverride,

sessionFile: target.sessionFile,

sessionId: target.sessionId,

sessionKey: target.sessionKey,

agentId: target.agentId,

config: params.config,

});

} catch (err) {

const errMsg = formatErrorMessage(err);

log.warn(`[tool-result-truncation] Failed to truncate: ${errMsg}`);

return { truncated: false, truncatedCount: 0, reason: errMsg };

} finally {

await sessionLock?.release();

}

}

/**

* Truncates a named transcript file artifact. Runtime callers should prefer

* truncateOversizedToolResultsInRuntimeTranscript with agent/session scope.

*/

export async function truncateOversizedToolResultsInSession(params: {

sessionFile: string;

contextWindowTokens: number;

let rewriteTranscriptEntriesInSessionFile: typeof import("./transcript-rewrite.js").rewriteTranscriptEntriesInSessionFile;

let rewriteTranscriptEntriesInSessionManager: typeof import("./transcript-rewrite.js").rewriteTranscriptEntriesInSessionManager;

let rewriteTranscriptEntriesInRuntimeTranscript: typeof import("./transcript-rewrite.js").rewriteTranscriptEntriesInRuntimeTranscript;

let onSessionTranscriptUpdate: typeof import("../../sessions/transcript-events.js").onSessionTranscriptUpdate;

let installSessionToolResultGuard: typeof import("../session-tool-result-guard.js").installSessionToolResultGuard;

beforeAll(async () => {

({ onSessionTranscriptUpdate } = await import("../../sessions/transcript-events.js"));

({ installSessionToolResultGuard } = await import("../session-tool-result-guard.js"));

({ rewriteTranscriptEntriesInSessionFile, rewriteTranscriptEntriesInSessionManager } =

await import("./transcript-rewrite.js"));

({

rewriteTranscriptEntriesInRuntimeTranscript,

rewriteTranscriptEntriesInSessionFile,

rewriteTranscriptEntriesInSessionManager,

} = await import("./transcript-rewrite.js"));

});

beforeEach(() => {

});

describe("rewriteTranscriptEntriesInSessionFile", () => {

it("does not create session metadata for missing runtime transcripts", async () => {

const dir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-transcript-rewrite-runtime-"));

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

await fs.writeFile(storePath, "{}\n", "utf8");

const result = await rewriteTranscriptEntriesInRuntimeTranscript({

scope: {

agentId: "main",

sessionId: "missing-session",

sessionKey: "agent:main:missing",

storePath,

},

request: { replacements: [] },

});

expect(result.changed).toBe(false);

expect(await fs.readFile(storePath, "utf8")).toBe("{}\n");

});

it("aborts under the write lock when the active suffix contains an unexpected entry", async () => {

const dir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-transcript-rewrite-guard-"));

const sessionManager = SessionManager.create(dir, dir);

readTranscriptFileState,

type TranscriptFileState,

} from "./transcript-file-state.js";

import {

persistRuntimeTranscriptStateMutation,

resolveRuntimeTranscriptReadTarget,

type RuntimeTranscriptScope,

} from "./transcript-runtime-state.js";

type SessionManagerLike = ReturnType<typeof SessionManager.open>;

type SessionBranchEntry = ReturnType<SessionManagerLike["getBranch"]>[number];

}

/**

* Open a transcript file, rewrite message entries on the active branch, and

* emit a transcript update when the active branch changed.

* Rewrites message entries for a runtime transcript without using the

* file-backed path as caller identity.

*/

export async function rewriteTranscriptEntriesInRuntimeTranscript(params: {

scope: RuntimeTranscriptScope;

request: TranscriptRewriteRequest;

config?: SessionWriteLockAcquireTimeoutConfig;

}): Promise<TranscriptRewriteResult> {

let sessionLock: Awaited<ReturnType<typeof acquireSessionWriteLock>> | undefined;

try {

const target = await resolveRuntimeTranscriptReadTarget(params.scope);

sessionLock = await acquireSessionWriteLock({

sessionFile: target.sessionFile,

...resolveSessionWriteLockOptions(params.config),

});

const state = await readTranscriptFileState(target.sessionFile);

const result = rewriteTranscriptEntriesInState({

state,

replacements: params.request.replacements,

...(params.request.allowedRewriteSuffixEntryIds

? { allowedRewriteSuffixEntryIds: params.request.allowedRewriteSuffixEntryIds }

: {}),

});

if (result.changed) {

await persistRuntimeTranscriptStateMutation({

target,

state,

appendedEntries: result.appendedEntries,

});

emitSessionTranscriptUpdate({

sessionFile: target.sessionFile,

sessionKey: target.sessionKey,

agentId: target.agentId,

});

log.info(

`[transcript-rewrite] rewrote ${result.rewrittenEntries} entr` +

`${result.rewrittenEntries === 1 ? "y" : "ies"} ` +

`bytesFreed=${result.bytesFreed} ` +

`sessionKey=${target.sessionKey}`,

);

}

return result;

} catch (err) {

const reason = formatErrorMessage(err);

log.warn(`[transcript-rewrite] failed: ${reason}`);

return {

changed: false,

bytesFreed: 0,

rewrittenEntries: 0,

reason,

};

} finally {

await sessionLock?.release();

}

}

/**

* Rewrites a named transcript file artifact. Runtime callers should prefer

* rewriteTranscriptEntriesInRuntimeTranscript with agent/session scope.

*/

export async function rewriteTranscriptEntriesInSessionFile(params: {

sessionFile: string;