@pixelzx/genesis 2026.5.5-2 → 2026.5.5-3

package/dist/dreaming-narrative-XoOfVb0x.js

@@ -0,0 +1,595 @@
+import { c as readErrorName, i as formatErrorMessage, r as extractErrorCode } from "./errors-Jbvi20TW.js";
+import { t as resolveGlobalMap } from "./global-singleton-CqneY5Pr.js";
+import { _ as resolveStateDir } from "./paths-DmR9mjUX.js";
+import { a as loadConfig } from "./io-DNd8mbjy.js";
+import { u as resolveStorePath } from "./paths-DD6L4IvS.js";
+import { t as loadSessionStore } from "./store-load-CUqchamJ.js";
+import { o as updateSessionStore } from "./store-CUSu4-Qr.js";
+import { t as createAsyncLock } from "./json-files-0_0afRRQ.js";
+import { t as RequestScopedSubagentRuntimeError } from "./error-runtime-Cv5whxJ8.js";
+import "./config-runtime-CiIsBMuo.js";
+import "./infra-runtime-BTJv3KK8.js";
+import "./memory-core-host-runtime-core-CCiyGJ4d.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();
+	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)}`);
+		}
+		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 };

package/dist/embedded-gateway-stub.runtime-xwZ-M7Ei.js

@@ -0,0 +1,9 @@
+import { a as loadConfig } from "./io-DNd8mbjy.js";
+import { p as resolveSessionAgentId } from "./agent-scope-CDjZLqNk.js";
+import "./config-3He3LWHw.js";
+import { t as loadCombinedSessionStoreForGateway } from "./combined-store-gateway-DT2C-8GW.js";
+import { c as stripEnvelopeFromMessages, i as readSessionMessages, n as capArrayByJsonBytes } from "./session-utils.fs-sxwRHULR.js";
+import { a as loadSessionEntry, p as resolveSessionModelRef, r as listSessionsFromStore } from "./session-utils-BPYVECh0.js";
+import { T as augmentChatHistoryWithCliSessionImports, a as enforceChatHistoryFinalBudget, c as sanitizeChatHistoryMessages, o as replaceOversizedChatHistoryMessages, r as augmentChatHistoryWithCanvasBlocks, s as resolveEffectiveChatHistoryMaxChars, t as CHAT_HISTORY_MAX_SINGLE_MESSAGE_BYTES, w as getMaxChatHistoryMessagesBytes } from "./chat-zUeX8mQw.js";
+import { t as resolveSessionKeyFromResolveParams } from "./sessions-resolve-D6KPfG_4.js";
+export { CHAT_HISTORY_MAX_SINGLE_MESSAGE_BYTES, augmentChatHistoryWithCanvasBlocks, augmentChatHistoryWithCliSessionImports, capArrayByJsonBytes, enforceChatHistoryFinalBudget, getMaxChatHistoryMessagesBytes, listSessionsFromStore, loadCombinedSessionStoreForGateway, loadConfig, loadSessionEntry, readSessionMessages, replaceOversizedChatHistoryMessages, resolveEffectiveChatHistoryMaxChars, resolveSessionAgentId, resolveSessionKeyFromResolveParams, resolveSessionModelRef, sanitizeChatHistoryMessages, stripEnvelopeFromMessages };

package/dist/embedded-gateway-stub.runtime.js

@@ -1 +1 @@
-export * from "./embedded-gateway-stub.runtime-Hi36BeCq.js";
+export * from "./embedded-gateway-stub.runtime-xwZ-M7Ei.js";

package/dist/entry.js

@@ -172,14 +172,14 @@ function tryHandleRootHelpFastPath(argv, deps = {}) {
 	}
 	import("./root-help-metadata-CgrSyohJ.js").then(async ({ outputPrecomputedRootHelpText }) => {
 		if (outputPrecomputedRootHelpText()) return;
-		const { outputRootHelp } = await import("./root-help-D9aeVXNr.js");
+		const { outputRootHelp } = await import("./root-help-DDa1oEtT.js");
 		await outputRootHelp();
 	}).catch(handleError);
 	return true;
 }
 function runMainOrRootHelp(argv) {
 	if (tryHandleRootHelpFastPath(argv)) return;
-	import("./run-main-1Fvwazhp.js").then(({ runCli }) => runCli(argv)).catch((error) => {
+	import("./run-main-BLD1wTLU.js").then(({ runCli }) => runCli(argv)).catch((error) => {
 		console.error("[genesis] Failed to start CLI:", error instanceof Error ? error.stack ?? error.message : error);
 		process$1.exitCode = 1;
 	});