@xopcai/xopc 0.0.180 → 0.0.188

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

@@ -1,55 +1,29 @@
 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, withDreamingStoreLock } from "./short-term-store.js";
+import { recordDreamingDecision } from "../../../storage/sqlite/dreaming-repository.js";
+import { appendMemorySignal, appendMemoryTraceEvent, getMemoryRecord, listMemorySignals } from "../../../storage/sqlite/memory-records-repository.js";
+import "../../../storage/sqlite/index.js";
 import { inferMemorySensitivity } from "../sensitivity.js";
-import "./last-run.js";
-import { activateRemInsight, remPatternKey } from "./promotion-lifecycle.js";
-import path from "node:path";
-import fs from "node:fs/promises";
+import { activateRemInsight } from "./promotion-lifecycle.js";
+import { createHash } from "node:crypto";
 //#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 indexed memory sources, 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.
-*/
+/** Discover cross-session patterns from structured usage signals. */
 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();
+	const started = Date.now();
 	if (!cfg.enabled) {
-		await writeLastRun(params.dreamingRoot, {
-			runId,
-			startedAt,
-			cfg,
-			ok: true,
-			reason: "REM patterns disabled",
-			startMs,
-			rem: {
-				patternsDiscovered: 0,
-				entriesAnalyzed: 0
-			}
-		});
+		trace(params, "REM patterns disabled", [], 0, started);
 		return {
 			ok: true,
 			reason: "REM patterns disabled",
@@ -58,250 +32,119 @@ async function runRemPatterns(params) {
 		};
 	}
 	try {
-		return await withDreamingStoreLock(params.dreamingRoot, async () => {
-			const { store } = await loadDreamingStore({ dreamingRoot: params.dreamingRoot });
-			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.dreamingRoot, {
-					runId,
-					startedAt,
-					cfg,
-					ok: true,
-					reason: "not enough recent entries for pattern analysis",
-					startMs,
-					rem: {
-						patternsDiscovered: 0,
-						entriesAnalyzed: recentEntries.length
-					}
+		const cutoff = now.getTime() - cfg.lookbackDays * 864e5;
+		const signals = listMemorySignals({
+			workspaceId: params.workspaceDir,
+			limit: 500
+		}).filter((signal) => signal.recordId && Date.parse(signal.createdAt) >= cutoff && (signal.source === "search_recall" || signal.source === "context_injection"));
+		const groups = /* @__PURE__ */ new Map();
+		for (const signal of signals) {
+			const query = String(signal.metadata.query ?? "").trim().toLocaleLowerCase();
+			if (!query || !signal.recordId) continue;
+			const queryKey = createHash("sha256").update(query).digest("hex").slice(0, 24);
+			const group = groups.get(queryKey) ?? /* @__PURE__ */ new Set();
+			group.add(signal.recordId);
+			groups.set(queryKey, group);
+		}
+		const patterns = [...groups.values()].filter((recordIds) => recordIds.size >= 2).map((recordIds) => [...recordIds].map((id) => getMemoryRecord(id)).filter((record) => record != null)).filter((records) => records.length >= 2).map((records) => ({
+			records,
+			strength: Math.min(1, records.length / 4)
+		})).filter((pattern) => pattern.strength >= cfg.minPatternStrength).sort((left, right) => right.strength - left.strength).slice(0, cfg.limit);
+		const canPropose = params.mode !== "observe";
+		let written = 0;
+		for (const pattern of patterns) {
+			const sensitivity = inferMemorySensitivity(pattern.records.map((record) => record.content).join("\n"));
+			if (sensitivity !== "normal" && params.sensitiveWritePolicy !== "allow") {
+				recordDreamingDecision({
+					runId: params.runId,
+					action: "skip",
+					reasonCode: "sensitive_write_blocked",
+					score: pattern.strength
 				});
-				return {
-					ok: true,
-					reason: "not enough recent entries for pattern analysis",
-					patternsDiscovered: 0,
-					entriesAnalyzed: recentEntries.length
-				};
-			}
-			const topClusters = discoverPatternClusters(recentEntries, cfg.minPatternStrength).filter((cluster) => {
-				return inferMemorySensitivity(cluster.members.map((member) => member.snippet).join("\n")) === "normal" || params.sensitiveWritePolicy === "allow";
-			}).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");
+				continue;
 			}
-			store.updatedAt = now.toISOString();
-			await saveDreamingStore({
-				dreamingRoot: params.dreamingRoot,
-				store
+			recordDreamingDecision({
+				runId: params.runId,
+				action: canPropose ? "propose" : "observe",
+				reasonCode: "rem_pattern_threshold_met",
+				score: pattern.strength,
+				evidence: { memberRecordIds: pattern.records.map((record) => record.id) }
 			});
-			if (params.promotionWritePolicy === "allow") for (const cluster of topClusters) {
-				const sensitivity = inferMemorySensitivity(cluster.members.map((member) => member.snippet).join("\n"));
-				activateRemInsight({
+			if (canPropose) {
+				const record = activateRemInsight({
 					agentId: params.agentId,
 					workspaceId: params.workspaceDir,
-					memberKeys: cluster.members.map((member) => member.key),
-					representative: cluster.representative.snippet,
-					distinctPaths: cluster.distinctPaths,
-					strength: cluster.strength,
+					memberKeys: pattern.records.map((record) => record.id),
+					representative: pattern.records[0].content,
+					distinctPaths: pattern.records.map((record) => record.id),
+					strength: pattern.strength,
 					observedAt: now.toISOString(),
-					evidence: cluster.members.map((member) => member.snippet),
-					sensitivity
+					evidence: pattern.records.map((record) => record.content),
+					sensitivity,
+					status: "candidate"
 				});
+				appendMemorySignal({
+					signal: {
+						source: "dreaming",
+						recordId: record.id,
+						score: pattern.strength,
+						content: record.content,
+						metadata: { phase: "rem" }
+					},
+					providerId: "local",
+					sourceAgentId: params.agentId,
+					workspaceId: params.workspaceDir
+				});
+				written += 1;
 			}
-			if (topClusters.length > 0) await appendPatternSummary(params.dreamingRoot, topClusters, now);
-			log.info({
-				dreamingRoot: params.dreamingRoot,
-				patterns: topClusters.length,
-				entriesAnalyzed: recentEntries.length,
-				touched: touchedKeys.size
-			}, "REM pattern discovery complete");
-			await writeLastRun(params.dreamingRoot, {
-				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
-			};
-		});
+		}
+		const selected = patterns.flatMap((pattern) => pattern.records.map((record) => record.id));
+		const reason = patterns.length === 0 ? "not enough evidence for recurring patterns" : canPropose ? "pattern candidates added for user review" : "patterns analyzed in observe mode";
+		trace(params, reason, selected, written, started);
+		log.info({
+			workspaceDir: params.workspaceDir,
+			patterns: patterns.length,
+			written,
+			canPropose
+		}, "REM pattern discovery complete");
+		return {
+			ok: true,
+			reason,
+			patternsDiscovered: patterns.length,
+			entriesAnalyzed: new Set(signals.map((signal) => signal.recordId)).size
+		};
 	} catch (err) {
-		const errorMessage = err instanceof Error ? err.message : String(err);
-		log.error({
-			err,
-			errorMessage,
-			dreamingRoot: params.dreamingRoot
-		}, `REM pattern discovery failed: ${errorMessage}`);
-		await writeLastRun(params.dreamingRoot, {
-			runId,
-			startedAt,
-			cfg,
-			ok: false,
-			reason: `REM error: ${errorMessage}`,
-			startMs,
-			rem: {
-				patternsDiscovered: 0,
-				entriesAnalyzed: 0
-			},
-			errorMessage
-		}).catch(() => void 0);
+		const reason = err instanceof Error ? err.message : String(err);
+		appendMemoryTraceEvent({
+			phase: "dreaming_rem",
+			providerId: "local",
+			sourceAgentId: params.agentId,
+			request: { workspaceId: params.workspaceDir },
+			error: reason,
+			durationMs: Date.now() - started
+		});
 		return {
 			ok: false,
-			reason: errorMessage,
+			reason,
 			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(dreamingRoot, clusters, now) {
-	const dreamsPath = path.join(dreamingRoot, DREAMS_MD_FILENAME);
-	const existing = await fs.readFile(dreamsPath, "utf-8").catch((err) => {
-		if (err?.code === "ENOENT") return "";
-		throw err;
+function trace(params, reason, selectedRecordIds, written, started) {
+	appendMemoryTraceEvent({
+		phase: "dreaming_rem",
+		providerId: "local",
+		sourceAgentId: params.agentId,
+		request: {
+			workspaceId: params.workspaceDir,
+			reason,
+			written
+		},
+		resultCount: selectedRecordIds.length,
+		selectedRecordIds,
+		durationMs: Date.now() - started
 	});
-	const day = isoDay(now);
-	const lines = [];
-	const newClusters = clusters.filter((cluster) => !existing.includes(`xopc-rem-pattern id="${remPatternKey(cluster.members.map((member) => member.key))}"`));
-	if (newClusters.length === 0) return;
-	if (existing.trim().length === 0) lines.push("# Dream Diary", "");
-	lines.push(`## REM Pattern Discovery — ${day}`, "");
-	lines.push(`*${now.toISOString()}*`, "");
-	for (let i = 0; i < newClusters.length; i++) {
-		const cluster = newClusters[i];
-		lines.push(`<!-- xopc-rem-pattern id="${remPatternKey(cluster.members.map((member) => member.key))}" -->`);
-		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(dreamingRoot, 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(dreamingRoot, 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 };

package/dist/src/agent/memory/dreaming/runner.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from '../../../config/schema.js';
+import { type DreamingPhase, type DreamingRun } from '../../../storage/sqlite/index.js';
+export declare function runDreamingPhase(input: {
+    config: Config;
+    phase: DreamingPhase;
+    triggerKind: 'schedule' | 'manual';
+}): Promise<{
+    run: DreamingRun;
+    result: Record<string, unknown>;
+}>;

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

@@ -0,0 +1,78 @@
+import { finishDreamingRun, startDreamingRun } from "../../../storage/sqlite/dreaming-repository.js";
+import "../../../storage/sqlite/index.js";
+import { DREAMING_ALGORITHM_VERSION } from "./constants.js";
+import { runDreamingDeepPromotion } from "./deep-promotion.js";
+import { runLightSweep } from "./light-sweep.js";
+import { runRemPatterns } from "./rem-patterns.js";
+import { resolveDreamingAgentScope } from "./scope.js";
+//#region src/agent/memory/dreaming/runner.ts
+async function runDreamingPhase(input) {
+	const scope = resolveDreamingAgentScope(input.config);
+	const resolved = scope.config;
+	if (resolved.mode === "off") throw new Error("Dreaming is off");
+	if (input.triggerKind === "schedule" && !resolved.phases[input.phase].enabled) throw new Error(`Dreaming ${input.phase} schedule is disabled`);
+	const forceManualRun = input.triggerKind === "manual";
+	const run = startDreamingRun({
+		agentId: scope.agentId,
+		workspaceId: scope.workspaceDir,
+		phase: input.phase,
+		mode: resolved.mode,
+		triggerKind: input.triggerKind,
+		algorithmVersion: DREAMING_ALGORITHM_VERSION,
+		configSnapshot: resolved
+	});
+	try {
+		let result;
+		if (input.phase === "light") result = await runLightSweep({
+			runId: run.runId,
+			workspaceDir: scope.workspaceDir,
+			config: {
+				...resolved.phases.light,
+				enabled: forceManualRun || resolved.phases.light.enabled
+			}
+		});
+		else if (input.phase === "deep") result = await runDreamingDeepPromotion({
+			runId: run.runId,
+			mode: resolved.mode,
+			agentId: scope.agentId,
+			workspaceDir: scope.workspaceDir,
+			config: {
+				...resolved.phases.deep,
+				enabled: forceManualRun || resolved.phases.deep.enabled
+			},
+			sensitiveWritePolicy: input.config.userContext.privacy.sensitiveWritePolicy
+		});
+		else result = await runRemPatterns({
+			runId: run.runId,
+			mode: resolved.mode,
+			agentId: scope.agentId,
+			workspaceDir: scope.workspaceDir,
+			config: {
+				...resolved.phases.rem,
+				enabled: forceManualRun || resolved.phases.rem.enabled
+			},
+			sensitiveWritePolicy: input.config.userContext.privacy.sensitiveWritePolicy
+		});
+		const ok = result.ok === true;
+		const reason = typeof result.reason === "string" ? result.reason : ok ? "completed" : "failed";
+		return {
+			run: finishDreamingRun({
+				runId: run.runId,
+				ok,
+				reason,
+				metrics: result
+			}) ?? run,
+			result
+		};
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		finishDreamingRun({
+			runId: run.runId,
+			ok: false,
+			reason
+		});
+		throw error;
+	}
+}
+//#endregion
+export { runDreamingPhase };

package/dist/src/agent/memory/dreaming/schedule.d.ts

@@ -0,0 +1,23 @@
+import type { DreamingSchedule } from '../../../user-context/config.js';
+export declare const DEFAULT_DREAMING_SCHEDULES: {
+    readonly light: {
+        readonly kind: "interval";
+        readonly everyHours: 6;
+        readonly minute: 0;
+    };
+    readonly deep: {
+        readonly kind: "daily";
+        readonly time: "03:00";
+    };
+    readonly rem: {
+        readonly kind: "weekly";
+        readonly weekday: 0;
+        readonly time: "05:00";
+    };
+};
+export declare function resolveDreamingTimezone(timezone?: string): string;
+export declare function compileDreamingSchedule(schedule: DreamingSchedule): string;
+export declare function nextDreamingRunTimes(schedule: DreamingSchedule, timezone: string, options?: {
+    fromMs?: number;
+    limit?: number;
+}): string[];

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

@@ -0,0 +1,38 @@
+import { CronExpressionParser } from "cron-parser";
+//#region src/agent/memory/dreaming/schedule.ts
+const DEFAULT_DREAMING_SCHEDULES = {
+	light: {
+		kind: "interval",
+		everyHours: 6,
+		minute: 0
+	},
+	deep: {
+		kind: "daily",
+		time: "03:00"
+	},
+	rem: {
+		kind: "weekly",
+		weekday: 0,
+		time: "05:00"
+	}
+};
+function resolveDreamingTimezone(timezone) {
+	if (timezone) return timezone;
+	return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+}
+function compileDreamingSchedule(schedule) {
+	if (schedule.kind === "interval") return `${schedule.minute} */${schedule.everyHours} * * *`;
+	const [hour, minute] = schedule.time.split(":").map(Number);
+	if (schedule.kind === "daily") return `${minute} ${hour} * * *`;
+	return `${minute} ${hour} * * ${schedule.weekday}`;
+}
+function nextDreamingRunTimes(schedule, timezone, options = {}) {
+	const limit = Math.max(0, Math.min(10, options.limit ?? 3));
+	const expression = CronExpressionParser.parse(compileDreamingSchedule(schedule), {
+		currentDate: new Date(options.fromMs ?? Date.now()),
+		tz: timezone
+	});
+	return Array.from({ length: limit }, () => expression.next().toISOString());
+}
+//#endregion
+export { DEFAULT_DREAMING_SCHEDULES, compileDreamingSchedule, nextDreamingRunTimes, resolveDreamingTimezone };

package/dist/src/agent/memory/dreaming/scope.d.ts

@@ -1,13 +1,11 @@
 import type { Config } from '../../../config/schema.js';
+import { type MemoryReadiness } from '../../../user-context/memory-readiness.js';
 import type { DreamingResolvedConfig } from './config.js';
 export type DreamingAgentScope = {
     agentId: string;
     workspaceDir: string;
-    memoriesDir: string;
-    memoryPath: string;
-    dreamsPath: string;
     config: DreamingResolvedConfig;
+    readiness: MemoryReadiness;
     memory: Config['userContext']['memory'];
 };
-export declare function resolveDreamingRoot(): string;
 export declare function resolveDreamingAgentScope(config: Config, requestedAgentId?: string | null): DreamingAgentScope;

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

@@ -1,25 +1,33 @@
+import { isXopcDatabaseOpen } from "../../../storage/sqlite/connection.js";
+import { evaluateMemoryReadiness } from "../../../user-context/memory-readiness.js";
+import { getMemoryReadiness } from "../../../storage/sqlite/memory-readiness-repository.js";
+import "../../../storage/sqlite/index.js";
 import { init_agent_scope, normalizeAgentId, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../../agent-scope.js";
-import { init_paths, resolveUserDir } from "../../../config/paths.js";
 import { resolveDreamingConfig } from "./config.js";
-import path from "node:path";
 //#region src/agent/memory/dreaming/scope.ts
 init_agent_scope();
-init_paths();
-function resolveDreamingRoot() {
-	return path.join(resolveUserDir(), "memories");
-}
 function resolveDreamingAgentScope(config, requestedAgentId) {
 	const agentId = normalizeAgentId(requestedAgentId || resolveDefaultAgentId(config));
-	const memoriesDir = resolveDreamingRoot();
+	const workspaceDir = resolveAgentWorkspaceDir(config, agentId);
+	const readiness = isXopcDatabaseOpen() ? getMemoryReadiness({
+		agentId,
+		workspaceId: workspaceDir
+	}) : evaluateMemoryReadiness({
+		evaluatedTurns: 0,
+		helpfulTurns: 0,
+		recordFeedback: 0,
+		recordErrors: 0,
+		sensitiveFeedback: 0,
+		dreamingRuns: 0,
+		dreamingFailures: 0
+	});
 	return {
 		agentId,
-		workspaceDir: resolveAgentWorkspaceDir(config, agentId),
-		memoriesDir,
-		memoryPath: path.join(memoriesDir, "MEMORY.md"),
-		dreamsPath: path.join(memoriesDir, "DREAMS.md"),
-		config: resolveDreamingConfig(config, agentId),
+		workspaceDir,
+		config: resolveDreamingConfig(config, { automaticReady: readiness.ready }),
+		readiness,
 		memory: config.userContext.memory
 	};
 }
 //#endregion
-export { resolveDreamingAgentScope, resolveDreamingRoot };
+export { resolveDreamingAgentScope };