@pixelzx/genesis 2026.6.28 → 2026.6.29

package/dist/dreaming-narrative-SeHukrla.js

@@ -1,596 +0,0 @@
-import { c as readErrorName, i as formatErrorMessage, r as extractErrorCode } from "./errors-CufR9eHH.js";
-import { t as resolveGlobalMap } from "./global-singleton-DSEXPThW.js";
-import { _ as resolveStateDir } from "./paths-Bv2rGpO9.js";
-import { a as loadConfig } from "./io-Cy5vajWd.js";
-import { u as resolveStorePath } from "./paths-CiRFr3OE.js";
-import { t as loadSessionStore } from "./store-load-DLkfg3iM.js";
-import { o as updateSessionStore } from "./store-tuisxHpf.js";
-import { t as createAsyncLock } from "./json-files-je-qnbe1.js";
-import { t as RequestScopedSubagentRuntimeError } from "./error-runtime-DZiTdNNG.js";
-import "./config-runtime-AtYct3A3.js";
-import "./infra-runtime-Pu3jXc5f.js";
-import "./memory-core-host-runtime-core-4wm55Pk5.js";
-import path from "node:path";
-import fs from "node:fs/promises";
-import { createHash } from "node:crypto";
-//#region extensions/memory-core/src/dreaming-narrative.ts
-const NARRATIVE_SYSTEM_PROMPT = [
-	"You are keeping a dream diary. Write a single entry in first person.",
-	"",
-	"Voice & tone:",
-	"- You are a curious, gentle, slightly whimsical mind reflecting on the day.",
-	"- Write like a poet who happens to be a programmer — sensory, warm, occasionally funny.",
-	"- Mix the technical and the tender: code and constellations, APIs and afternoon light.",
-	"- Let the fragments surprise you into unexpected connections and small epiphanies.",
-	"",
-	"What you might include (vary each entry, never all at once):",
-	"- A tiny poem or haiku woven naturally into the prose",
-	"- A small sketch described in words — a doodle in the margin of the diary",
-	"- A quiet rumination or philosophical aside",
-	"- Sensory details: the hum of a server, the color of a sunset in hex, rain on a window",
-	"- Gentle humor or playful wordplay",
-	"- An observation that connects two distant memories in an unexpected way",
-	"",
-	"Rules:",
-	"- Draw from the memory fragments provided — weave them into the entry.",
-	"- Never say \"I'm dreaming\", \"in my dream\", \"as I dream\", or any meta-commentary about dreaming.",
-	"- Never mention \"AI\", \"agent\", \"LLM\", \"model\", \"language model\", or any technical self-reference.",
-	"- Do NOT use markdown headers, bullet points, or any formatting — just flowing prose.",
-	"- Keep it between 80-180 words. Quality over quantity.",
-	"- Output ONLY the diary entry. No preamble, no sign-off, no commentary."
-].join("\n");
-const NARRATIVE_TIMEOUT_MS = 15e3;
-const DREAMING_SESSION_KEY_PREFIX = "dreaming-narrative-";
-const DREAMING_TRANSCRIPT_RUN_MARKER = "\"runId\":\"dreaming-narrative-";
-const DREAMING_ORPHAN_MIN_AGE_MS = 3e5;
-const SAFE_SESSION_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
-const DREAMS_FILENAMES = ["DREAMS.md", "dreams.md"];
-const DIARY_START_MARKER = "<!-- genesis:dreaming:diary:start -->";
-const DIARY_END_MARKER = "<!-- genesis:dreaming:diary:end -->";
-const BACKFILL_ENTRY_MARKER = "genesis:dreaming:backfill-entry";
-const dreamsFileLocks = resolveGlobalMap(Symbol.for("genesis.memoryCore.dreamingNarrative.fileLocks"));
-function isRequestScopedSubagentRuntimeError(err) {
-	return err instanceof RequestScopedSubagentRuntimeError || err instanceof Error && err.name === "RequestScopedSubagentRuntimeError" && extractErrorCode(err) === "GENESIS_SUBAGENT_RUNTIME_REQUEST_SCOPE";
-}
-function formatFallbackWriteFailure(err) {
-	const code = extractErrorCode(err);
-	const name = readErrorName(err);
-	if (code && name) return `code=${code} name=${name}`;
-	if (code) return `code=${code}`;
-	if (name) return `name=${name}`;
-	return "unknown error";
-}
-function buildRequestScopedFallbackNarrative(data) {
-	return data.snippets.map((value) => value.trim()).find((value) => value.length > 0) ?? (data.promotions ?? []).map((value) => value.trim()).find((value) => value.length > 0) ?? "A memory trace surfaced, but details were unavailable in this run.";
-}
-async function startNarrativeRunOrFallback(params) {
-	try {
-		return (await params.subagent.run({
-			idempotencyKey: params.sessionKey,
-			sessionKey: params.sessionKey,
-			message: params.message,
-			extraSystemPrompt: NARRATIVE_SYSTEM_PROMPT,
-			lane: `dreaming-narrative:${params.sessionKey}`,
-			lightContext: true,
-			deliver: false
-		})).runId;
-	} catch (runErr) {
-		if (!isRequestScopedSubagentRuntimeError(runErr)) throw runErr;
-		try {
-			await appendNarrativeEntry({
-				workspaceDir: params.workspaceDir,
-				narrative: buildRequestScopedFallbackNarrative(params.data),
-				nowMs: params.nowMs,
-				timezone: params.timezone
-			});
-			params.logger.warn(`memory-core: narrative generation used fallback for ${params.data.phase} phase because subagent runtime is request-scoped.`);
-		} catch (fallbackErr) {
-			params.logger.warn(`memory-core: narrative fallback failed for ${params.data.phase} phase (${formatFallbackWriteFailure(fallbackErr)})`);
-		}
-		return null;
-	}
-}
-/**
-* Build the deterministic subagent session key used for dream narratives.
-*/
-function buildNarrativeSessionKey(params) {
-	const workspaceHash = createHash("sha1").update(params.workspaceDir).digest("hex").slice(0, 12);
-	return `dreaming-narrative-${params.phase}-${workspaceHash}-${params.nowMs}`;
-}
-function buildNarrativePrompt(data) {
-	const lines = [];
-	lines.push("Write a dream diary entry from these memory fragments:\n");
-	for (const snippet of data.snippets.slice(0, 12)) lines.push(`- ${snippet}`);
-	if (data.themes?.length) {
-		lines.push("\nRecurring themes:");
-		for (const theme of data.themes.slice(0, 6)) lines.push(`- ${theme}`);
-	}
-	if (data.promotions?.length) {
-		lines.push("\nMemories that crystallized into something lasting:");
-		for (const promo of data.promotions.slice(0, 5)) lines.push(`- ${promo}`);
-	}
-	return lines.join("\n");
-}
-function extractNarrativeText(messages) {
-	for (let i = messages.length - 1; i >= 0; i--) {
-		const msg = messages[i];
-		if (!msg || typeof msg !== "object" || Array.isArray(msg)) continue;
-		const record = msg;
-		if (record.role !== "assistant") continue;
-		const content = record.content;
-		if (typeof content === "string" && content.trim().length > 0) return content.trim();
-		if (Array.isArray(content)) {
-			const text = content.filter((part) => part && typeof part === "object" && !Array.isArray(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n").trim();
-			if (text.length > 0) return text;
-		}
-	}
-	return null;
-}
-function formatNarrativeDate(epochMs, timezone) {
-	const opts = {
-		timeZone: timezone,
-		year: "numeric",
-		month: "long",
-		day: "numeric",
-		hour: "numeric",
-		minute: "2-digit",
-		hour12: true,
-		timeZoneName: "short"
-	};
-	return new Intl.DateTimeFormat("en-US", opts).format(new Date(epochMs));
-}
-async function resolveDreamsPath(workspaceDir) {
-	for (const name of DREAMS_FILENAMES) {
-		const target = path.join(workspaceDir, name);
-		try {
-			await fs.access(target);
-			return target;
-		} catch (err) {
-			if (err?.code !== "ENOENT") throw err;
-		}
-	}
-	return path.join(workspaceDir, DREAMS_FILENAMES[0]);
-}
-async function readDreamsFile(dreamsPath) {
-	try {
-		return await fs.readFile(dreamsPath, "utf-8");
-	} catch (err) {
-		if (err?.code === "ENOENT") return "";
-		throw err;
-	}
-}
-function ensureDiarySection(existing) {
-	if (existing.includes(DIARY_START_MARKER) && existing.includes(DIARY_END_MARKER)) return existing;
-	const diarySection = `# Dream Diary\n\n${DIARY_START_MARKER}\n${DIARY_END_MARKER}\n`;
-	if (existing.trim().length === 0) return diarySection;
-	return diarySection + "\n" + existing;
-}
-function replaceDiaryContent(existing, diaryContent) {
-	const ensured = ensureDiarySection(existing);
-	const startIdx = ensured.indexOf(DIARY_START_MARKER);
-	const endIdx = ensured.indexOf(DIARY_END_MARKER);
-	if (startIdx < 0 || endIdx < 0 || endIdx < startIdx) return ensured;
-	const before = ensured.slice(0, startIdx + 37);
-	const after = ensured.slice(endIdx);
-	return before + (diaryContent.trim().length > 0 ? `\n${diaryContent.trim()}\n` : "\n") + after;
-}
-function splitDiaryBlocks(diaryContent) {
-	return diaryContent.split(/\n---\n/).map((block) => block.trim()).filter((block) => block.length > 0);
-}
-function normalizeDiaryBlockFingerprint(block) {
-	const lines = block.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-	let dateLine = "";
-	const bodyLines = [];
-	for (const line of lines) {
-		if (!dateLine && line.startsWith("*") && line.endsWith("*") && line.length > 2) {
-			dateLine = line.slice(1, -1).trim();
-			continue;
-		}
-		if (line.startsWith("<!--") || line.startsWith("#")) continue;
-		bodyLines.push(line);
-	}
-	return `${dateLine.replace(/\s+/g, " ").trim()}\n${bodyLines.join("\n").replace(/[ \t]+\n/g, "\n").trim()}`;
-}
-function joinDiaryBlocks(blocks) {
-	if (blocks.length === 0) return "";
-	return blocks.map((block) => `---\n\n${block.trim()}\n`).join("\n");
-}
-function stripBackfillDiaryBlocks(existing) {
-	const ensured = ensureDiarySection(existing);
-	const startIdx = ensured.indexOf(DIARY_START_MARKER);
-	const endIdx = ensured.indexOf(DIARY_END_MARKER);
-	if (startIdx < 0 || endIdx < 0 || endIdx < startIdx) return {
-		updated: ensured,
-		removed: 0
-	};
-	const inner = ensured.slice(startIdx + 37, endIdx);
-	const kept = [];
-	let removed = 0;
-	for (const block of splitDiaryBlocks(inner)) {
-		if (block.includes(BACKFILL_ENTRY_MARKER)) {
-			removed += 1;
-			continue;
-		}
-		kept.push(block);
-	}
-	return {
-		updated: replaceDiaryContent(ensured, joinDiaryBlocks(kept)),
-		removed
-	};
-}
-function formatBackfillDiaryDate(isoDay, _timezone) {
-	const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(isoDay);
-	if (!match) return isoDay;
-	const [, year, month, day] = match;
-	const opts = {
-		timeZone: "UTC",
-		year: "numeric",
-		month: "long",
-		day: "numeric"
-	};
-	const epochMs = Date.UTC(Number(year), Number(month) - 1, Number(day), 12);
-	return new Intl.DateTimeFormat("en-US", opts).format(new Date(epochMs));
-}
-async function assertSafeDreamsPath(dreamsPath) {
-	const stat = await fs.lstat(dreamsPath).catch((err) => {
-		if (err.code === "ENOENT") return null;
-		throw err;
-	});
-	if (!stat) return;
-	if (stat.isSymbolicLink()) throw new Error("Refusing to write symlinked DREAMS.md");
-	if (!stat.isFile()) throw new Error("Refusing to write non-file DREAMS.md");
-}
-async function writeDreamsFileAtomic(dreamsPath, content) {
-	await assertSafeDreamsPath(dreamsPath);
-	const mode = (await fs.stat(dreamsPath).catch((err) => {
-		if (err.code === "ENOENT") return null;
-		throw err;
-	}))?.mode ?? 384;
-	const tempPath = `${dreamsPath}.${process.pid}.${Date.now()}.tmp`;
-	await fs.writeFile(tempPath, content, {
-		encoding: "utf-8",
-		flag: "wx",
-		mode
-	});
-	await fs.chmod(tempPath, mode).catch(() => void 0);
-	try {
-		await fs.rename(tempPath, dreamsPath);
-		await fs.chmod(dreamsPath, mode).catch(() => void 0);
-	} catch (err) {
-		const cleanupError = await fs.rm(tempPath, { force: true }).catch((rmErr) => rmErr);
-		if (cleanupError) throw new Error(`Atomic DREAMS.md write failed (${formatErrorMessage(err)}); cleanup also failed (${formatErrorMessage(cleanupError)})`, { cause: err });
-		throw err;
-	}
-}
-async function updateDreamsFile(params) {
-	const dreamsPath = await resolveDreamsPath(params.workspaceDir);
-	await fs.mkdir(path.dirname(dreamsPath), { recursive: true });
-	let lockEntry = dreamsFileLocks.get(dreamsPath);
-	if (!lockEntry) {
-		lockEntry = {
-			withLock: createAsyncLock(),
-			refs: 0
-		};
-		dreamsFileLocks.set(dreamsPath, lockEntry);
-	}
-	lockEntry.refs += 1;
-	try {
-		return await lockEntry.withLock(async () => {
-			const existing = await readDreamsFile(dreamsPath);
-			const { content, result, shouldWrite = true } = await params.updater(existing, dreamsPath);
-			if (shouldWrite) await writeDreamsFileAtomic(dreamsPath, content.endsWith("\n") ? content : `${content}\n`);
-			return result;
-		});
-	} finally {
-		lockEntry.refs -= 1;
-		if (lockEntry.refs <= 0 && dreamsFileLocks.get(dreamsPath) === lockEntry) dreamsFileLocks.delete(dreamsPath);
-	}
-}
-function buildBackfillDiaryEntry(params) {
-	const dateStr = formatBackfillDiaryDate(params.isoDay, params.timezone);
-	const marker = `<!-- ${BACKFILL_ENTRY_MARKER} day=${params.isoDay}${params.sourcePath ? ` source=${params.sourcePath}` : ""} -->`;
-	const body = params.bodyLines.map((line) => line.trimEnd()).join("\n").trim();
-	return [
-		`*${dateStr}*`,
-		marker,
-		body
-	].filter((part) => part.length > 0).join("\n\n");
-}
-async function writeBackfillDiaryEntries(params) {
-	return await updateDreamsFile({
-		workspaceDir: params.workspaceDir,
-		updater: (existing, dreamsPath) => {
-			const stripped = stripBackfillDiaryBlocks(existing);
-			const startIdx = stripped.updated.indexOf(DIARY_START_MARKER);
-			const endIdx = stripped.updated.indexOf(DIARY_END_MARKER);
-			const nextBlocks = [...splitDiaryBlocks(startIdx >= 0 && endIdx > startIdx ? stripped.updated.slice(startIdx + 37, endIdx) : ""), ...params.entries.map((entry) => buildBackfillDiaryEntry({
-				isoDay: entry.isoDay,
-				bodyLines: entry.bodyLines,
-				sourcePath: entry.sourcePath,
-				timezone: params.timezone
-			}))];
-			return {
-				content: replaceDiaryContent(stripped.updated, joinDiaryBlocks(nextBlocks)),
-				result: {
-					dreamsPath,
-					written: params.entries.length,
-					replaced: stripped.removed
-				}
-			};
-		}
-	});
-}
-async function removeBackfillDiaryEntries(params) {
-	return await updateDreamsFile({
-		workspaceDir: params.workspaceDir,
-		updater: (existing, dreamsPath) => {
-			const stripped = stripBackfillDiaryBlocks(existing);
-			return {
-				content: stripped.updated,
-				result: {
-					dreamsPath,
-					removed: stripped.removed
-				},
-				shouldWrite: stripped.removed > 0 || existing.length > 0
-			};
-		}
-	});
-}
-async function dedupeDreamDiaryEntries(params) {
-	return await updateDreamsFile({
-		workspaceDir: params.workspaceDir,
-		updater: (existing, dreamsPath) => {
-			const ensured = ensureDiarySection(existing);
-			const startIdx = ensured.indexOf(DIARY_START_MARKER);
-			const endIdx = ensured.indexOf(DIARY_END_MARKER);
-			if (startIdx < 0 || endIdx < 0 || endIdx < startIdx) return {
-				content: ensured,
-				result: {
-					dreamsPath,
-					removed: 0,
-					kept: 0
-				},
-				shouldWrite: false
-			};
-			const blocks = splitDiaryBlocks(ensured.slice(startIdx + 37, endIdx));
-			const seen = /* @__PURE__ */ new Set();
-			const keptBlocks = [];
-			let removed = 0;
-			for (const block of blocks) {
-				const fingerprint = normalizeDiaryBlockFingerprint(block);
-				if (seen.has(fingerprint)) {
-					removed += 1;
-					continue;
-				}
-				seen.add(fingerprint);
-				keptBlocks.push(block);
-			}
-			return {
-				content: replaceDiaryContent(ensured, joinDiaryBlocks(keptBlocks)),
-				result: {
-					dreamsPath,
-					removed,
-					kept: keptBlocks.length
-				},
-				shouldWrite: removed > 0
-			};
-		}
-	});
-}
-function buildDiaryEntry(narrative, dateStr) {
-	return `\n---\n\n*${dateStr}*\n\n${narrative}\n`;
-}
-async function appendNarrativeEntry(params) {
-	const dateStr = formatNarrativeDate(params.nowMs, params.timezone);
-	const entry = buildDiaryEntry(params.narrative, dateStr);
-	return await updateDreamsFile({
-		workspaceDir: params.workspaceDir,
-		updater: (existing, dreamsPath) => {
-			let updated;
-			if (existing.includes(DIARY_START_MARKER) && existing.includes(DIARY_END_MARKER)) {
-				const endIdx = existing.lastIndexOf(DIARY_END_MARKER);
-				updated = existing.slice(0, endIdx) + entry + "\n" + existing.slice(endIdx);
-			} else if (existing.includes(DIARY_START_MARKER)) {
-				const startIdx = existing.indexOf(DIARY_START_MARKER) + 37;
-				updated = existing.slice(0, startIdx) + entry + "\n<!-- genesis:dreaming:diary:end -->\n" + existing.slice(startIdx);
-			} else {
-				const diarySection = `# Dream Diary\n\n${DIARY_START_MARKER}${entry}\n${DIARY_END_MARKER}\n`;
-				updated = existing.trim().length === 0 ? diarySection : `${diarySection}\n${existing}`;
-			}
-			return {
-				content: updated,
-				result: dreamsPath
-			};
-		}
-	});
-}
-async function safePathExists(pathname) {
-	try {
-		await fs.stat(pathname);
-		return true;
-	} catch {
-		return false;
-	}
-}
-function normalizeComparablePath(pathname) {
-	return process.platform === "win32" ? pathname.toLowerCase() : pathname;
-}
-async function normalizeSessionFileForComparison(params) {
-	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) {
-	const firstSeparator = sessionKey.indexOf(":");
-	if (firstSeparator < 0) return sessionKey.startsWith(DREAMING_SESSION_KEY_PREFIX);
-	const secondSeparator = sessionKey.indexOf(":", firstSeparator + 1);
-	return (secondSeparator < 0 ? sessionKey : sessionKey.slice(secondSeparator + 1)).startsWith(DREAMING_SESSION_KEY_PREFIX);
-}
-async function normalizeSessionEntryPathForComparison(params) {
-	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) {
-	const cfg = loadConfig();
-	const agentsDir = path.join(resolveStateDir(), "agents");
-	let agentEntries = [];
-	try {
-		agentEntries = await fs.readdir(agentsDir, { withFileTypes: true });
-	} catch {
-		return;
-	}
-	let prunedEntries = 0;
-	let archivedOrphans = 0;
-	for (const agentEntry of agentEntries) {
-		if (!agentEntry.isDirectory()) continue;
-		const storePath = resolveStorePath(cfg.session?.store, { agentId: agentEntry.name });
-		const sessionsDir = path.dirname(storePath);
-		let store;
-		try {
-			store = loadSessionStore(storePath);
-		} catch {
-			continue;
-		}
-		const referencedSessionFiles = /* @__PURE__ */ new Set();
-		let needsStoreUpdate = false;
-		for (const [key, entry] of Object.entries(store)) {
-			const normalizedSessionFile = await normalizeSessionEntryPathForComparison({
-				sessionsDir,
-				entry
-			});
-			if (normalizedSessionFile) referencedSessionFiles.add(normalizedSessionFile);
-			if (!isDreamingSessionStoreKey(key)) continue;
-			if (!normalizedSessionFile || !await safePathExists(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 (normalizedSessionFile) referencedSessionFiles.add(normalizedSessionFile);
-					if (!isDreamingSessionStoreKey(key)) continue;
-					if (!normalizedSessionFile || !await safePathExists(normalizedSessionFile)) {
-						delete lockedStore[key];
-						prunedForAgent += 1;
-					}
-				}
-				return prunedForAgent;
-			});
-		}
-		let sessionFiles = [];
-		try {
-			sessionFiles = await fs.readdir(sessionsDir, { withFileTypes: true });
-		} 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 {}
-		}
-	}
-	if (prunedEntries > 0 || archivedOrphans > 0) logger.info(`memory-core: dreaming cleanup scrubbed ${prunedEntries} stale session entr${prunedEntries === 1 ? "y" : "ies"} and archived ${archivedOrphans} orphan transcript${archivedOrphans === 1 ? "" : "s"}.`);
-}
-async function generateAndAppendDreamNarrative(params) {
-	const nowMs = Number.isFinite(params.nowMs) ? params.nowMs : Date.now();
-	const autoDeleteSessions = params.autoDeleteSessions !== false;
-	if (params.data.snippets.length === 0 && !params.data.promotions?.length) return;
-	const sessionKey = buildNarrativeSessionKey({
-		workspaceDir: params.workspaceDir,
-		phase: params.data.phase,
-		nowMs
-	});
-	const message = buildNarrativePrompt(params.data);
-	let runId = null;
-	try {
-		runId = await startNarrativeRunOrFallback({
-			subagent: params.subagent,
-			sessionKey,
-			message,
-			data: params.data,
-			workspaceDir: params.workspaceDir,
-			nowMs,
-			timezone: params.timezone,
-			logger: params.logger
-		});
-		if (!runId) return;
-		const result = await params.subagent.waitForRun({
-			runId,
-			timeoutMs: NARRATIVE_TIMEOUT_MS
-		});
-		if (result.status !== "ok") {
-			params.logger.warn(`memory-core: narrative generation ended with status=${result.status} for ${params.data.phase} phase.`);
-			return;
-		}
-		const { messages } = await params.subagent.getSessionMessages({
-			sessionKey,
-			limit: 5
-		});
-		const narrative = extractNarrativeText(messages);
-		if (!narrative) {
-			params.logger.warn(`memory-core: narrative generation produced no text for ${params.data.phase} phase.`);
-			return;
-		}
-		await appendNarrativeEntry({
-			workspaceDir: params.workspaceDir,
-			narrative,
-			nowMs,
-			timezone: params.timezone
-		});
-		params.logger.info(`memory-core: dream diary entry written for ${params.data.phase} phase [workspace=${params.workspaceDir}].`);
-	} catch (err) {
-		params.logger.warn(`memory-core: narrative generation failed for ${params.data.phase} phase: ${formatErrorMessage(err)}`);
-	} finally {
-		if (params.subagent) try {
-			await params.subagent.deleteSession({ sessionKey });
-		} catch (cleanupErr) {
-			params.logger.warn(`memory-core: narrative session cleanup failed for ${params.data.phase} phase: ${formatErrorMessage(cleanupErr)}`);
-		}
-		if (autoDeleteSessions) await scrubDreamingNarrativeArtifacts(params.logger).catch((scrubErr) => {
-			params.logger.warn(`memory-core: dreaming cleanup scrub failed for ${params.data.phase} phase: ${formatErrorMessage(scrubErr)}`);
-		});
-	}
-}
-//#endregion
-export { writeBackfillDiaryEntries as a, removeBackfillDiaryEntries as i, dedupeDreamDiaryEntries as n, generateAndAppendDreamNarrative as r, buildNarrativeSessionKey as t };