import { resolveGlobalMap } from "openclaw/plugin-sdk/global-singleton";

import { resolveStateDir } from "openclaw/plugin-sdk/memory-core-host-runtime-core";

import { getRuntimeConfig } from "openclaw/plugin-sdk/runtime-config-snapshot";

import { pathExists } from "openclaw/plugin-sdk/security-runtime";

import {

loadSessionStore,

resolveStorePath,

updateSessionStore,

} from "openclaw/plugin-sdk/session-store-runtime";

import { cleanupSessionLifecycleArtifacts } from "openclaw/plugin-sdk/session-store-runtime";

import { readDreamsFile, resolveDreamsPath, updateDreamsFile } from "./dreaming-dreams-file.js";

// ── Types ──────────────────────────────────────────────────────────────

const DREAMING_SESSION_KEY_PREFIX = "dreaming-narrative-";

const DREAMING_TRANSCRIPT_RUN_MARKER = '"runId":"dreaming-narrative-';

const DREAMING_ORPHAN_MIN_AGE_MS = 300_000;

const SAFE_SESSION_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;

const DIARY_START_MARKER = "<!-- openclaw:dreaming:diary:start -->";

const DIARY_END_MARKER = "<!-- openclaw:dreaming:diary:end -->";

const BACKFILL_ENTRY_MARKER = "openclaw:dreaming:backfill-entry";

// ── Orchestrator ───────────────────────────────────────────────────────

function normalizeComparablePath(pathname: string): string {

return process.platform === "win32" ? pathname.toLowerCase() : pathname;

}

async function normalizeSessionFileForComparison(params: {

sessionsDir: string;

sessionFile: string;

}): Promise<string | null> {

const trimmed = params.sessionFile.trim();

if (!trimmed) {

return null;

}

const resolved = path.isAbsolute(trimmed) ? trimmed : path.resolve(params.sessionsDir, trimmed);

try {

return normalizeComparablePath(await fs.realpath(resolved));

} catch {

return normalizeComparablePath(path.resolve(resolved));

}

}

function isDreamingSessionStoreKey(sessionKey: string): boolean {

const firstSeparator = sessionKey.indexOf(":");

if (firstSeparator < 0) {

return sessionKey.startsWith(DREAMING_SESSION_KEY_PREFIX);

}

const secondSeparator = sessionKey.indexOf(":", firstSeparator + 1);

const sessionSegment = secondSeparator < 0 ? sessionKey : sessionKey.slice(secondSeparator + 1);

return sessionSegment.startsWith(DREAMING_SESSION_KEY_PREFIX);

}

// A dreaming store row is reclaimable once its narrative run is finished. The

// happy path deletes the session in `finally`, but when `deleteSession` throws

// (e.g. request-scoped subagent runtime) the row is left behind referencing a

// still-present transcript, so the missing-transcript check alone never reaps

// it and the session lingers in the sidebar forever (issue #88322). Reclaim a

// dreaming row when its transcript is missing, or when the transcript has aged

// past the orphan threshold (a live narrative refreshes its transcript well

// within that window, so active runs are never reaped).

async function isReclaimableDreamingStoreEntry(

normalizedSessionFile: string | null,

): Promise<boolean> {

if (!normalizedSessionFile || !(await pathExists(normalizedSessionFile))) {

return true;

}

try {

const stat = await fs.stat(normalizedSessionFile);

return Date.now() - stat.mtimeMs >= DREAMING_ORPHAN_MIN_AGE_MS;

} catch {

return true;

}

}

async function normalizeSessionEntryPathForComparison(params: {

sessionsDir: string;

entry: { sessionFile?: string; sessionId?: string } | undefined;

}): Promise<string | null> {

const sessionFile = typeof params.entry?.sessionFile === "string" ? params.entry.sessionFile : "";

if (sessionFile) {

return normalizeSessionFileForComparison({

sessionsDir: params.sessionsDir,

sessionFile,

});

}

const sessionId =

typeof params.entry?.sessionId === "string" ? params.entry.sessionId.trim() : "";

if (!SAFE_SESSION_ID_RE.test(sessionId)) {

return null;

}

return normalizeSessionFileForComparison({

sessionsDir: params.sessionsDir,

sessionFile: `${sessionId}.jsonl`,

});

}

async function scrubDreamingNarrativeArtifacts(logger: Logger): Promise<void> {

const cfg = getRuntimeConfig();

const agentsDir = path.join(resolveStateDir(), "agents");

continue;

}

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

const sessionsDir = path.dirname(storePath);

let store: Record<string, { sessionFile?: string; sessionId?: string } | undefined>;

try {

store = loadSessionStore(storePath) as Record<

string,

{ sessionFile?: string; sessionId?: string } | undefined

>;

} catch {

continue;

}

const referencedSessionFiles = new Set<string>();

let needsStoreUpdate = false;

for (const [key, entry] of Object.entries(store)) {

const normalizedSessionFile = await normalizeSessionEntryPathForComparison({

sessionsDir,

entry,

const result = await cleanupSessionLifecycleArtifacts({

agentId: agentEntry.name,

archiveRemovedEntryTranscripts: false,

sessionStore: cfg.session?.store,

sessionKeySegmentPrefix: DREAMING_SESSION_KEY_PREFIX,

transcriptContentMarker: DREAMING_TRANSCRIPT_RUN_MARKER,

orphanTranscriptMinAgeMs: DREAMING_ORPHAN_MIN_AGE_MS,

});

if (normalizedSessionFile) {

referencedSessionFiles.add(normalizedSessionFile);

}

if (!isDreamingSessionStoreKey(key)) {

continue;

}

if (await isReclaimableDreamingStoreEntry(normalizedSessionFile)) {

needsStoreUpdate = true;

}

}

if (needsStoreUpdate) {

referencedSessionFiles.clear();

prunedEntries += await updateSessionStore(storePath, async (lockedStore) => {

let prunedForAgent = 0;

for (const [key, entry] of Object.entries(lockedStore)) {

const normalizedSessionFile = await normalizeSessionEntryPathForComparison({

sessionsDir,

entry,

});

if (!isDreamingSessionStoreKey(key)) {

if (normalizedSessionFile) {

referencedSessionFiles.add(normalizedSessionFile);

}

continue;

}

if (await isReclaimableDreamingStoreEntry(normalizedSessionFile)) {

// Drop the row and leave the transcript unreferenced so the orphan

// transcript pass below archives the aged-out (or missing) file.

delete lockedStore[key];

prunedForAgent += 1;

continue;

}

if (normalizedSessionFile) {

referencedSessionFiles.add(normalizedSessionFile);

}

}

return prunedForAgent;

});

}

let sessionFiles: Dirent[];

try {

sessionFiles = await fs.readdir(sessionsDir, { withFileTypes: true });

prunedEntries += result.removedEntries;

archivedOrphans += result.archivedTranscriptArtifacts;

} catch {

continue;

}

for (const fileEntry of sessionFiles) {

if (!fileEntry.isFile() || !fileEntry.name.endsWith(".jsonl")) {

continue;

}

const transcriptPath = path.join(sessionsDir, fileEntry.name);

const normalizedTranscriptPath =

(await normalizeSessionFileForComparison({

sessionsDir,

sessionFile: fileEntry.name,

})) ?? normalizeComparablePath(transcriptPath);

if (referencedSessionFiles.has(normalizedTranscriptPath)) {

continue;

}

let stat;

try {

stat = await fs.stat(transcriptPath);

} catch {

continue;

}

if (Date.now() - stat.mtimeMs < DREAMING_ORPHAN_MIN_AGE_MS) {

continue;

}

let content;

try {

content = await fs.readFile(transcriptPath, "utf-8");

} catch {

continue;

}

if (!content.includes(DREAMING_TRANSCRIPT_RUN_MARKER)) {

continue;

}

const archivedPath = `${transcriptPath}.deleted.${Date.now()}`;

try {

await fs.rename(transcriptPath, archivedPath);

archivedOrphans += 1;

} catch {

// best-effort scrubber

}

}

}

if (prunedEntries > 0 || archivedOrphans > 0) {