@xopcai/xopc 0.0.24 → 0.0.26

package/dist/src/agent/memory/dreaming/preview.js

@@ -0,0 +1,97 @@
+import { MEMORY_MD_FILENAME } from "./constants.js";
+import { clamp01, compareCandidatesByScore, computeCandidateScore, extractPromotionMarkers, isContaminatedSnippet, isExpiredEntry, readFileLines, resolveDeepDefaults, sliceRange, snippetHash } from "./utils.js";
+import { loadDreamingStore } from "./short-term-store.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region src/agent/memory/dreaming/preview.ts
+async function previewDreamingDeepPromotion(params) {
+	const cfg = resolveDeepDefaults(params.config);
+	const memoryPath = path.join(params.workspaceDir, MEMORY_MD_FILENAME);
+	if (!cfg.enabled) return {
+		ok: true,
+		reason: "dreaming disabled",
+		items: [],
+		memoryPath
+	};
+	const { store } = await loadDreamingStore({ workspaceDir: params.workspaceDir });
+	const nowMs = (params.now ?? /* @__PURE__ */ new Date()).getTime();
+	const ranked = Object.values(store.entries ?? {}).filter((e) => {
+		if (!e || typeof e !== "object") return false;
+		if (e.promotedAt) return false;
+		if (!e.path || !e.path.startsWith("memory/")) return false;
+		if (e.recallCount < cfg.minRecallCount) return false;
+		if ((e.queryHashes?.length ?? 0) < cfg.minUniqueQueries) return false;
+		if (isExpiredEntry(e.lastRecalledAt, nowMs, cfg.maxAgeDays)) return false;
+		return clamp01(e.recallCount > 0 ? e.totalScore / e.recallCount : 0) >= cfg.minScore;
+	}).map((e) => {
+		const { avgScore, score, recencyDecay } = computeCandidateScore(e, nowMs, cfg.recencyHalfLifeDays);
+		return {
+			...e,
+			avgScore,
+			score,
+			recencyDecay
+		};
+	}).sort(compareCandidatesByScore);
+	const markers = extractPromotionMarkers(await fs.readFile(memoryPath, "utf-8").catch((err) => {
+		if (err?.code === "ENOENT") return "";
+		throw err;
+	}));
+	const limit = Math.min(Math.max(params.limit ?? 20, 1), 50);
+	const out = [];
+	const scanCap = Math.min(ranked.length, Math.max(limit * 3, limit));
+	for (const candidate of ranked.slice(0, scanCap)) {
+		if (markers.keys.has(candidate.key)) {
+			out.push({
+				key: candidate.key,
+				hash: "",
+				snippet: "",
+				path: candidate.path,
+				startLine: candidate.startLine,
+				endLine: candidate.endLine,
+				score: candidate.score,
+				avgScore: candidate.avgScore,
+				recallCount: candidate.recallCount,
+				recencyDecay: candidate.recencyDecay,
+				alreadyPromotedByKey: true,
+				alreadyPromotedByHash: false,
+				skippedReason: "already promoted (key)"
+			});
+			continue;
+		}
+		const lines = await readFileLines(path.join(params.workspaceDir, candidate.path));
+		if (!lines) continue;
+		const startLine = Math.max(1, Math.floor(candidate.startLine));
+		const endLine = Math.max(startLine, Math.floor(candidate.endLine));
+		const snippet = sliceRange(lines, startLine, endLine);
+		if (!snippet) continue;
+		if (isContaminatedSnippet(snippet)) continue;
+		const hash = snippetHash(snippet);
+		const alreadyPromotedByHash = markers.hashes.has(hash);
+		out.push({
+			key: candidate.key,
+			hash,
+			snippet,
+			path: candidate.path,
+			startLine,
+			endLine,
+			score: candidate.score,
+			avgScore: candidate.avgScore,
+			recallCount: candidate.recallCount,
+			recencyDecay: candidate.recencyDecay,
+			alreadyPromotedByKey: false,
+			alreadyPromotedByHash,
+			skippedReason: alreadyPromotedByHash ? "already promoted (hash)" : null
+		});
+		if (out.filter((x) => !x.skippedReason).length >= limit) break;
+	}
+	return {
+		ok: true,
+		reason: "ok",
+		items: out,
+		memoryPath
+	};
+}
+//#endregion
+export { previewDreamingDeepPromotion };
+
+//# sourceMappingURL=preview.js.map

package/dist/src/agent/memory/dreaming/preview.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.js","names":[],"sources":["../../../../../src/agent/memory/dreaming/preview.ts"],"sourcesContent":["import fs from 'node:fs/promises';\nimport path from 'node:path';\n\nimport type { DreamingDeepConfig } from './config.js';\nimport { MEMORY_MD_FILENAME } from './constants.js';\nimport { loadDreamingStore, type DreamingStoreEntry } from './short-term-store.js';\nimport {\n  clamp01,\n  compareCandidatesByScore,\n  computeCandidateScore,\n  extractPromotionMarkers,\n  isContaminatedSnippet,\n  isExpiredEntry,\n  readFileLines,\n  resolveDeepDefaults,\n  sliceRange,\n  snippetHash,\n} from './utils.js';\n\ntype PreviewItem = {\n  key: string;\n  hash: string;\n  snippet: string;\n  path: string;\n  startLine: number;\n  endLine: number;\n  score: number;\n  avgScore: number;\n  recallCount: number;\n  recencyDecay: number;\n  alreadyPromotedByKey: boolean;\n  alreadyPromotedByHash: boolean;\n  skippedReason: string | null;\n};\n\nexport async function previewDreamingDeepPromotion(params: {\n  workspaceDir: string;\n  config?: Partial<DreamingDeepConfig>;\n  limit?: number;\n  now?: Date;\n}): Promise<{ ok: boolean; reason: string; items: PreviewItem[]; memoryPath: string }> {\n  const cfg = resolveDeepDefaults(params.config);\n  const memoryPath = path.join(params.workspaceDir, MEMORY_MD_FILENAME);\n  if (!cfg.enabled) return { ok: true, reason: 'dreaming disabled', items: [], memoryPath };\n\n  const { store } = await loadDreamingStore({ workspaceDir: params.workspaceDir });\n  const nowMs = (params.now ?? new Date()).getTime();\n\n  const all = Object.values(store.entries ?? {}).filter((e): e is DreamingStoreEntry => {\n    if (!e || typeof e !== 'object') return false;\n    if (e.promotedAt) return false;\n    if (!e.path || !e.path.startsWith('memory/')) return false;\n    if (e.recallCount < cfg.minRecallCount) return false;\n    if ((e.queryHashes?.length ?? 0) < cfg.minUniqueQueries) return false;\n    if (isExpiredEntry(e.lastRecalledAt, nowMs, cfg.maxAgeDays)) return false;\n    const avg = e.recallCount > 0 ? e.totalScore / e.recallCount : 0;\n    return clamp01(avg) >= cfg.minScore;\n  });\n\n  const ranked = all\n    .map((e) => {\n      const { avgScore, score, recencyDecay } = computeCandidateScore(e, nowMs, cfg.recencyHalfLifeDays);\n      return { ...e, avgScore, score, recencyDecay };\n    })\n    .sort(compareCandidatesByScore);\n\n  const existing = await fs.readFile(memoryPath, 'utf-8').catch((err: unknown) => {\n    if ((err as NodeJS.ErrnoException | undefined)?.code === 'ENOENT') return '';\n    throw err;\n  });\n  const markers = extractPromotionMarkers(existing);\n\n  const limit = Math.min(Math.max(params.limit ?? 20, 1), 50);\n  const out: PreviewItem[] = [];\n\n  // Scan more than limit so filtering doesn't yield empty previews.\n  const scanCap = Math.min(ranked.length, Math.max(limit * 3, limit));\n  for (const candidate of ranked.slice(0, scanCap)) {\n    const alreadyPromotedByKey = markers.keys.has(candidate.key);\n    if (alreadyPromotedByKey) {\n      out.push({\n        key: candidate.key,\n        hash: '',\n        snippet: '',\n        path: candidate.path,\n        startLine: candidate.startLine,\n        endLine: candidate.endLine,\n        score: candidate.score,\n        avgScore: candidate.avgScore,\n        recallCount: candidate.recallCount,\n        recencyDecay: candidate.recencyDecay,\n        alreadyPromotedByKey: true,\n        alreadyPromotedByHash: false,\n        skippedReason: 'already promoted (key)',\n      });\n      continue;\n    }\n\n    const fullPath = path.join(params.workspaceDir, candidate.path);\n    const lines = await readFileLines(fullPath);\n    if (!lines) continue;\n    const startLine = Math.max(1, Math.floor(candidate.startLine));\n    const endLine = Math.max(startLine, Math.floor(candidate.endLine));\n    const snippet = sliceRange(lines, startLine, endLine);\n    if (!snippet) continue;\n    if (isContaminatedSnippet(snippet)) continue;\n    const hash = snippetHash(snippet);\n    const alreadyPromotedByHash = markers.hashes.has(hash);\n    out.push({\n      key: candidate.key,\n      hash,\n      snippet,\n      path: candidate.path,\n      startLine,\n      endLine,\n      score: candidate.score,\n      avgScore: candidate.avgScore,\n      recallCount: candidate.recallCount,\n      recencyDecay: candidate.recencyDecay,\n      alreadyPromotedByKey: false,\n      alreadyPromotedByHash,\n      skippedReason: alreadyPromotedByHash ? 'already promoted (hash)' : null,\n    });\n    if (out.filter((x) => !x.skippedReason).length >= limit) break;\n  }\n\n  return { ok: true, reason: 'ok', items: out, memoryPath };\n}\n"],"mappings":";;;;;;AAmCA,eAAsB,6BAA6B,QAKoC;CACrF,MAAM,MAAM,oBAAoB,OAAO,OAAO;CAC9C,MAAM,aAAa,KAAK,KAAK,OAAO,cAAc,mBAAmB;AACrE,KAAI,CAAC,IAAI,QAAS,QAAO;EAAE,IAAI;EAAM,QAAQ;EAAqB,OAAO,EAAE;EAAE;EAAY;CAEzF,MAAM,EAAE,UAAU,MAAM,kBAAkB,EAAE,cAAc,OAAO,cAAc,CAAC;CAChF,MAAM,SAAS,OAAO,uBAAO,IAAI,MAAM,EAAE,SAAS;CAalD,MAAM,SAXM,OAAO,OAAO,MAAM,WAAW,EAAE,CAAC,CAAC,QAAQ,MAA+B;AACpF,MAAI,CAAC,KAAK,OAAO,MAAM,SAAU,QAAO;AACxC,MAAI,EAAE,WAAY,QAAO;AACzB,MAAI,CAAC,EAAE,QAAQ,CAAC,EAAE,KAAK,WAAW,UAAU,CAAE,QAAO;AACrD,MAAI,EAAE,cAAc,IAAI,eAAgB,QAAO;AAC/C,OAAK,EAAE,aAAa,UAAU,KAAK,IAAI,iBAAkB,QAAO;AAChE,MAAI,eAAe,EAAE,gBAAgB,OAAO,IAAI,WAAW,CAAE,QAAO;AAEpE,SAAO,QADK,EAAE,cAAc,IAAI,EAAE,aAAa,EAAE,cAAc,EAC5C,IAAI,IAAI;GAGX,CACf,KAAK,MAAM;EACV,MAAM,EAAE,UAAU,OAAO,iBAAiB,sBAAsB,GAAG,OAAO,IAAI,oBAAoB;AAClG,SAAO;GAAE,GAAG;GAAG;GAAU;GAAO;GAAc;GAC9C,CACD,KAAK,yBAAyB;CAMjC,MAAM,UAAU,wBAAwB,MAJjB,GAAG,SAAS,YAAY,QAAQ,CAAC,OAAO,QAAiB;AAC9E,MAAK,KAA2C,SAAS,SAAU,QAAO;AAC1E,QAAM;GACN,CAC+C;CAEjD,MAAM,QAAQ,KAAK,IAAI,KAAK,IAAI,OAAO,SAAS,IAAI,EAAE,EAAE,GAAG;CAC3D,MAAM,MAAqB,EAAE;CAG7B,MAAM,UAAU,KAAK,IAAI,OAAO,QAAQ,KAAK,IAAI,QAAQ,GAAG,MAAM,CAAC;AACnE,MAAK,MAAM,aAAa,OAAO,MAAM,GAAG,QAAQ,EAAE;AAEhD,MAD6B,QAAQ,KAAK,IAAI,UAAU,IAChC,EAAE;AACxB,OAAI,KAAK;IACP,KAAK,UAAU;IACf,MAAM;IACN,SAAS;IACT,MAAM,UAAU;IAChB,WAAW,UAAU;IACrB,SAAS,UAAU;IACnB,OAAO,UAAU;IACjB,UAAU,UAAU;IACpB,aAAa,UAAU;IACvB,cAAc,UAAU;IACxB,sBAAsB;IACtB,uBAAuB;IACvB,eAAe;IAChB,CAAC;AACF;;EAIF,MAAM,QAAQ,MAAM,cADH,KAAK,KAAK,OAAO,cAAc,UAAU,KAChB,CAAC;AAC3C,MAAI,CAAC,MAAO;EACZ,MAAM,YAAY,KAAK,IAAI,GAAG,KAAK,MAAM,UAAU,UAAU,CAAC;EAC9D,MAAM,UAAU,KAAK,IAAI,WAAW,KAAK,MAAM,UAAU,QAAQ,CAAC;EAClE,MAAM,UAAU,WAAW,OAAO,WAAW,QAAQ;AACrD,MAAI,CAAC,QAAS;AACd,MAAI,sBAAsB,QAAQ,CAAE;EACpC,MAAM,OAAO,YAAY,QAAQ;EACjC,MAAM,wBAAwB,QAAQ,OAAO,IAAI,KAAK;AACtD,MAAI,KAAK;GACP,KAAK,UAAU;GACf;GACA;GACA,MAAM,UAAU;GAChB;GACA;GACA,OAAO,UAAU;GACjB,UAAU,UAAU;GACpB,aAAa,UAAU;GACvB,cAAc,UAAU;GACxB,sBAAsB;GACtB;GACA,eAAe,wBAAwB,4BAA4B;GACpE,CAAC;AACF,MAAI,IAAI,QAAQ,MAAM,CAAC,EAAE,cAAc,CAAC,UAAU,MAAO;;AAG3D,QAAO;EAAE,IAAI;EAAM,QAAQ;EAAM,OAAO;EAAK;EAAY"}

package/dist/src/agent/memory/dreaming/rem-patterns.d.ts

@@ -0,0 +1,21 @@
+import type { DreamingRemConfig } from './config.js';
+/**
+ * REM phase: cross-session pattern discovery.
+ *
+ * Scans the short-term store for entries that share query hashes or
+ * appear across multiple daily files, then clusters them to identify
+ * recurring themes/patterns. Bumps `remHits` on touched entries and
+ * optionally writes a pattern summary to DREAMS.md.
+ *
+ * Runs weekly; expensive but insightful.
+ */
+export declare function runRemPatterns(params: {
+    workspaceDir: string;
+    config?: Partial<DreamingRemConfig>;
+    now?: Date;
+}): Promise<{
+    ok: boolean;
+    reason: string;
+    patternsDiscovered: number;
+    entriesAnalyzed: number;
+}>;

package/dist/src/agent/memory/dreaming/rem-patterns.js

@@ -0,0 +1,286 @@
+import { createLogger } from "../../../utils/logger/index.js";
+import { init_logger } from "../../../utils/logger.js";
+import { DREAMING_DIR_RELATIVE, DREAMS_MD_FILENAME, MS_PER_DAY } from "./constants.js";
+import { isoDay } from "./utils.js";
+import { bumpEntryPhaseSignal, loadDreamingStore, saveDreamingStore } from "./short-term-store.js";
+import "./last-run.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region src/agent/memory/dreaming/rem-patterns.ts
+init_logger();
+const log = createLogger("Dreaming:REM");
+function resolveConfig(overrides) {
+	return {
+		enabled: overrides?.enabled === true,
+		cron: typeof overrides?.cron === "string" ? overrides.cron : "0 5 * * 0",
+		lookbackDays: Math.max(1, Math.floor(Number(overrides?.lookbackDays) || 7)),
+		limit: Math.max(0, Math.floor(Number(overrides?.limit) || 10)),
+		minPatternStrength: Math.max(0, Math.min(1, Number(overrides?.minPatternStrength) || .75))
+	};
+}
+/**
+* REM phase: cross-session pattern discovery.
+*
+* Scans the short-term store for entries that share query hashes or
+* appear across multiple daily files, then clusters them to identify
+* recurring themes/patterns. Bumps `remHits` on touched entries and
+* optionally writes a pattern summary to DREAMS.md.
+*
+* Runs weekly; expensive but insightful.
+*/
+async function runRemPatterns(params) {
+	const cfg = resolveConfig(params.config);
+	const now = params.now ?? /* @__PURE__ */ new Date();
+	const startedAt = now.toISOString();
+	const runId = `rem:${startedAt}:${process.pid}`;
+	const startMs = Date.now();
+	const nowMs = now.getTime();
+	if (!cfg.enabled) {
+		await writeLastRun(params.workspaceDir, {
+			runId,
+			startedAt,
+			cfg,
+			ok: true,
+			reason: "REM patterns disabled",
+			startMs,
+			rem: {
+				patternsDiscovered: 0,
+				entriesAnalyzed: 0
+			}
+		});
+		return {
+			ok: true,
+			reason: "REM patterns disabled",
+			patternsDiscovered: 0,
+			entriesAnalyzed: 0
+		};
+	}
+	try {
+		const { store } = await loadDreamingStore({ workspaceDir: params.workspaceDir });
+		const cutoffMs = nowMs - cfg.lookbackDays * MS_PER_DAY;
+		const recentEntries = Object.values(store.entries ?? {}).filter((entry) => {
+			if (!entry || typeof entry !== "object") return false;
+			if (!entry.lastRecalledAt) return false;
+			const lastMs = Date.parse(entry.lastRecalledAt);
+			return Number.isFinite(lastMs) && lastMs >= cutoffMs;
+		});
+		if (recentEntries.length < 2) {
+			await writeLastRun(params.workspaceDir, {
+				runId,
+				startedAt,
+				cfg,
+				ok: true,
+				reason: "not enough recent entries for pattern analysis",
+				startMs,
+				rem: {
+					patternsDiscovered: 0,
+					entriesAnalyzed: recentEntries.length
+				}
+			});
+			return {
+				ok: true,
+				reason: "not enough recent entries for pattern analysis",
+				patternsDiscovered: 0,
+				entriesAnalyzed: recentEntries.length
+			};
+		}
+		const topClusters = discoverPatternClusters(recentEntries, cfg.minPatternStrength).slice(0, cfg.limit);
+		const touchedKeys = /* @__PURE__ */ new Set();
+		for (const cluster of topClusters) for (const member of cluster.members) if (!touchedKeys.has(member.key)) {
+			touchedKeys.add(member.key);
+			const storeEntry = store.entries[member.key];
+			if (storeEntry) bumpEntryPhaseSignal(storeEntry, "remHits");
+		}
+		store.updatedAt = now.toISOString();
+		await saveDreamingStore({
+			workspaceDir: params.workspaceDir,
+			store
+		});
+		if (topClusters.length > 0) await appendPatternSummary(params.workspaceDir, topClusters, now);
+		log.info({
+			workspaceDir: params.workspaceDir,
+			patterns: topClusters.length,
+			entriesAnalyzed: recentEntries.length,
+			touched: touchedKeys.size
+		}, "REM pattern discovery complete");
+		await writeLastRun(params.workspaceDir, {
+			runId,
+			startedAt,
+			cfg,
+			ok: true,
+			reason: "REM patterns complete",
+			startMs,
+			rem: {
+				patternsDiscovered: topClusters.length,
+				entriesAnalyzed: recentEntries.length
+			}
+		});
+		return {
+			ok: true,
+			reason: "REM patterns complete",
+			patternsDiscovered: topClusters.length,
+			entriesAnalyzed: recentEntries.length
+		};
+	} catch (err) {
+		const errorMessage = err instanceof Error ? err.message : String(err);
+		log.error({
+			err,
+			errorMessage,
+			workspaceDir: params.workspaceDir
+		}, `REM pattern discovery failed: ${errorMessage}`);
+		await writeLastRun(params.workspaceDir, {
+			runId,
+			startedAt,
+			cfg,
+			ok: false,
+			reason: `REM error: ${errorMessage}`,
+			startMs,
+			rem: {
+				patternsDiscovered: 0,
+				entriesAnalyzed: 0
+			},
+			errorMessage
+		}).catch(() => void 0);
+		return {
+			ok: false,
+			reason: errorMessage,
+			patternsDiscovered: 0,
+			entriesAnalyzed: 0
+		};
+	}
+}
+/**
+* Build an inverted index of queryHash → entries, then form clusters
+* where multiple entries share overlapping query hashes. Each cluster's
+* "strength" is the ratio of shared queries to total unique queries.
+*/
+function discoverPatternClusters(entries, minStrength) {
+	const hashToEntries = /* @__PURE__ */ new Map();
+	for (const entry of entries) for (const queryHash of entry.queryHashes ?? []) {
+		const group = hashToEntries.get(queryHash);
+		if (group) group.push(entry);
+		else hashToEntries.set(queryHash, [entry]);
+	}
+	const significantHashes = [];
+	for (const [hash, group] of hashToEntries) {
+		const uniquePaths = new Set(group.map((e) => e.path));
+		if (group.length >= 2 && uniquePaths.size >= 2) significantHashes.push({
+			hash,
+			entries: group
+		});
+	}
+	if (significantHashes.length === 0) return [];
+	const keyToCluster = /* @__PURE__ */ new Map();
+	const keyToEntry = /* @__PURE__ */ new Map();
+	for (const entry of entries) keyToEntry.set(entry.key, entry);
+	for (const { entries: groupEntries } of significantHashes) {
+		const keys = groupEntries.map((e) => e.key);
+		let mergedCluster = keyToCluster.get(keys[0]);
+		if (!mergedCluster) {
+			mergedCluster = /* @__PURE__ */ new Set();
+			mergedCluster.add(keys[0]);
+			keyToCluster.set(keys[0], mergedCluster);
+		}
+		for (const key of keys.slice(1)) {
+			const existingCluster = keyToCluster.get(key);
+			if (existingCluster && existingCluster !== mergedCluster) for (const existingKey of existingCluster) {
+				mergedCluster.add(existingKey);
+				keyToCluster.set(existingKey, mergedCluster);
+			}
+			else {
+				mergedCluster.add(key);
+				keyToCluster.set(key, mergedCluster);
+			}
+		}
+	}
+	const seenClusters = /* @__PURE__ */ new Set();
+	const rawClusters = [];
+	for (const cluster of keyToCluster.values()) if (!seenClusters.has(cluster) && cluster.size >= 2) {
+		seenClusters.add(cluster);
+		rawClusters.push(cluster);
+	}
+	const scoredClusters = [];
+	for (const clusterKeys of rawClusters) {
+		const members = [];
+		for (const key of clusterKeys) {
+			const entry = keyToEntry.get(key);
+			if (entry) members.push(entry);
+		}
+		if (members.length < 2) continue;
+		const hashCounts = /* @__PURE__ */ new Map();
+		for (const member of members) for (const hash of member.queryHashes ?? []) hashCounts.set(hash, (hashCounts.get(hash) ?? 0) + 1);
+		const sharedQueries = [...hashCounts.entries()].filter(([, count]) => count >= 2).map(([hash]) => hash);
+		const allUniqueHashes = /* @__PURE__ */ new Set();
+		for (const member of members) for (const hash of member.queryHashes ?? []) allUniqueHashes.add(hash);
+		const strength = allUniqueHashes.size > 0 ? sharedQueries.length / allUniqueHashes.size : 0;
+		if (strength < minStrength) continue;
+		const distinctPaths = [...new Set(members.map((m) => m.path))];
+		const representative = members.reduce((best, current) => (current.totalSignalCount ?? 0) > (best.totalSignalCount ?? 0) ? current : best);
+		scoredClusters.push({
+			representative,
+			members,
+			strength,
+			sharedQueries,
+			distinctPaths
+		});
+	}
+	scoredClusters.sort((a, b) => {
+		if (b.strength !== a.strength) return b.strength - a.strength;
+		return b.members.length - a.members.length;
+	});
+	return scoredClusters;
+}
+async function appendPatternSummary(workspaceDir, clusters, now) {
+	const dreamsPath = path.join(workspaceDir, DREAMS_MD_FILENAME);
+	const existing = await fs.readFile(dreamsPath, "utf-8").catch((err) => {
+		if (err?.code === "ENOENT") return "";
+		throw err;
+	});
+	const day = isoDay(now);
+	const lines = [];
+	if (existing.trim().length === 0) lines.push("# Dream Diary", "");
+	lines.push(`## REM Pattern Discovery — ${day}`, "");
+	lines.push(`*${now.toISOString()}*`, "");
+	for (let i = 0; i < clusters.length; i++) {
+		const cluster = clusters[i];
+		lines.push(`### Pattern ${i + 1}: ${cluster.distinctPaths.length} files, strength=${cluster.strength.toFixed(2)}`);
+		lines.push("");
+		lines.push(`**Files involved:** ${cluster.distinctPaths.join(", ")}`);
+		lines.push(`**Shared query themes:** ${cluster.sharedQueries.length} overlapping queries`);
+		lines.push(`**Members:** ${cluster.members.length} snippets`);
+		lines.push("");
+		const rep = cluster.representative;
+		lines.push(`> ${rep.snippet?.slice(0, 200) ?? "(no snippet)"}`);
+		lines.push(`> — ${rep.path}:${rep.startLine}-${rep.endLine}`);
+		lines.push("");
+	}
+	lines.push("---", "");
+	const next = `${existing}${existing.trim().length > 0 && !existing.endsWith("\n") ? "\n" : ""}${lines.join("\n")}`;
+	await fs.writeFile(dreamsPath, next, "utf-8");
+}
+async function writeLastRun(workspaceDir, params) {
+	const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+	const durationMs = Math.max(0, Date.now() - params.startMs);
+	const lastRun = {
+		version: 2,
+		phase: "rem",
+		runId: params.runId,
+		startedAt: params.startedAt,
+		finishedAt,
+		durationMs,
+		ok: params.ok,
+		reason: params.reason,
+		config: params.cfg,
+		rem: params.rem,
+		...params.errorMessage ? { errorMessage: params.errorMessage } : {}
+	};
+	const lastRunPath = path.join(workspaceDir, DREAMING_DIR_RELATIVE, "last-run-rem.json");
+	await fs.mkdir(path.dirname(lastRunPath), { recursive: true });
+	const tmp = `${lastRunPath}.${process.pid}.${Date.now()}.tmp`;
+	await fs.writeFile(tmp, `${JSON.stringify(lastRun, null, 2)}\n`, "utf-8");
+	await fs.rename(tmp, lastRunPath);
+}
+//#endregion
+export { runRemPatterns };
+
+//# sourceMappingURL=rem-patterns.js.map

package/dist/src/agent/memory/dreaming/rem-patterns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rem-patterns.js","names":[],"sources":["../../../../../src/agent/memory/dreaming/rem-patterns.ts"],"sourcesContent":["import fs from 'node:fs/promises';\nimport path from 'node:path';\n\nimport { createLogger } from '../../../utils/logger.js';\nimport { DREAMING_DIR_RELATIVE, DREAMS_MD_FILENAME, MS_PER_DAY } from './constants.js';\nimport type { DreamingRemConfig } from './config.js';\nimport {\n  bumpEntryPhaseSignal,\n  loadDreamingStore,\n  saveDreamingStore,\n  type DreamingStoreEntry,\n} from './short-term-store.js';\nimport { isoDay } from './utils.js';\nimport {\n  DREAMING_LAST_RUN_FORMAT_VERSION,\n  type DreamingRemLastRun,\n} from './last-run.js';\n\nconst log = createLogger('Dreaming:REM');\n\n// ── Pattern types ──────────────────────────────────────────────────────\n\ntype PatternCluster = {\n  representative: DreamingStoreEntry;\n  members: DreamingStoreEntry[];\n  strength: number;\n  /** Shared query hashes across members. */\n  sharedQueries: string[];\n  /** Distinct source files involved. */\n  distinctPaths: string[];\n};\n\n// ── Config defaults ────────────────────────────────────────────────────\n\nfunction resolveConfig(overrides?: Partial<DreamingRemConfig>): DreamingRemConfig {\n  return {\n    enabled: overrides?.enabled === true,\n    cron: typeof overrides?.cron === 'string' ? overrides.cron : '0 5 * * 0',\n    lookbackDays: Math.max(1, Math.floor(Number(overrides?.lookbackDays) || 7)),\n    limit: Math.max(0, Math.floor(Number(overrides?.limit) || 10)),\n    minPatternStrength: Math.max(0, Math.min(1, Number(overrides?.minPatternStrength) || 0.75)),\n  };\n}\n\n// ── Core REM pattern discovery ─────────────────────────────────────────\n\n/**\n * REM phase: cross-session pattern discovery.\n *\n * Scans the short-term store for entries that share query hashes or\n * appear across multiple daily files, then clusters them to identify\n * recurring themes/patterns. Bumps `remHits` on touched entries and\n * optionally writes a pattern summary to DREAMS.md.\n *\n * Runs weekly; expensive but insightful.\n */\nexport async function runRemPatterns(params: {\n  workspaceDir: string;\n  config?: Partial<DreamingRemConfig>;\n  now?: Date;\n}): Promise<{\n  ok: boolean;\n  reason: string;\n  patternsDiscovered: number;\n  entriesAnalyzed: number;\n}> {\n  const cfg = resolveConfig(params.config);\n  const now = params.now ?? new Date();\n  const startedAt = now.toISOString();\n  const runId = `rem:${startedAt}:${process.pid}`;\n  const startMs = Date.now();\n  const nowMs = now.getTime();\n\n  if (!cfg.enabled) {\n    await writeLastRun(params.workspaceDir, {\n      runId, startedAt, cfg, ok: true, reason: 'REM patterns disabled', startMs,\n      rem: { patternsDiscovered: 0, entriesAnalyzed: 0 },\n    });\n    return { ok: true, reason: 'REM patterns disabled', patternsDiscovered: 0, entriesAnalyzed: 0 };\n  }\n\n  try {\n    const { store } = await loadDreamingStore({ workspaceDir: params.workspaceDir });\n\n    // Filter entries within the lookback window.\n    const cutoffMs = nowMs - cfg.lookbackDays * MS_PER_DAY;\n    const recentEntries = Object.values(store.entries ?? {}).filter(\n      (entry): entry is DreamingStoreEntry => {\n        if (!entry || typeof entry !== 'object') return false;\n        if (!entry.lastRecalledAt) return false;\n        const lastMs = Date.parse(entry.lastRecalledAt);\n        return Number.isFinite(lastMs) && lastMs >= cutoffMs;\n      },\n    );\n\n    if (recentEntries.length < 2) {\n      await writeLastRun(params.workspaceDir, {\n        runId, startedAt, cfg, ok: true, reason: 'not enough recent entries for pattern analysis', startMs,\n        rem: { patternsDiscovered: 0, entriesAnalyzed: recentEntries.length },\n      });\n      return {\n        ok: true,\n        reason: 'not enough recent entries for pattern analysis',\n        patternsDiscovered: 0,\n        entriesAnalyzed: recentEntries.length,\n      };\n    }\n\n    // Discover patterns by clustering entries that share query hashes.\n    const clusters = discoverPatternClusters(recentEntries, cfg.minPatternStrength);\n    const topClusters = clusters.slice(0, cfg.limit);\n\n    // Bump remHits on all entries that belong to a discovered pattern.\n    const touchedKeys = new Set<string>();\n    for (const cluster of topClusters) {\n      for (const member of cluster.members) {\n        if (!touchedKeys.has(member.key)) {\n          touchedKeys.add(member.key);\n          const storeEntry = store.entries[member.key];\n          if (storeEntry) {\n            bumpEntryPhaseSignal(storeEntry, 'remHits');\n          }\n        }\n      }\n    }\n\n    store.updatedAt = now.toISOString();\n    await saveDreamingStore({ workspaceDir: params.workspaceDir, store });\n\n    // Write pattern summary to DREAMS.md (append).\n    if (topClusters.length > 0) {\n      await appendPatternSummary(params.workspaceDir, topClusters, now);\n    }\n\n    log.info(\n      {\n        workspaceDir: params.workspaceDir,\n        patterns: topClusters.length,\n        entriesAnalyzed: recentEntries.length,\n        touched: touchedKeys.size,\n      },\n      'REM pattern discovery complete',\n    );\n\n    await writeLastRun(params.workspaceDir, {\n      runId, startedAt, cfg, ok: true, reason: 'REM patterns complete', startMs,\n      rem: { patternsDiscovered: topClusters.length, entriesAnalyzed: recentEntries.length },\n    });\n\n    return {\n      ok: true,\n      reason: 'REM patterns complete',\n      patternsDiscovered: topClusters.length,\n      entriesAnalyzed: recentEntries.length,\n    };\n  } catch (err) {\n    const errorMessage = err instanceof Error ? err.message : String(err);\n    log.error({ err, errorMessage, workspaceDir: params.workspaceDir }, `REM pattern discovery failed: ${errorMessage}`);\n    await writeLastRun(params.workspaceDir, {\n      runId, startedAt, cfg, ok: false, reason: `REM error: ${errorMessage}`, startMs,\n      rem: { patternsDiscovered: 0, entriesAnalyzed: 0 }, errorMessage,\n    }).catch(() => undefined);\n    return { ok: false, reason: errorMessage, patternsDiscovered: 0, entriesAnalyzed: 0 };\n  }\n}\n\n// ── Pattern clustering ─────────────────────────────────────────────────\n\n/**\n * Build an inverted index of queryHash → entries, then form clusters\n * where multiple entries share overlapping query hashes. Each cluster's\n * \"strength\" is the ratio of shared queries to total unique queries.\n */\nfunction discoverPatternClusters(\n  entries: DreamingStoreEntry[],\n  minStrength: number,\n): PatternCluster[] {\n  // Build inverted index: queryHash → entry keys.\n  const hashToEntries = new Map<string, DreamingStoreEntry[]>();\n  for (const entry of entries) {\n    for (const queryHash of entry.queryHashes ?? []) {\n      const group = hashToEntries.get(queryHash);\n      if (group) {\n        group.push(entry);\n      } else {\n        hashToEntries.set(queryHash, [entry]);\n      }\n    }\n  }\n\n  // Find query hashes that appear in 2+ distinct entries from different paths.\n  const significantHashes: Array<{ hash: string; entries: DreamingStoreEntry[] }> = [];\n  for (const [hash, group] of hashToEntries) {\n    const uniquePaths = new Set(group.map((e) => e.path));\n    if (group.length >= 2 && uniquePaths.size >= 2) {\n      significantHashes.push({ hash, entries: group });\n    }\n  }\n\n  if (significantHashes.length === 0) return [];\n\n  // Merge overlapping groups into clusters using union-find.\n  const keyToCluster = new Map<string, Set<string>>();\n  const keyToEntry = new Map<string, DreamingStoreEntry>();\n\n  for (const entry of entries) {\n    keyToEntry.set(entry.key, entry);\n  }\n\n  for (const { entries: groupEntries } of significantHashes) {\n    const keys = groupEntries.map((e) => e.key);\n    // Find or create the cluster for the first key.\n    let mergedCluster = keyToCluster.get(keys[0]!);\n    if (!mergedCluster) {\n      mergedCluster = new Set<string>();\n      mergedCluster.add(keys[0]!);\n      keyToCluster.set(keys[0]!, mergedCluster);\n    }\n    // Merge all other keys into this cluster.\n    for (const key of keys.slice(1)) {\n      const existingCluster = keyToCluster.get(key);\n      if (existingCluster && existingCluster !== mergedCluster) {\n        for (const existingKey of existingCluster) {\n          mergedCluster.add(existingKey);\n          keyToCluster.set(existingKey, mergedCluster);\n        }\n      } else {\n        mergedCluster.add(key);\n        keyToCluster.set(key, mergedCluster);\n      }\n    }\n  }\n\n  // Deduplicate cluster sets.\n  const seenClusters = new Set<Set<string>>();\n  const rawClusters: Set<string>[] = [];\n  for (const cluster of keyToCluster.values()) {\n    if (!seenClusters.has(cluster) && cluster.size >= 2) {\n      seenClusters.add(cluster);\n      rawClusters.push(cluster);\n    }\n  }\n\n  // Score each cluster.\n  const scoredClusters: PatternCluster[] = [];\n  for (const clusterKeys of rawClusters) {\n    const members: DreamingStoreEntry[] = [];\n    for (const key of clusterKeys) {\n      const entry = keyToEntry.get(key);\n      if (entry) members.push(entry);\n    }\n    if (members.length < 2) continue;\n\n    // Shared queries: hashes that appear in 2+ members.\n    const hashCounts = new Map<string, number>();\n    for (const member of members) {\n      for (const hash of member.queryHashes ?? []) {\n        hashCounts.set(hash, (hashCounts.get(hash) ?? 0) + 1);\n      }\n    }\n    const sharedQueries = [...hashCounts.entries()]\n      .filter(([, count]) => count >= 2)\n      .map(([hash]) => hash);\n\n    const allUniqueHashes = new Set<string>();\n    for (const member of members) {\n      for (const hash of member.queryHashes ?? []) allUniqueHashes.add(hash);\n    }\n\n    const strength = allUniqueHashes.size > 0 ? sharedQueries.length / allUniqueHashes.size : 0;\n    if (strength < minStrength) continue;\n\n    const distinctPaths = [...new Set(members.map((m) => m.path))];\n\n    // Representative: the member with the highest totalSignalCount.\n    const representative = members.reduce((best, current) =>\n      (current.totalSignalCount ?? 0) > (best.totalSignalCount ?? 0) ? current : best,\n    );\n\n    scoredClusters.push({\n      representative,\n      members,\n      strength,\n      sharedQueries,\n      distinctPaths,\n    });\n  }\n\n  // Sort by strength descending, then by member count.\n  scoredClusters.sort((a, b) => {\n    if (b.strength !== a.strength) return b.strength - a.strength;\n    return b.members.length - a.members.length;\n  });\n\n  return scoredClusters;\n}\n\n// ── DREAMS.md writer ───────────────────────────────────────────────────\n\nasync function appendPatternSummary(\n  workspaceDir: string,\n  clusters: PatternCluster[],\n  now: Date,\n): Promise<void> {\n  const dreamsPath = path.join(workspaceDir, DREAMS_MD_FILENAME);\n  const existing = await fs.readFile(dreamsPath, 'utf-8').catch((err: unknown) => {\n    if ((err as NodeJS.ErrnoException)?.code === 'ENOENT') return '';\n    throw err;\n  });\n\n  const day = isoDay(now);\n  const lines: string[] = [];\n\n  if (existing.trim().length === 0) {\n    lines.push('# Dream Diary', '');\n  }\n\n  lines.push(`## REM Pattern Discovery — ${day}`, '');\n  lines.push(`*${now.toISOString()}*`, '');\n\n  for (let i = 0; i < clusters.length; i++) {\n    const cluster = clusters[i]!;\n    lines.push(\n      `### Pattern ${i + 1}: ${cluster.distinctPaths.length} files, strength=${cluster.strength.toFixed(2)}`,\n    );\n    lines.push('');\n    lines.push(`**Files involved:** ${cluster.distinctPaths.join(', ')}`);\n    lines.push(`**Shared query themes:** ${cluster.sharedQueries.length} overlapping queries`);\n    lines.push(`**Members:** ${cluster.members.length} snippets`);\n    lines.push('');\n    // Include the representative snippet.\n    const rep = cluster.representative;\n    lines.push(`> ${rep.snippet?.slice(0, 200) ?? '(no snippet)'}`);\n    lines.push(`> — ${rep.path}:${rep.startLine}-${rep.endLine}`);\n    lines.push('');\n  }\n\n  lines.push('---', '');\n\n  const separator = existing.trim().length > 0 && !existing.endsWith('\\n') ? '\\n' : '';\n  const next = `${existing}${separator}${lines.join('\\n')}`;\n  await fs.writeFile(dreamsPath, next, 'utf-8');\n}\n\n// ── Last-run writer ────────────────────────────────────────────────────\n\nasync function writeLastRun(\n  workspaceDir: string,\n  params: {\n    runId: string;\n    startedAt: string;\n    cfg: DreamingRemConfig;\n    ok: boolean;\n    reason: string;\n    startMs: number;\n    rem: DreamingRemLastRun['rem'];\n    errorMessage?: string;\n  },\n): Promise<void> {\n  const finishedAt = new Date().toISOString();\n  const durationMs = Math.max(0, Date.now() - params.startMs);\n\n  const lastRun: DreamingRemLastRun = {\n    version: DREAMING_LAST_RUN_FORMAT_VERSION,\n    phase: 'rem',\n    runId: params.runId,\n    startedAt: params.startedAt,\n    finishedAt,\n    durationMs,\n    ok: params.ok,\n    reason: params.reason,\n    config: params.cfg,\n    rem: params.rem,\n    ...(params.errorMessage ? { errorMessage: params.errorMessage } : {}),\n  };\n\n  const lastRunPath = path.join(workspaceDir, DREAMING_DIR_RELATIVE, 'last-run-rem.json');\n  await fs.mkdir(path.dirname(lastRunPath), { recursive: true });\n  const tmp = `${lastRunPath}.${process.pid}.${Date.now()}.tmp`;\n  await fs.writeFile(tmp, `${JSON.stringify(lastRun, null, 2)}\\n`, 'utf-8');\n  await fs.rename(tmp, lastRunPath);\n}\n"],"mappings":"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"}

package/dist/src/agent/memory/dreaming/short-term-store.d.ts

@@ -0,0 +1,65 @@
+import type { MemorySearchOptions } from '../../prompt/memory/index.js';
+export type DreamingStoreEntry = {
+    key: string;
+    path: string;
+    startLine: number;
+    endLine: number;
+    snippet: string;
+    /** Number of times this snippet was returned by a memory recall query. */
+    recallCount: number;
+    /** Number of times recorded from daily log scanning (light sweep). */
+    dailyCount: number;
+    /** Number of times replayed from grounded context (agent-initiated). */
+    groundedCount: number;
+    /** Number of times the light phase touched this entry. */
+    lightHits: number;
+    /** Number of times the REM phase touched this entry. */
+    remHits: number;
+    /** Cross-phase hit count (light + deep + rem combined touches). */
+    phaseHitCount: number;
+    /** Weighted aggregate of all signal dimensions. */
+    totalSignalCount: number;
+    totalScore: number;
+    maxScore: number;
+    queryHashes: string[];
+    recallDays: string[];
+    firstRecalledAt: string;
+    lastRecalledAt: string;
+    promotedAt?: string;
+};
+export type DreamingStore = {
+    version: 1;
+    updatedAt: string;
+    entries: Record<string, DreamingStoreEntry>;
+};
+type MemoryMatch = Awaited<ReturnType<typeof import('../../prompt/memory/index.js').memorySearch>>[number];
+export declare function recordDreamingRecalls(params: {
+    workspaceDir: string;
+    query: string;
+    matches: MemoryMatch[];
+    options?: MemorySearchOptions;
+    now?: Date;
+}): Promise<{
+    recorded: number;
+    skipped: number;
+    storePath: string;
+}>;
+export declare function withDreamingPromotionLock<T>(workspaceDir: string, task: () => Promise<T>): Promise<T>;
+export declare function loadDreamingStore(params: {
+    workspaceDir: string;
+}): Promise<{
+    store: DreamingStore;
+    storePath: string;
+}>;
+export declare function saveDreamingStore(params: {
+    workspaceDir: string;
+    store: DreamingStore;
+}): Promise<void>;
+type PhaseSignalField = 'dailyCount' | 'groundedCount' | 'lightHits' | 'remHits';
+/**
+ * Increment a phase-specific signal counter on an existing store entry.
+ * Also bumps `phaseHitCount` and `totalSignalCount`.
+ * Returns `true` if the entry existed and was updated.
+ */
+export declare function bumpEntryPhaseSignal(entry: DreamingStoreEntry, field: PhaseSignalField, increment?: number): void;
+export {};