import fsSync from "node:fs";

import fs from "node:fs/promises";

import path from "node:path";

import { stripInternalRuntimeContext } from "../../agents/internal-runtime-context.js";

isUsageCountedSessionTranscriptFileName,

} from "../../config/sessions/artifacts.js";

import { resolveSessionTranscriptsDirForAgent } from "../../config/sessions/paths.js";

import { loadSessionStore } from "../../config/sessions/store-load.js";

import { isExecCompletionEvent } from "../../infra/heartbeat-events-filter.js";

import { redactSensitiveText } from "../../logging/redact.js";

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

import { isCronRunSessionKey } from "../../sessions/session-key-utils.js";

import { hashText } from "./internal.js";

import { hashText } from "./hash.js";

const log = createSubsystemLogger("memory");

const DREAMING_NARRATIVE_RUN_PREFIX = "dreaming-narrative-";

// Keep the historical one-line-per-message export shape for normal turns, but

// wrap pathological long messages so downstream indexers never ingest a single

cronRunTranscriptPaths: ReadonlySet<string>;

};

type SessionTranscriptStoreEntry = {

sessionFile?: unknown;

sessionId?: unknown;

};

function isCheckpointTranscriptFileName(fileName: string): boolean {

return fileName.endsWith(".jsonl") && fileName.includes(".checkpoint.");

}

sessionsDir: string,

): SessionTranscriptClassification {

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

const store = loadSessionStore(storePath);

const store = readSessionTranscriptClassificationStore(storePath);

const dreamingTranscriptPaths = new Set<string>();

const cronRunTranscriptPaths = new Set<string>();

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

};

}

function readSessionTranscriptClassificationStore(

storePath: string,

): Record<string, SessionTranscriptStoreEntry> {

try {

const parsed = JSON.parse(fsSync.readFileSync(storePath, "utf-8")) as unknown;

if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {

return {};

}

return parsed as Record<string, SessionTranscriptStoreEntry>;

} catch {

return {};

}

}

export function loadDreamingNarrativeTranscriptPathSetForAgent(

agentId: string,

): ReadonlySet<string> {

return path.join("sessions", path.basename(absPath)).replace(/\\/g, "/");

}

async function logSessionFileReadFailure(absPath: string, err: unknown): Promise<void> {

const { createSubsystemLogger } = await import("../../logging/subsystem.js");

createSubsystemLogger("memory").debug(`Failed reading session file ${absPath}: ${String(err)}`);

}

function normalizeSessionText(value: string): string {

return value

.replace(/\s*\n+\s*/g, " ")

...(generatedByCronRun ? { generatedByCronRun: true } : {}),

};

} catch (err) {

log.debug(`Failed reading session file ${absPath}: ${String(err)}`);

void logSessionFileReadFailure(absPath, err);

return null;

}

}