opencode-graphiti 0.0.0-development

package/esm/src/session.js

@@ -0,0 +1,694 @@
+import { DEFAULT_CONTEXT_LIMIT } from "./services/constants.js";
+import { logger } from "./services/logger.js";
+import { PERSISTENT_MEMORY_BODY_BUDGET, } from "./services/redis-cache.js";
+import { escapeXml, normalizeMemoryText, renderXmlListSection, sanitizeMemoryInput, uniqueNormalizedValues, } from "./services/render-utils.js";
+import { getSessionEventPrimaryText, } from "./types/index.js";
+const findLatestUserRequest = (events) => {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.role !== "user")
+            continue;
+        const candidate = sanitizeMemoryInput(getSessionEventPrimaryText(event));
+        if (candidate)
+            return candidate;
+    }
+    return "";
+};
+const RECENT_BASELINE_LIMIT = 20;
+const RECALL_RESULT_LIMIT = 12;
+const EXPLICIT_NOT_FOUND_CODES = new Set([
+    "not_found",
+    "session_not_found",
+]);
+const asRecord = (value) => typeof value === "object" && value !== null
+    ? value
+    : null;
+const normalizeErrorToken = (value) => {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    return normalized.length > 0 ? normalized : null;
+};
+const isExplicitNotFoundCode = (value) => {
+    const normalized = normalizeErrorToken(value);
+    return normalized !== null && EXPLICIT_NOT_FOUND_CODES.has(normalized);
+};
+const isExplicitSessionNotFoundMessage = (value) => {
+    if (typeof value !== "string")
+        return false;
+    return /\bsession not found\b/i.test(value);
+};
+const isExplicitSessionNotFoundError = (error) => {
+    const queue = [error];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const record = asRecord(current);
+        if (!record)
+            continue;
+        if (visited.has(record))
+            continue;
+        visited.add(record);
+        const status = record.status;
+        const statusCode = record.statusCode;
+        if (status === 404 || statusCode === 404)
+            return true;
+        if (isExplicitNotFoundCode(record.code) ||
+            isExplicitNotFoundCode(record.errorCode) ||
+            isExplicitNotFoundCode(record.type) ||
+            isExplicitSessionNotFoundMessage(record.message)) {
+            return true;
+        }
+        queue.push(record.cause, record.data, record.body, record.error, record.response);
+    }
+    return false;
+};
+const mergeSessionEvents = (recentEvents, recalledEvents) => {
+    const merged = new Map();
+    for (const event of recentEvents) {
+        if (!merged.has(event.id))
+            merged.set(event.id, event);
+    }
+    for (const event of recalledEvents) {
+        if (!merged.has(event.id))
+            merged.set(event.id, event);
+    }
+    return [...merged.values()].sort((left, right) => {
+        if (left.ts !== right.ts)
+            return left.ts - right.ts;
+        return left.id.localeCompare(right.id);
+    });
+};
+const collectRecentUniqueValues = (events, collect, limit, excludedNormalized = new Set()) => uniqueNormalizedValues(events.flatMap((event) => {
+    const value = collect(event);
+    if (value === null || value === undefined)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}).reverse(), limit, excludedNormalized);
+const addNormalizedValues = (target, values) => {
+    for (const value of values) {
+        const normalized = normalizeMemoryText(value);
+        if (normalized)
+            target.add(normalized);
+    }
+};
+const filterDuplicateSnapshotLeaves = (snapshot, excludedNormalized) => {
+    if (!snapshot)
+        return "";
+    let filtered = snapshot.replace(/<([a-z_]+)>([^<>]*)<\/\1>/gi, (match, tag, text) => {
+        if (tag.toLowerCase() === "snapshot")
+            return match;
+        const normalized = normalizeMemoryText(text);
+        return normalized && excludedNormalized.has(normalized) ? "" : match;
+    });
+    filtered = filtered.replace(/<(?!snapshot\b)([a-z_]+)>\s*<\/\1>/gi, "");
+    return filtered;
+};
+const collectSectionValues = (events, predicate, limit, excludedNormalized = new Set()) => collectRecentUniqueValues(events, (event) => predicate(event)
+    ? sanitizeMemoryInput(getSessionEventPrimaryText(event))
+    : null, limit, excludedNormalized);
+const collectPathValues = (events, limit, excludedNormalized = new Set()) => collectRecentUniqueValues(events, (event) => event.category.startsWith("file.") ? event.refs ?? [] : [], limit, excludedNormalized);
+export class SessionManager {
+    constructor(defaultGroupId, defaultUserGroupId, sdkClient, redisEvents, redisSnapshot, redisCache, options = {}) {
+        Object.defineProperty(this, "defaultGroupId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: defaultGroupId
+        });
+        Object.defineProperty(this, "defaultUserGroupId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: defaultUserGroupId
+        });
+        Object.defineProperty(this, "sdkClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: sdkClient
+        });
+        Object.defineProperty(this, "redisEvents", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: redisEvents
+        });
+        Object.defineProperty(this, "redisSnapshot", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: redisSnapshot
+        });
+        Object.defineProperty(this, "redisCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: redisCache
+        });
+        Object.defineProperty(this, "sessions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "parentIdCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "canonicalSessionIdCache", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "temporaryRootSessionIds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "pendingAssistantMessages", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "pendingAssistantCompletions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Set()
+        });
+        Object.defineProperty(this, "bufferedAssistantMessageIds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "sessionLifecycles", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "idleRetentionMs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "setTimerImpl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "clearTimerImpl", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.idleRetentionMs = Math.max(0, options.idleRetentionMs ?? 0);
+        this.setTimerImpl = options.setTimer ??
+            ((callback, delayMs) => setTimeout(callback, delayMs));
+        this.clearTimerImpl = options.clearTimer ??
+            ((timer) => clearTimeout(timer));
+    }
+    createDefaultState(groupId, userGroupId) {
+        return {
+            groupId,
+            userGroupId,
+            injectedMemories: false,
+            messageCount: 0,
+            contextLimit: DEFAULT_CONTEXT_LIMIT,
+            isMain: true,
+            hotTierReady: false,
+            latestUserRequest: undefined,
+            latestRefreshQuery: undefined,
+            pendingInjection: undefined,
+            pendingInjectionGeneration: 0,
+        };
+    }
+    getState(sessionId) {
+        return this.sessions.get(sessionId);
+    }
+    setState(sessionId, state) {
+        this.sessions.set(sessionId, state);
+    }
+    markSessionActive(sessionId) {
+        this.markLifecycleActive(sessionId);
+        const canonicalSessionId = this.canonicalSessionIdCache.get(sessionId);
+        if (canonicalSessionId && canonicalSessionId !== sessionId) {
+            this.markLifecycleActive(canonicalSessionId);
+        }
+    }
+    markResolvedSessionActive(sessionId, canonicalSessionId) {
+        this.markLifecycleActive(sessionId);
+        if (canonicalSessionId && canonicalSessionId !== sessionId) {
+            this.markLifecycleActive(canonicalSessionId);
+        }
+    }
+    markLifecycleActive(sessionId) {
+        const lifecycle = this.getLifecycle(sessionId);
+        lifecycle.activityGeneration += 1;
+        if (lifecycle.idleCleanupTimer !== null) {
+            this.clearTimerImpl(lifecycle.idleCleanupTimer);
+            lifecycle.idleCleanupTimer = null;
+        }
+    }
+    captureIdleCleanupGeneration(sessionId) {
+        const state = this.sessions.get(sessionId);
+        if (!state?.isMain)
+            return null;
+        return this.getLifecycle(sessionId).activityGeneration;
+    }
+    scheduleIdleSessionCleanup(sessionId, expectedActivityGeneration) {
+        const state = this.sessions.get(sessionId);
+        if (!state?.isMain) {
+            this.deleteSession(sessionId);
+            return;
+        }
+        const lifecycle = this.getLifecycle(sessionId);
+        if (expectedActivityGeneration !== undefined &&
+            lifecycle.activityGeneration !== expectedActivityGeneration) {
+            return;
+        }
+        if (this.idleRetentionMs <= 0) {
+            this.deleteSession(sessionId);
+            return;
+        }
+        if (lifecycle.idleCleanupTimer !== null) {
+            this.clearTimerImpl(lifecycle.idleCleanupTimer);
+            lifecycle.idleCleanupTimer = null;
+        }
+        const activityGeneration = expectedActivityGeneration ??
+            lifecycle.activityGeneration;
+        const timerHandle = this.setTimerImpl(() => {
+            const currentLifecycle = this.sessionLifecycles.get(sessionId);
+            if (!currentLifecycle)
+                return;
+            if (currentLifecycle.idleCleanupTimer !== timerHandle)
+                return;
+            if (currentLifecycle.activityGeneration !== activityGeneration)
+                return;
+            this.deleteSession(sessionId);
+        }, this.idleRetentionMs);
+        lifecycle.idleCleanupTimer = timerHandle;
+    }
+    setParentId(sessionId, parentId) {
+        const wasTemporaryRoot = this.temporaryRootSessionIds.has(sessionId);
+        this.parentIdCache.set(sessionId, parentId);
+        if (!parentId) {
+            this.temporaryRootSessionIds.delete(sessionId);
+            this.canonicalSessionIdCache.set(sessionId, sessionId);
+            return;
+        }
+        const parentCanonical = this.canonicalSessionIdCache.get(parentId);
+        if (parentCanonical) {
+            this.canonicalSessionIdCache.set(sessionId, parentCanonical);
+            if (parentCanonical !== sessionId) {
+                this.migrateTemporaryRootRuntimeState(sessionId, parentCanonical);
+            }
+            if (wasTemporaryRoot) {
+                this.temporaryRootSessionIds.delete(sessionId);
+            }
+            return;
+        }
+        this.canonicalSessionIdCache.delete(sessionId);
+    }
+    mergeSessionState(target, source) {
+        target.injectedMemories ||= source.injectedMemories;
+        target.messageCount += source.messageCount;
+        target.contextLimit = Math.max(target.contextLimit, source.contextLimit);
+        target.isMain ||= source.isMain;
+        target.hotTierReady ||= source.hotTierReady;
+        if (source.latestUserRequest) {
+            target.latestUserRequest = source.latestUserRequest;
+        }
+        if (source.latestRefreshQuery) {
+            target.latestRefreshQuery = source.latestRefreshQuery;
+        }
+        if (source.pendingInjection !== undefined) {
+            target.pendingInjection = source.pendingInjection;
+        }
+        target.pendingInjectionGeneration = Math.max(target.pendingInjectionGeneration, source.pendingInjectionGeneration);
+    }
+    migrateTemporaryRootRuntimeState(sessionId, canonicalSessionId) {
+        if (sessionId === canonicalSessionId)
+            return;
+        const sourceState = this.sessions.get(sessionId);
+        const targetState = this.sessions.get(canonicalSessionId);
+        if (sourceState) {
+            if (targetState) {
+                this.mergeSessionState(targetState, sourceState);
+            }
+            else {
+                this.sessions.set(canonicalSessionId, sourceState);
+            }
+            this.sessions.delete(sessionId);
+        }
+        const sourceLifecycle = this.sessionLifecycles.get(sessionId);
+        const targetLifecycle = this.sessionLifecycles.get(canonicalSessionId);
+        if (sourceLifecycle) {
+            const targetIdleCleanupTimer = targetLifecycle?.idleCleanupTimer ?? null;
+            if (sourceLifecycle.idleCleanupTimer !== null) {
+                this.clearTimerImpl(sourceLifecycle.idleCleanupTimer);
+            }
+            if (targetIdleCleanupTimer !== null) {
+                this.clearTimerImpl(targetIdleCleanupTimer);
+            }
+            this.sessionLifecycles.set(canonicalSessionId, {
+                activityGeneration: Math.max(targetLifecycle?.activityGeneration ?? 0, sourceLifecycle.activityGeneration),
+                idleCleanupTimer: null,
+            });
+            this.sessionLifecycles.delete(sessionId);
+        }
+        const sessionPrefix = `${sessionId}:`;
+        for (const [key, buffered] of [...this.pendingAssistantMessages.entries()]) {
+            if (!key.startsWith(sessionPrefix))
+                continue;
+            const messageId = key.slice(sessionPrefix.length);
+            const canonicalKey = `${canonicalSessionId}:${messageId}`;
+            if (!this.pendingAssistantMessages.has(canonicalKey)) {
+                this.pendingAssistantMessages.set(canonicalKey, {
+                    ...buffered,
+                    sessionId: canonicalSessionId,
+                });
+            }
+            this.pendingAssistantMessages.delete(key);
+        }
+        for (const [key, sourceSessionId] of [...this.bufferedAssistantMessageIds
+                .entries()]) {
+            if (!key.startsWith(sessionPrefix))
+                continue;
+            const messageId = key.slice(sessionPrefix.length);
+            const canonicalKey = `${canonicalSessionId}:${messageId}`;
+            if (!this.bufferedAssistantMessageIds.has(canonicalKey)) {
+                this.bufferedAssistantMessageIds.set(canonicalKey, sourceSessionId);
+            }
+            this.bufferedAssistantMessageIds.delete(key);
+        }
+        for (const key of [...this.pendingAssistantCompletions]) {
+            if (!key.startsWith(sessionPrefix))
+                continue;
+            const messageId = key.slice(sessionPrefix.length);
+            this.pendingAssistantCompletions.add(`${canonicalSessionId}:${messageId}`);
+            this.pendingAssistantCompletions.delete(key);
+        }
+        for (const [cachedSessionId, cachedCanonicalSessionId] of [
+            ...this.canonicalSessionIdCache.entries(),
+        ]) {
+            if (cachedCanonicalSessionId === sessionId) {
+                this.canonicalSessionIdCache.set(cachedSessionId, canonicalSessionId);
+            }
+        }
+    }
+    async resolveParentId(sessionId) {
+        if (this.parentIdCache.has(sessionId)) {
+            return this.parentIdCache.get(sessionId) ?? null;
+        }
+        try {
+            const response = await this.sdkClient.session.get({
+                path: { id: sessionId },
+            });
+            const sessionInfo = typeof response === "object" && response !== null &&
+                "data" in response
+                ? response.data
+                : response;
+            if (!sessionInfo)
+                return undefined;
+            const parentId = sessionInfo.parentID ?? null;
+            this.parentIdCache.set(sessionId, parentId);
+            return parentId;
+        }
+        catch (err) {
+            if (isExplicitSessionNotFoundError(err)) {
+                this.parentIdCache.set(sessionId, null);
+                this.canonicalSessionIdCache.set(sessionId, sessionId);
+                this.temporaryRootSessionIds.add(sessionId);
+                logger.debug("Session not found during parent resolution; treating as temporary root", { sessionId });
+                return null;
+            }
+            logger.debug("Failed to resolve session parentID", { sessionId, err });
+            return undefined;
+        }
+    }
+    async resolveCanonicalSessionId(sessionId, visited = new Set()) {
+        const cached = this.canonicalSessionIdCache.get(sessionId);
+        if (cached)
+            return cached;
+        if (visited.has(sessionId)) {
+            logger.debug("Detected cycle while resolving canonical session", {
+                sessionId,
+                visited: [...visited],
+            });
+            return undefined;
+        }
+        visited.add(sessionId);
+        const parentId = await this.resolveParentId(sessionId);
+        if (parentId === undefined)
+            return undefined;
+        if (!parentId) {
+            this.canonicalSessionIdCache.set(sessionId, sessionId);
+            return sessionId;
+        }
+        const canonicalSessionId = await this.resolveCanonicalSessionId(parentId, visited);
+        if (!canonicalSessionId)
+            return undefined;
+        if (canonicalSessionId !== sessionId) {
+            this.migrateTemporaryRootRuntimeState(sessionId, canonicalSessionId);
+            this.temporaryRootSessionIds.delete(sessionId);
+        }
+        this.canonicalSessionIdCache.set(sessionId, canonicalSessionId);
+        return canonicalSessionId;
+    }
+    async resolveSessionState(sessionId) {
+        const canonicalSessionId = await this.resolveCanonicalSessionId(sessionId);
+        if (!canonicalSessionId) {
+            return { state: null, resolved: false, canonicalSessionId: undefined };
+        }
+        let state = this.sessions.get(canonicalSessionId);
+        if (!state) {
+            state = this.createDefaultState(this.defaultGroupId, this.defaultUserGroupId);
+            this.sessions.set(canonicalSessionId, state);
+        }
+        return { state, resolved: true, canonicalSessionId };
+    }
+    bufferAssistantPart(sessionId, messageId, text, sourceSessionId = sessionId) {
+        const key = `${sessionId}:${messageId}`;
+        this.pendingAssistantMessages.set(key, {
+            sessionId,
+            text,
+            sourceSessionId,
+        });
+    }
+    isAssistantBuffered(sessionId, messageId) {
+        return this.bufferedAssistantMessageIds.has(`${sessionId}:${messageId}`);
+    }
+    hasPendingAssistantCompletion(sessionId, messageId) {
+        return this.pendingAssistantCompletions.has(`${sessionId}:${messageId}`);
+    }
+    finalizeAssistantMessage(_state, sessionId, messageId, source) {
+        const key = `${sessionId}:${messageId}`;
+        if (this.bufferedAssistantMessageIds.has(key))
+            return null;
+        const buffered = this.pendingAssistantMessages.get(key);
+        const messageText = buffered?.text?.trim() ?? "";
+        if (!messageText) {
+            this.pendingAssistantCompletions.add(key);
+            return null;
+        }
+        this.pendingAssistantCompletions.delete(key);
+        this.pendingAssistantMessages.delete(key);
+        this.bufferedAssistantMessageIds.set(key, buffered?.sourceSessionId ?? sessionId);
+        logger.info("Assistant message completed", {
+            hook: source,
+            sessionId,
+            messageID: messageId,
+            messageLength: messageText.length,
+        });
+        return messageText;
+    }
+    deletePendingAssistant(sessionId, messageId) {
+        const key = `${sessionId}:${messageId}`;
+        this.pendingAssistantMessages.delete(key);
+        this.pendingAssistantCompletions.delete(key);
+    }
+    clearPendingInjection(state, prepared) {
+        if (!prepared)
+            return;
+        if (state.pendingInjection === prepared) {
+            state.pendingInjection = undefined;
+        }
+    }
+    purgeAssistantBufferSource(sourceSessionId) {
+        for (const [key, buffered] of [...this.pendingAssistantMessages.entries()]) {
+            if (buffered.sourceSessionId === sourceSessionId) {
+                this.pendingAssistantMessages.delete(key);
+                this.pendingAssistantCompletions.delete(key);
+            }
+        }
+        for (const [key, bufferedSourceSessionId] of [
+            ...this.bufferedAssistantMessageIds.entries(),
+        ]) {
+            if (bufferedSourceSessionId === sourceSessionId) {
+                this.bufferedAssistantMessageIds.delete(key);
+            }
+        }
+    }
+    async prepareInjection(sessionId, lastRequest) {
+        const state = this.sessions.get(sessionId);
+        if (!state?.isMain)
+            return null;
+        const generation = state.pendingInjectionGeneration + 1;
+        state.pendingInjectionGeneration = generation;
+        const [recentEvents, snapshot, cache, cacheMeta] = await Promise.all([
+            this.redisEvents.getRecentSessionEvents(sessionId, RECENT_BASELINE_LIMIT, true),
+            this.redisSnapshot.getSnapshot(sessionId),
+            this.redisCache.get(state.groupId),
+            this.redisCache.getMeta(state.groupId),
+        ]);
+        const canonicalLatestRequest = sanitizeMemoryInput(state.latestUserRequest ?? "");
+        const directFallbackRequest = sanitizeMemoryInput(lastRequest ?? "");
+        const cachedFallbackRequest = sanitizeMemoryInput(state.latestRefreshQuery ?? cacheMeta?.lastQuery ?? "");
+        const historyFallbackRequest = findLatestUserRequest(recentEvents);
+        const latestRequest = canonicalLatestRequest || directFallbackRequest ||
+            cachedFallbackRequest || historyFallbackRequest;
+        const recalledEvents = latestRequest
+            ? await this.redisEvents.recallSessionEvents(sessionId, latestRequest, {
+                resultLimit: RECALL_RESULT_LIMIT,
+            })
+            : [];
+        const events = mergeSessionEvents(recentEvents, recalledEvents);
+        const occupiedNormalized = new Set();
+        const normalizedLatestRequest = normalizeMemoryText(latestRequest);
+        if (normalizedLatestRequest) {
+            occupiedNormalized.add(normalizedLatestRequest);
+        }
+        const activeTasks = collectSectionValues(events, (event) => ["task.create", "task.update", "task.complete"].includes(event.category), 4, occupiedNormalized);
+        addNormalizedValues(occupiedNormalized, activeTasks);
+        const decisions = collectSectionValues(events, (event) => ["decision", "preference"].includes(event.category), 5, occupiedNormalized);
+        addNormalizedValues(occupiedNormalized, decisions);
+        const files = collectPathValues(events, 6, occupiedNormalized);
+        addNormalizedValues(occupiedNormalized, files);
+        const rules = collectSectionValues(events, (event) => event.category === "rule.load", 6, occupiedNormalized);
+        addNormalizedValues(occupiedNormalized, rules);
+        const unresolvedErrors = collectRecentUniqueValues(events, (event) => event.category === "error" && event.metadata?.resolved !== true &&
+            event.role !== "assistant"
+            ? sanitizeMemoryInput(getSessionEventPrimaryText(event))
+            : null, 4, occupiedNormalized);
+        addNormalizedValues(occupiedNormalized, unresolvedErrors);
+        const gitState = collectSectionValues(events, (event) => event.category === "git.activity", 4, occupiedNormalized);
+        addNormalizedValues(occupiedNormalized, gitState);
+        const subagentWork = collectSectionValues(events, (event) => event.category === "subagent.start" ||
+            event.category === "subagent.finish", 4, occupiedNormalized);
+        addNormalizedValues(occupiedNormalized, subagentWork);
+        const filteredSnapshot = filterDuplicateSnapshotLeaves(snapshot, occupiedNormalized);
+        const persistent = this.redisCache.renderPersistentMemory(cache, PERSISTENT_MEMORY_BODY_BUDGET);
+        const refreshDecision = this.redisCache.classifyRefresh(cache, latestRequest);
+        const sections = [
+            `<last_request>${escapeXml(latestRequest)}</last_request>`,
+            renderXmlListSection("active_tasks", "task", activeTasks, { itemCharLimit: 280, includeEmpty: true }),
+            renderXmlListSection("key_decisions", "decision", decisions, {
+                itemCharLimit: 280,
+                includeEmpty: true,
+            }),
+            renderXmlListSection("files_in_play", "file", files, {
+                itemCharLimit: 280,
+                includeEmpty: true,
+            }),
+            renderXmlListSection("project_rules", "rule", rules, {
+                itemCharLimit: 280,
+                includeEmpty: true,
+            }),
+            unresolvedErrors.length > 0
+                ? renderXmlListSection("unresolved_errors", "error", unresolvedErrors, {
+                    itemCharLimit: 280,
+                })
+                : "",
+            gitState.length > 0
+                ? renderXmlListSection("git_state", "item", gitState, {
+                    itemCharLimit: 280,
+                })
+                : "",
+            subagentWork.length > 0
+                ? renderXmlListSection("subagent_work", "item", subagentWork, {
+                    itemCharLimit: 280,
+                })
+                : "",
+            filteredSnapshot
+                ? `<session_snapshot>${filteredSnapshot}</session_snapshot>`
+                : "",
+            persistent.body
+                ? `<persistent_memory node_refs="${escapeXml(persistent.nodeRefs.join(","))}">${persistent.body}</persistent_memory>`
+                : "",
+        ].filter(Boolean);
+        const envelope = `<session_memory source="falkordb+graphiti-cache" version="1">${sections.join("")}</session_memory>`;
+        const prepared = {
+            envelope,
+            nodeRefs: persistent.nodeRefs,
+            refreshDecision,
+        };
+        const currentState = this.sessions.get(sessionId);
+        if (currentState !== state || !currentState.isMain)
+            return null;
+        if (state.pendingInjectionGeneration !== generation)
+            return null;
+        state.pendingInjection = prepared;
+        state.hotTierReady = true;
+        state.latestRefreshQuery = latestRequest || cacheMeta?.lastQuery;
+        return prepared;
+    }
+    deleteSession(sessionId) {
+        const lifecycle = this.sessionLifecycles.get(sessionId);
+        if (lifecycle?.idleCleanupTimer != null) {
+            this.clearTimerImpl(lifecycle.idleCleanupTimer);
+        }
+        this.sessionLifecycles.delete(sessionId);
+        this.sessions.delete(sessionId);
+        this.parentIdCache.delete(sessionId);
+        this.canonicalSessionIdCache.delete(sessionId);
+        this.temporaryRootSessionIds.delete(sessionId);
+        for (const [childSessionId, parentId] of [...this.parentIdCache.entries()]) {
+            if (parentId === sessionId)
+                this.parentIdCache.delete(childSessionId);
+        }
+        for (const [childSessionId, canonicalSessionId] of [
+            ...this.canonicalSessionIdCache.entries(),
+        ]) {
+            if (canonicalSessionId === sessionId) {
+                this.canonicalSessionIdCache.delete(childSessionId);
+            }
+        }
+        const prefix = `${sessionId}:`;
+        for (const key of [...this.pendingAssistantMessages.keys()]) {
+            if (key.startsWith(prefix)) {
+                this.pendingAssistantMessages.delete(key);
+                this.pendingAssistantCompletions.delete(key);
+            }
+        }
+        for (const [key] of [...this.bufferedAssistantMessageIds.entries()]) {
+            if (key.startsWith(prefix))
+                this.bufferedAssistantMessageIds.delete(key);
+        }
+        for (const key of [...this.pendingAssistantCompletions]) {
+            if (key.startsWith(prefix))
+                this.pendingAssistantCompletions.delete(key);
+        }
+    }
+    getLifecycle(sessionId) {
+        let lifecycle = this.sessionLifecycles.get(sessionId);
+        if (!lifecycle) {
+            lifecycle = {
+                activityGeneration: 0,
+                idleCleanupTimer: null,
+            };
+            this.sessionLifecycles.set(sessionId, lifecycle);
+        }
+        return lifecycle;
+    }
+}