@xopcai/xopc 0.0.24 → 0.0.26

package/dist/src/agent/memory/dreaming/last-run.d.ts

@@ -0,0 +1,80 @@
+import type { DreamingDeepConfig, DreamingLightConfig, DreamingRemConfig } from './config.js';
+export declare const DREAMING_LAST_RUN_FORMAT_VERSION: 2;
+export type { DreamingDeepConfig } from './config.js';
+export type DreamingDeepPhaseSkipped = {
+    alreadyPromotedKey: number;
+    rehydrateFailed: number;
+    contaminated: number;
+    hashDuplicate: number;
+};
+/**
+ * On-disk / API shape for `memory/.dreams/last-run.json` (deep promotion sweep).
+ */
+export type DreamingDeepLastRun = {
+    version: typeof DREAMING_LAST_RUN_FORMAT_VERSION;
+    phase: 'deep';
+    runId: string;
+    startedAt: string;
+    finishedAt: string;
+    durationMs: number;
+    ok: boolean;
+    reason: string;
+    config: DreamingDeepConfig;
+    memoryPath: string;
+    errorMessage?: string;
+    deep: {
+        candidatesRanked: number;
+        applied: number;
+        skipped: DreamingDeepPhaseSkipped;
+    };
+};
+/**
+ * On-disk shape for light sweep last-run.
+ */
+export type DreamingLightLastRun = {
+    version: typeof DREAMING_LAST_RUN_FORMAT_VERSION;
+    phase: 'light';
+    runId: string;
+    startedAt: string;
+    finishedAt: string;
+    durationMs: number;
+    ok: boolean;
+    reason: string;
+    config: DreamingLightConfig;
+    light: {
+        scannedEntries: number;
+        newSignals: number;
+        deduped: number;
+    };
+    errorMessage?: string;
+};
+/**
+ * On-disk shape for REM pattern last-run.
+ */
+export type DreamingRemLastRun = {
+    version: typeof DREAMING_LAST_RUN_FORMAT_VERSION;
+    phase: 'rem';
+    runId: string;
+    startedAt: string;
+    finishedAt: string;
+    durationMs: number;
+    ok: boolean;
+    reason: string;
+    config: DreamingRemConfig;
+    rem: {
+        patternsDiscovered: number;
+        entriesAnalyzed: number;
+    };
+    errorMessage?: string;
+};
+/** Union of all phase last-run shapes. */
+export type DreamingLastRun = DreamingDeepLastRun | DreamingLightLastRun | DreamingRemLastRun;
+/**
+ * Parse `last-run.json`. Only the current on-disk format (`version: 2`, `phase: 'deep'`) is accepted.
+ */
+export declare function parseDreamingLastRunFile(raw: unknown): DreamingDeepLastRun | null;
+export declare function emptyDeepPhaseSkipped(): DreamingDeepPhaseSkipped;
+export declare function writeDreamingDeepLastRun(params: {
+    workspaceDir: string;
+    lastRun: DreamingDeepLastRun;
+}): Promise<void>;

package/dist/src/agent/memory/dreaming/last-run.js

@@ -0,0 +1,98 @@
+import { DREAMING_LAST_RUN_RELATIVE } from "./constants.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region src/agent/memory/dreaming/last-run.ts
+const DREAMING_LAST_RUN_FORMAT_VERSION = 2;
+function isRecord(v) {
+	return v !== null && typeof v === "object" && !Array.isArray(v);
+}
+function asNonNegInt(v) {
+	if (typeof v === "number" && Number.isFinite(v)) return Math.max(0, Math.floor(v));
+	if (typeof v === "string" && v.trim() && Number.isFinite(Number(v))) return Math.max(0, Math.floor(Number(v)));
+	return 0;
+}
+function asDreamingDeepConfig(v) {
+	if (!isRecord(v)) return null;
+	return {
+		enabled: v.enabled === true,
+		cron: typeof v.cron === "string" ? v.cron : "0 3 * * *",
+		minScore: typeof v.minScore === "number" && Number.isFinite(v.minScore) ? v.minScore : 0,
+		minRecallCount: asNonNegInt(v.minRecallCount) || 1,
+		minUniqueQueries: asNonNegInt(v.minUniqueQueries) || 3,
+		limit: asNonNegInt(v.limit),
+		recencyHalfLifeDays: asNonNegInt(v.recencyHalfLifeDays) || 14,
+		maxAgeDays: asNonNegInt(v.maxAgeDays) || 30
+	};
+}
+const EMPTY_SKIPPED = {
+	alreadyPromotedKey: 0,
+	rehydrateFailed: 0,
+	contaminated: 0,
+	hashDuplicate: 0
+};
+function parseSkippedStrict(raw) {
+	if (!isRecord(raw)) return null;
+	if (typeof raw.alreadyPromotedKey !== "number" || !Number.isFinite(raw.alreadyPromotedKey) || typeof raw.rehydrateFailed !== "number" || !Number.isFinite(raw.rehydrateFailed) || typeof raw.contaminated !== "number" || !Number.isFinite(raw.contaminated) || typeof raw.hashDuplicate !== "number" || !Number.isFinite(raw.hashDuplicate)) return null;
+	return {
+		alreadyPromotedKey: Math.max(0, Math.floor(raw.alreadyPromotedKey)),
+		rehydrateFailed: Math.max(0, Math.floor(raw.rehydrateFailed)),
+		contaminated: Math.max(0, Math.floor(raw.contaminated)),
+		hashDuplicate: Math.max(0, Math.floor(raw.hashDuplicate))
+	};
+}
+/**
+* Parse `last-run.json`. Only the current on-disk format (`version: 2`, `phase: 'deep'`) is accepted.
+*/
+function parseDreamingLastRunFile(raw) {
+	if (!isRecord(raw)) return null;
+	if (raw.version !== 2 || raw.phase !== "deep") return null;
+	if (typeof raw.runId !== "string" || !raw.runId.trim()) return null;
+	if (typeof raw.startedAt !== "string" || typeof raw.finishedAt !== "string") return null;
+	if (!raw.startedAt.trim() || !raw.finishedAt.trim()) return null;
+	if (typeof raw.durationMs !== "number" || !Number.isFinite(raw.durationMs) || raw.durationMs < 0) return null;
+	if (raw.ok !== true && raw.ok !== false) return null;
+	if (typeof raw.reason !== "string") return null;
+	const config = asDreamingDeepConfig(raw.config);
+	if (!config) return null;
+	if (typeof raw.memoryPath !== "string" || !raw.memoryPath.trim()) return null;
+	const deepRaw = raw.deep;
+	if (!isRecord(deepRaw)) return null;
+	if (typeof deepRaw.candidatesRanked !== "number" || !Number.isFinite(deepRaw.candidatesRanked)) return null;
+	if (typeof deepRaw.applied !== "number" || !Number.isFinite(deepRaw.applied)) return null;
+	const skipped = parseSkippedStrict(deepRaw.skipped);
+	if (!skipped) return null;
+	const err = raw.errorMessage;
+	const errMsg = typeof err === "string" && err.trim() ? err.trim() : void 0;
+	return {
+		version: 2,
+		phase: "deep",
+		runId: raw.runId.trim(),
+		startedAt: raw.startedAt,
+		finishedAt: raw.finishedAt,
+		durationMs: Math.max(0, Math.floor(raw.durationMs)),
+		ok: raw.ok === true,
+		reason: raw.reason,
+		config,
+		memoryPath: raw.memoryPath,
+		...errMsg ? { errorMessage: errMsg } : {},
+		deep: {
+			candidatesRanked: Math.max(0, Math.floor(deepRaw.candidatesRanked)),
+			applied: Math.max(0, Math.floor(deepRaw.applied)),
+			skipped
+		}
+	};
+}
+function emptyDeepPhaseSkipped() {
+	return { ...EMPTY_SKIPPED };
+}
+async function writeDreamingDeepLastRun(params) {
+	const fullPath = path.join(params.workspaceDir, DREAMING_LAST_RUN_RELATIVE);
+	await fs.mkdir(path.dirname(fullPath), { recursive: true });
+	const tmp = `${fullPath}.${process.pid}.${Date.now()}.tmp`;
+	await fs.writeFile(tmp, `${JSON.stringify(params.lastRun, null, 2)}\n`, "utf-8");
+	await fs.rename(tmp, fullPath);
+}
+//#endregion
+export { DREAMING_LAST_RUN_FORMAT_VERSION, emptyDeepPhaseSkipped, parseDreamingLastRunFile, writeDreamingDeepLastRun };
+
+//# sourceMappingURL=last-run.js.map

package/dist/src/agent/memory/dreaming/last-run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"last-run.js","names":[],"sources":["../../../../../src/agent/memory/dreaming/last-run.ts"],"sourcesContent":["import fs from 'node:fs/promises';\nimport path from 'node:path';\n\nimport { DREAMING_LAST_RUN_RELATIVE } from './constants.js';\nimport type { DreamingDeepConfig, DreamingLightConfig, DreamingRemConfig } from './config.js';\n\nexport const DREAMING_LAST_RUN_FORMAT_VERSION = 2 as const;\n\nexport type { DreamingDeepConfig } from './config.js';\n\nexport type DreamingDeepPhaseSkipped = {\n  alreadyPromotedKey: number;\n  rehydrateFailed: number;\n  contaminated: number;\n  hashDuplicate: number;\n};\n\n/**\n * On-disk / API shape for `memory/.dreams/last-run.json` (deep promotion sweep).\n */\nexport type DreamingDeepLastRun = {\n  version: typeof DREAMING_LAST_RUN_FORMAT_VERSION;\n  phase: 'deep';\n  runId: string;\n  startedAt: string;\n  finishedAt: string;\n  durationMs: number;\n  ok: boolean;\n  reason: string;\n  config: DreamingDeepConfig;\n  memoryPath: string;\n  errorMessage?: string;\n  deep: {\n    candidatesRanked: number;\n    applied: number;\n    skipped: DreamingDeepPhaseSkipped;\n  };\n};\n\n/**\n * On-disk shape for light sweep last-run.\n */\nexport type DreamingLightLastRun = {\n  version: typeof DREAMING_LAST_RUN_FORMAT_VERSION;\n  phase: 'light';\n  runId: string;\n  startedAt: string;\n  finishedAt: string;\n  durationMs: number;\n  ok: boolean;\n  reason: string;\n  config: DreamingLightConfig;\n  light: {\n    scannedEntries: number;\n    newSignals: number;\n    deduped: number;\n  };\n  errorMessage?: string;\n};\n\n/**\n * On-disk shape for REM pattern last-run.\n */\nexport type DreamingRemLastRun = {\n  version: typeof DREAMING_LAST_RUN_FORMAT_VERSION;\n  phase: 'rem';\n  runId: string;\n  startedAt: string;\n  finishedAt: string;\n  durationMs: number;\n  ok: boolean;\n  reason: string;\n  config: DreamingRemConfig;\n  rem: {\n    patternsDiscovered: number;\n    entriesAnalyzed: number;\n  };\n  errorMessage?: string;\n};\n\n/** Union of all phase last-run shapes. */\nexport type DreamingLastRun = DreamingDeepLastRun | DreamingLightLastRun | DreamingRemLastRun;\n\nfunction isRecord(v: unknown): v is Record<string, unknown> {\n  return v !== null && typeof v === 'object' && !Array.isArray(v);\n}\n\nfunction asNonNegInt(v: unknown): number {\n  if (typeof v === 'number' && Number.isFinite(v)) return Math.max(0, Math.floor(v));\n  if (typeof v === 'string' && v.trim() && Number.isFinite(Number(v))) {\n    return Math.max(0, Math.floor(Number(v)));\n  }\n  return 0;\n}\n\nfunction asDreamingDeepConfig(v: unknown): DreamingDeepConfig | null {\n  if (!isRecord(v)) return null;\n  return {\n    enabled: v.enabled === true,\n    cron: typeof v.cron === 'string' ? v.cron : '0 3 * * *',\n    minScore: typeof v.minScore === 'number' && Number.isFinite(v.minScore) ? v.minScore : 0,\n    minRecallCount: asNonNegInt(v.minRecallCount) || 1,\n    minUniqueQueries: asNonNegInt(v.minUniqueQueries) || 3,\n    limit: asNonNegInt(v.limit),\n    recencyHalfLifeDays: asNonNegInt(v.recencyHalfLifeDays) || 14,\n    maxAgeDays: asNonNegInt(v.maxAgeDays) || 30,\n  };\n}\n\nconst EMPTY_SKIPPED: DreamingDeepPhaseSkipped = {\n  alreadyPromotedKey: 0,\n  rehydrateFailed: 0,\n  contaminated: 0,\n  hashDuplicate: 0,\n};\n\nfunction parseSkippedStrict(raw: unknown): DreamingDeepPhaseSkipped | null {\n  if (!isRecord(raw)) return null;\n  if (\n    typeof raw.alreadyPromotedKey !== 'number' ||\n    !Number.isFinite(raw.alreadyPromotedKey) ||\n    typeof raw.rehydrateFailed !== 'number' ||\n    !Number.isFinite(raw.rehydrateFailed) ||\n    typeof raw.contaminated !== 'number' ||\n    !Number.isFinite(raw.contaminated) ||\n    typeof raw.hashDuplicate !== 'number' ||\n    !Number.isFinite(raw.hashDuplicate)\n  ) {\n    return null;\n  }\n  return {\n    alreadyPromotedKey: Math.max(0, Math.floor(raw.alreadyPromotedKey)),\n    rehydrateFailed: Math.max(0, Math.floor(raw.rehydrateFailed)),\n    contaminated: Math.max(0, Math.floor(raw.contaminated)),\n    hashDuplicate: Math.max(0, Math.floor(raw.hashDuplicate)),\n  };\n}\n\n/**\n * Parse `last-run.json`. Only the current on-disk format (`version: 2`, `phase: 'deep'`) is accepted.\n */\nexport function parseDreamingLastRunFile(raw: unknown): DreamingDeepLastRun | null {\n  if (!isRecord(raw)) return null;\n  if (raw.version !== DREAMING_LAST_RUN_FORMAT_VERSION || raw.phase !== 'deep') return null;\n\n  if (typeof raw.runId !== 'string' || !raw.runId.trim()) return null;\n  if (typeof raw.startedAt !== 'string' || typeof raw.finishedAt !== 'string') return null;\n  if (!raw.startedAt.trim() || !raw.finishedAt.trim()) return null;\n\n  if (typeof raw.durationMs !== 'number' || !Number.isFinite(raw.durationMs) || raw.durationMs < 0) {\n    return null;\n  }\n  if (raw.ok !== true && raw.ok !== false) return null;\n  if (typeof raw.reason !== 'string') return null;\n\n  const config = asDreamingDeepConfig(raw.config);\n  if (!config) return null;\n  if (typeof raw.memoryPath !== 'string' || !raw.memoryPath.trim()) return null;\n\n  const deepRaw = raw.deep;\n  if (!isRecord(deepRaw)) return null;\n  if (typeof deepRaw.candidatesRanked !== 'number' || !Number.isFinite(deepRaw.candidatesRanked)) {\n    return null;\n  }\n  if (typeof deepRaw.applied !== 'number' || !Number.isFinite(deepRaw.applied)) return null;\n  const skipped = parseSkippedStrict(deepRaw.skipped);\n  if (!skipped) return null;\n\n  const err = raw.errorMessage;\n  const errMsg = typeof err === 'string' && err.trim() ? err.trim() : undefined;\n\n  return {\n    version: DREAMING_LAST_RUN_FORMAT_VERSION,\n    phase: 'deep',\n    runId: raw.runId.trim(),\n    startedAt: raw.startedAt,\n    finishedAt: raw.finishedAt,\n    durationMs: Math.max(0, Math.floor(raw.durationMs)),\n    ok: raw.ok === true,\n    reason: raw.reason,\n    config,\n    memoryPath: raw.memoryPath,\n    ...(errMsg ? { errorMessage: errMsg } : {}),\n    deep: {\n      candidatesRanked: Math.max(0, Math.floor(deepRaw.candidatesRanked)),\n      applied: Math.max(0, Math.floor(deepRaw.applied)),\n      skipped,\n    },\n  };\n}\n\nexport function emptyDeepPhaseSkipped(): DreamingDeepPhaseSkipped {\n  return { ...EMPTY_SKIPPED };\n}\n\nexport async function writeDreamingDeepLastRun(params: {\n  workspaceDir: string;\n  lastRun: DreamingDeepLastRun;\n}): Promise<void> {\n  const fullPath = path.join(params.workspaceDir, DREAMING_LAST_RUN_RELATIVE);\n  await fs.mkdir(path.dirname(fullPath), { recursive: true });\n  const tmp = `${fullPath}.${process.pid}.${Date.now()}.tmp`;\n  await fs.writeFile(tmp, `${JSON.stringify(params.lastRun, null, 2)}\\n`, 'utf-8');\n  await fs.rename(tmp, fullPath);\n}\n"],"mappings":"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"}

package/dist/src/agent/memory/dreaming/light-sweep.d.ts

@@ -0,0 +1,19 @@
+import type { DreamingLightConfig } from './config.js';
+/**
+ * Scan recent daily memory files (memory/YYYY-MM-DD.md) and collect signal
+ * entries into the short-term store. Deduplicates near-identical snippets
+ * using trigram similarity.
+ *
+ * This is the "light sleep" phase: fast, frequent, cheap.
+ */
+export declare function runLightSweep(params: {
+    workspaceDir: string;
+    config?: Partial<DreamingLightConfig>;
+    now?: Date;
+}): Promise<{
+    ok: boolean;
+    reason: string;
+    scannedEntries: number;
+    newSignals: number;
+    deduped: number;
+}>;

package/dist/src/agent/memory/dreaming/light-sweep.js

@@ -0,0 +1,328 @@
+import { createLogger } from "../../../utils/logger/index.js";
+import { init_logger } from "../../../utils/logger.js";
+import { DREAMING_DIR_RELATIVE } from "./constants.js";
+import { buildEntryKey, isoDay, normalizeMemoryPath, normalizeSnippetForHash, snippetHash } 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/light-sweep.ts
+init_logger();
+const log = createLogger("Dreaming:Light");
+function isDailyMemoryFile(filename) {
+	return /^\d{4}-\d{2}-\d{2}\.md$/i.test(filename);
+}
+/**
+* Cosine-ish similarity via character n-gram overlap.
+* Fast and deterministic — no embeddings required.
+*/
+function trigramSimilarity(textA, textB) {
+	const normalizedA = normalizeSnippetForHash(textA);
+	const normalizedB = normalizeSnippetForHash(textB);
+	if (!normalizedA || !normalizedB) return 0;
+	if (normalizedA === normalizedB) return 1;
+	const gramsA = buildTrigramSet(normalizedA);
+	const gramsB = buildTrigramSet(normalizedB);
+	if (gramsA.size === 0 || gramsB.size === 0) return 0;
+	let intersection = 0;
+	for (const gram of gramsA) if (gramsB.has(gram)) intersection += 1;
+	return intersection / Math.sqrt(gramsA.size * gramsB.size);
+}
+function buildTrigramSet(text) {
+	const grams = /* @__PURE__ */ new Set();
+	for (let i = 0; i <= text.length - 3; i++) grams.add(text.slice(i, i + 3));
+	return grams;
+}
+function resolveConfig(overrides) {
+	return {
+		enabled: overrides?.enabled === true,
+		cron: typeof overrides?.cron === "string" ? overrides.cron : "0 */6 * * *",
+		lookbackDays: Math.max(1, Math.floor(Number(overrides?.lookbackDays) || 2)),
+		limit: Math.max(0, Math.floor(Number(overrides?.limit) || 100)),
+		dedupeSimilarity: Math.max(0, Math.min(1, Number(overrides?.dedupeSimilarity) || .9))
+	};
+}
+/**
+* Scan recent daily memory files (memory/YYYY-MM-DD.md) and collect signal
+* entries into the short-term store. Deduplicates near-identical snippets
+* using trigram similarity.
+*
+* This is the "light sleep" phase: fast, frequent, cheap.
+*/
+async function runLightSweep(params) {
+	const cfg = resolveConfig(params.config);
+	const now = params.now ?? /* @__PURE__ */ new Date();
+	const startedAt = now.toISOString();
+	const runId = `light:${startedAt}:${process.pid}`;
+	const startMs = Date.now();
+	if (!cfg.enabled) {
+		await writeLastRun(params.workspaceDir, {
+			runId,
+			startedAt,
+			cfg,
+			ok: true,
+			reason: "light sweep disabled",
+			startMs,
+			light: {
+				scannedEntries: 0,
+				newSignals: 0,
+				deduped: 0
+			}
+		});
+		return {
+			ok: true,
+			reason: "light sweep disabled",
+			scannedEntries: 0,
+			newSignals: 0,
+			deduped: 0
+		};
+	}
+	try {
+		const recentFiles = await listRecentDailyFiles(path.join(params.workspaceDir, "memory"), cfg.lookbackDays, now);
+		if (recentFiles.length === 0) {
+			await writeLastRun(params.workspaceDir, {
+				runId,
+				startedAt,
+				cfg,
+				ok: true,
+				reason: "no recent daily files",
+				startMs,
+				light: {
+					scannedEntries: 0,
+					newSignals: 0,
+					deduped: 0
+				}
+			});
+			return {
+				ok: true,
+				reason: "no recent daily files",
+				scannedEntries: 0,
+				newSignals: 0,
+				deduped: 0
+			};
+		}
+		const allChunks = [];
+		for (const filePath of recentFiles) {
+			const chunks = await parseFileChunks(filePath, params.workspaceDir);
+			allChunks.push(...chunks);
+		}
+		if (allChunks.length === 0) {
+			await writeLastRun(params.workspaceDir, {
+				runId,
+				startedAt,
+				cfg,
+				ok: true,
+				reason: "no chunks found in daily files",
+				startMs,
+				light: {
+					scannedEntries: 0,
+					newSignals: 0,
+					deduped: 0
+				}
+			});
+			return {
+				ok: true,
+				reason: "no chunks found in daily files",
+				scannedEntries: 0,
+				newSignals: 0,
+				deduped: 0
+			};
+		}
+		const { unique, deduped } = deduplicateChunks(allChunks, cfg.dedupeSimilarity);
+		const capped = unique.slice(0, cfg.limit);
+		const { store } = await loadDreamingStore({ workspaceDir: params.workspaceDir });
+		let newSignals = 0;
+		const dayBucket = isoDay(now);
+		const nowIso = now.toISOString();
+		for (const chunk of capped) {
+			const key = buildEntryKey({
+				path: chunk.path,
+				startLine: chunk.startLine,
+				endLine: chunk.endLine
+			});
+			const existing = store.entries[key];
+			if (existing) {
+				bumpEntryPhaseSignal(existing, "lightHits");
+				bumpEntryPhaseSignal(existing, "dailyCount");
+				existing.snippet = chunk.text.slice(0, 360);
+				existing.lastRecalledAt = nowIso;
+			} else {
+				store.entries[key] = {
+					key,
+					path: chunk.path,
+					startLine: chunk.startLine,
+					endLine: chunk.endLine,
+					snippet: chunk.text.slice(0, 360),
+					recallCount: 0,
+					dailyCount: 1,
+					groundedCount: 0,
+					lightHits: 1,
+					remHits: 0,
+					phaseHitCount: 1,
+					totalSignalCount: 1,
+					totalScore: 0,
+					maxScore: 0,
+					queryHashes: [],
+					recallDays: [dayBucket],
+					firstRecalledAt: nowIso,
+					lastRecalledAt: nowIso
+				};
+				newSignals += 1;
+			}
+		}
+		store.updatedAt = nowIso;
+		await saveDreamingStore({
+			workspaceDir: params.workspaceDir,
+			store
+		});
+		log.info({
+			workspaceDir: params.workspaceDir,
+			scanned: allChunks.length,
+			newSignals,
+			deduped
+		}, "Light sweep complete");
+		await writeLastRun(params.workspaceDir, {
+			runId,
+			startedAt,
+			cfg,
+			ok: true,
+			reason: "light sweep complete",
+			startMs,
+			light: {
+				scannedEntries: allChunks.length,
+				newSignals,
+				deduped
+			}
+		});
+		return {
+			ok: true,
+			reason: "light sweep complete",
+			scannedEntries: allChunks.length,
+			newSignals,
+			deduped
+		};
+	} catch (err) {
+		const errorMessage = err instanceof Error ? err.message : String(err);
+		log.error({
+			err,
+			errorMessage,
+			workspaceDir: params.workspaceDir
+		}, `Light sweep failed: ${errorMessage}`);
+		await writeLastRun(params.workspaceDir, {
+			runId,
+			startedAt,
+			cfg,
+			ok: false,
+			reason: `light sweep error: ${errorMessage}`,
+			startMs,
+			light: {
+				scannedEntries: 0,
+				newSignals: 0,
+				deduped: 0
+			},
+			errorMessage
+		}).catch(() => void 0);
+		return {
+			ok: false,
+			reason: errorMessage,
+			scannedEntries: 0,
+			newSignals: 0,
+			deduped: 0
+		};
+	}
+}
+async function listRecentDailyFiles(memoryDir, lookbackDays, now) {
+	let entries;
+	try {
+		entries = await fs.readdir(memoryDir);
+	} catch (err) {
+		if (err?.code === "ENOENT") return [];
+		throw err;
+	}
+	const cutoff = new Date(now);
+	cutoff.setDate(cutoff.getDate() - lookbackDays);
+	const cutoffDay = isoDay(cutoff);
+	return entries.filter((name) => isDailyMemoryFile(name)).filter((name) => {
+		return name.replace(/\.md$/i, "") >= cutoffDay;
+	}).sort().map((name) => path.join(memoryDir, name));
+}
+async function parseFileChunks(filePath, workspaceDir) {
+	let raw;
+	try {
+		raw = await fs.readFile(filePath, "utf-8");
+	} catch {
+		return [];
+	}
+	const relativePath = normalizeMemoryPath(path.relative(workspaceDir, filePath));
+	const lines = raw.split(/\r?\n/);
+	const chunks = [];
+	let chunkStartLine = 1;
+	let currentLines = [];
+	for (let i = 0; i < lines.length; i++) {
+		const trimmed = lines[i].trim();
+		if (trimmed.length === 0) {
+			if (currentLines.length > 0) {
+				const text = currentLines.join(" ").replace(/\s+/g, " ").trim();
+				if (text.length >= 20) chunks.push({
+					path: relativePath,
+					startLine: chunkStartLine,
+					endLine: chunkStartLine + currentLines.length - 1,
+					text: text.slice(0, 360),
+					hash: snippetHash(text)
+				});
+				currentLines = [];
+			}
+			chunkStartLine = i + 2;
+		} else {
+			if (currentLines.length === 0) chunkStartLine = i + 1;
+			currentLines.push(trimmed);
+		}
+	}
+	if (currentLines.length > 0) {
+		const text = currentLines.join(" ").replace(/\s+/g, " ").trim();
+		if (text.length >= 20) chunks.push({
+			path: relativePath,
+			startLine: chunkStartLine,
+			endLine: chunkStartLine + currentLines.length - 1,
+			text: text.slice(0, 360),
+			hash: snippetHash(text)
+		});
+	}
+	return chunks;
+}
+function deduplicateChunks(chunks, threshold) {
+	const unique = [];
+	let deduped = 0;
+	for (const chunk of chunks) if (unique.some((existing) => existing.hash === chunk.hash || trigramSimilarity(existing.text, chunk.text) >= threshold)) deduped += 1;
+	else unique.push(chunk);
+	return {
+		unique,
+		deduped
+	};
+}
+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: "light",
+		runId: params.runId,
+		startedAt: params.startedAt,
+		finishedAt,
+		durationMs,
+		ok: params.ok,
+		reason: params.reason,
+		config: params.cfg,
+		light: params.light,
+		...params.errorMessage ? { errorMessage: params.errorMessage } : {}
+	};
+	const lastRunPath = path.join(workspaceDir, DREAMING_DIR_RELATIVE, "last-run-light.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 { runLightSweep };
+
+//# sourceMappingURL=light-sweep.js.map

package/dist/src/agent/memory/dreaming/light-sweep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"light-sweep.js","names":[],"sources":["../../../../../src/agent/memory/dreaming/light-sweep.ts"],"sourcesContent":["import fs from 'node:fs/promises';\nimport path from 'node:path';\n\nimport { createLogger } from '../../../utils/logger.js';\nimport { DREAMING_DIR_RELATIVE } from './constants.js';\nimport type { DreamingLightConfig } from './config.js';\nimport {\n  bumpEntryPhaseSignal,\n  loadDreamingStore,\n  saveDreamingStore,\n} from './short-term-store.js';\nimport {\n  buildEntryKey,\n  isoDay,\n  normalizeMemoryPath,\n  normalizeSnippetForHash,\n  snippetHash,\n} from './utils.js';\nimport {\n  DREAMING_LAST_RUN_FORMAT_VERSION,\n  type DreamingLightLastRun,\n} from './last-run.js';\n\nconst log = createLogger('Dreaming:Light');\n\n// ── Helpers ────────────────────────────────────────────────────────────\n\nfunction isDailyMemoryFile(filename: string): boolean {\n  return /^\\d{4}-\\d{2}-\\d{2}\\.md$/i.test(filename);\n}\n\n/**\n * Cosine-ish similarity via character n-gram overlap.\n * Fast and deterministic — no embeddings required.\n */\nfunction trigramSimilarity(textA: string, textB: string): number {\n  const normalizedA = normalizeSnippetForHash(textA);\n  const normalizedB = normalizeSnippetForHash(textB);\n  if (!normalizedA || !normalizedB) return 0;\n  if (normalizedA === normalizedB) return 1;\n\n  const gramsA = buildTrigramSet(normalizedA);\n  const gramsB = buildTrigramSet(normalizedB);\n  if (gramsA.size === 0 || gramsB.size === 0) return 0;\n\n  let intersection = 0;\n  for (const gram of gramsA) {\n    if (gramsB.has(gram)) intersection += 1;\n  }\n  return intersection / Math.sqrt(gramsA.size * gramsB.size);\n}\n\nfunction buildTrigramSet(text: string): Set<string> {\n  const grams = new Set<string>();\n  for (let i = 0; i <= text.length - 3; i++) {\n    grams.add(text.slice(i, i + 3));\n  }\n  return grams;\n}\n\n// ── Light sweep config defaults ────────────────────────────────────────\n\nfunction resolveConfig(overrides?: Partial<DreamingLightConfig>): DreamingLightConfig {\n  return {\n    enabled: overrides?.enabled === true,\n    cron: typeof overrides?.cron === 'string' ? overrides.cron : '0 */6 * * *',\n    lookbackDays: Math.max(1, Math.floor(Number(overrides?.lookbackDays) || 2)),\n    limit: Math.max(0, Math.floor(Number(overrides?.limit) || 100)),\n    dedupeSimilarity: Math.max(0, Math.min(1, Number(overrides?.dedupeSimilarity) || 0.9)),\n  };\n}\n\n// ── Core light sweep ───────────────────────────────────────────────────\n\ntype LightSweepChunk = {\n  path: string;\n  startLine: number;\n  endLine: number;\n  text: string;\n  hash: string;\n};\n\n/**\n * Scan recent daily memory files (memory/YYYY-MM-DD.md) and collect signal\n * entries into the short-term store. Deduplicates near-identical snippets\n * using trigram similarity.\n *\n * This is the \"light sleep\" phase: fast, frequent, cheap.\n */\nexport async function runLightSweep(params: {\n  workspaceDir: string;\n  config?: Partial<DreamingLightConfig>;\n  now?: Date;\n}): Promise<{\n  ok: boolean;\n  reason: string;\n  scannedEntries: number;\n  newSignals: number;\n  deduped: number;\n}> {\n  const cfg = resolveConfig(params.config);\n  const now = params.now ?? new Date();\n  const startedAt = now.toISOString();\n  const runId = `light:${startedAt}:${process.pid}`;\n  const startMs = Date.now();\n\n  if (!cfg.enabled) {\n    await writeLastRun(params.workspaceDir, {\n      runId, startedAt, cfg, ok: true, reason: 'light sweep disabled', startMs,\n      light: { scannedEntries: 0, newSignals: 0, deduped: 0 },\n    });\n    return { ok: true, reason: 'light sweep disabled', scannedEntries: 0, newSignals: 0, deduped: 0 };\n  }\n\n  try {\n    const memoryDir = path.join(params.workspaceDir, 'memory');\n    const recentFiles = await listRecentDailyFiles(memoryDir, cfg.lookbackDays, now);\n\n    if (recentFiles.length === 0) {\n      await writeLastRun(params.workspaceDir, {\n        runId, startedAt, cfg, ok: true, reason: 'no recent daily files', startMs,\n        light: { scannedEntries: 0, newSignals: 0, deduped: 0 },\n      });\n      return { ok: true, reason: 'no recent daily files', scannedEntries: 0, newSignals: 0, deduped: 0 };\n    }\n\n    // Parse chunks from daily files.\n    const allChunks: LightSweepChunk[] = [];\n    for (const filePath of recentFiles) {\n      const chunks = await parseFileChunks(filePath, params.workspaceDir);\n      allChunks.push(...chunks);\n    }\n\n    if (allChunks.length === 0) {\n      await writeLastRun(params.workspaceDir, {\n        runId, startedAt, cfg, ok: true, reason: 'no chunks found in daily files', startMs,\n        light: { scannedEntries: 0, newSignals: 0, deduped: 0 },\n      });\n      return { ok: true, reason: 'no chunks found in daily files', scannedEntries: 0, newSignals: 0, deduped: 0 };\n    }\n\n    // Deduplicate chunks by trigram similarity.\n    const { unique, deduped } = deduplicateChunks(allChunks, cfg.dedupeSimilarity);\n    const capped = unique.slice(0, cfg.limit);\n\n    // Merge into the short-term store, bumping lightHits + dailyCount.\n    const { store } = await loadDreamingStore({ workspaceDir: params.workspaceDir });\n    let newSignals = 0;\n    const dayBucket = isoDay(now);\n    const nowIso = now.toISOString();\n\n    for (const chunk of capped) {\n      const key = buildEntryKey({ path: chunk.path, startLine: chunk.startLine, endLine: chunk.endLine });\n      const existing = store.entries[key];\n\n      if (existing) {\n        bumpEntryPhaseSignal(existing, 'lightHits');\n        bumpEntryPhaseSignal(existing, 'dailyCount');\n        existing.snippet = chunk.text.slice(0, 360);\n        existing.lastRecalledAt = nowIso;\n      } else {\n        store.entries[key] = {\n          key,\n          path: chunk.path,\n          startLine: chunk.startLine,\n          endLine: chunk.endLine,\n          snippet: chunk.text.slice(0, 360),\n          recallCount: 0,\n          dailyCount: 1,\n          groundedCount: 0,\n          lightHits: 1,\n          remHits: 0,\n          phaseHitCount: 1,\n          totalSignalCount: 1,\n          totalScore: 0,\n          maxScore: 0,\n          queryHashes: [],\n          recallDays: [dayBucket],\n          firstRecalledAt: nowIso,\n          lastRecalledAt: nowIso,\n        };\n        newSignals += 1;\n      }\n    }\n\n    store.updatedAt = nowIso;\n    await saveDreamingStore({ workspaceDir: params.workspaceDir, store });\n\n    log.info(\n      { workspaceDir: params.workspaceDir, scanned: allChunks.length, newSignals, deduped },\n      'Light sweep complete',\n    );\n\n    await writeLastRun(params.workspaceDir, {\n      runId, startedAt, cfg, ok: true, reason: 'light sweep complete', startMs,\n      light: { scannedEntries: allChunks.length, newSignals, deduped },\n    });\n\n    return { ok: true, reason: 'light sweep complete', scannedEntries: allChunks.length, newSignals, deduped };\n  } catch (err) {\n    const errorMessage = err instanceof Error ? err.message : String(err);\n    log.error({ err, errorMessage, workspaceDir: params.workspaceDir }, `Light sweep failed: ${errorMessage}`);\n    await writeLastRun(params.workspaceDir, {\n      runId, startedAt, cfg, ok: false, reason: `light sweep error: ${errorMessage}`, startMs,\n      light: { scannedEntries: 0, newSignals: 0, deduped: 0 }, errorMessage,\n    }).catch(() => undefined);\n    return { ok: false, reason: errorMessage, scannedEntries: 0, newSignals: 0, deduped: 0 };\n  }\n}\n\n// ── File scanning ──────────────────────────────────────────────────────\n\nasync function listRecentDailyFiles(memoryDir: string, lookbackDays: number, now: Date): Promise<string[]> {\n  let entries: string[];\n  try {\n    entries = await fs.readdir(memoryDir);\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException)?.code === 'ENOENT') return [];\n    throw err;\n  }\n\n  const cutoff = new Date(now);\n  cutoff.setDate(cutoff.getDate() - lookbackDays);\n  const cutoffDay = isoDay(cutoff);\n\n  return entries\n    .filter((name) => isDailyMemoryFile(name))\n    .filter((name) => {\n      const day = name.replace(/\\.md$/i, '');\n      return day >= cutoffDay;\n    })\n    .sort()\n    .map((name) => path.join(memoryDir, name));\n}\n\nasync function parseFileChunks(filePath: string, workspaceDir: string): Promise<LightSweepChunk[]> {\n  let raw: string;\n  try {\n    raw = await fs.readFile(filePath, 'utf-8');\n  } catch {\n    return [];\n  }\n\n  const relativePath = normalizeMemoryPath(path.relative(workspaceDir, filePath));\n  const lines = raw.split(/\\r?\\n/);\n  const chunks: LightSweepChunk[] = [];\n\n  // Split into paragraph-level chunks (separated by blank lines).\n  let chunkStartLine = 1;\n  let currentLines: string[] = [];\n\n  for (let i = 0; i < lines.length; i++) {\n    const trimmed = lines[i]!.trim();\n    if (trimmed.length === 0) {\n      if (currentLines.length > 0) {\n        const text = currentLines.join(' ').replace(/\\s+/g, ' ').trim();\n        if (text.length >= 20) {\n          chunks.push({\n            path: relativePath,\n            startLine: chunkStartLine,\n            endLine: chunkStartLine + currentLines.length - 1,\n            text: text.slice(0, 360),\n            hash: snippetHash(text),\n          });\n        }\n        currentLines = [];\n      }\n      chunkStartLine = i + 2; // next non-blank line (1-indexed)\n    } else {\n      if (currentLines.length === 0) chunkStartLine = i + 1;\n      currentLines.push(trimmed);\n    }\n  }\n\n  // Flush remaining.\n  if (currentLines.length > 0) {\n    const text = currentLines.join(' ').replace(/\\s+/g, ' ').trim();\n    if (text.length >= 20) {\n      chunks.push({\n        path: relativePath,\n        startLine: chunkStartLine,\n        endLine: chunkStartLine + currentLines.length - 1,\n        text: text.slice(0, 360),\n        hash: snippetHash(text),\n      });\n    }\n  }\n\n  return chunks;\n}\n\n// ── Deduplication ──────────────────────────────────────────────────────\n\nfunction deduplicateChunks(\n  chunks: LightSweepChunk[],\n  threshold: number,\n): { unique: LightSweepChunk[]; deduped: number } {\n  const unique: LightSweepChunk[] = [];\n  let deduped = 0;\n\n  for (const chunk of chunks) {\n    const isDuplicate = unique.some(\n      (existing) => existing.hash === chunk.hash || trigramSimilarity(existing.text, chunk.text) >= threshold,\n    );\n    if (isDuplicate) {\n      deduped += 1;\n    } else {\n      unique.push(chunk);\n    }\n  }\n\n  return { unique, deduped };\n}\n\n// ── Last-run writer ────────────────────────────────────────────────────\n\nasync function writeLastRun(\n  workspaceDir: string,\n  params: {\n    runId: string;\n    startedAt: string;\n    cfg: DreamingLightConfig;\n    ok: boolean;\n    reason: string;\n    startMs: number;\n    light: DreamingLightLastRun['light'];\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: DreamingLightLastRun = {\n    version: DREAMING_LAST_RUN_FORMAT_VERSION,\n    phase: 'light',\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    light: params.light,\n    ...(params.errorMessage ? { errorMessage: params.errorMessage } : {}),\n  };\n\n  const lastRunPath = path.join(workspaceDir, DREAMING_DIR_RELATIVE, 'last-run-light.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/preview.d.ts

@@ -0,0 +1,28 @@
+import type { DreamingDeepConfig } from './config.js';
+type PreviewItem = {
+    key: string;
+    hash: string;
+    snippet: string;
+    path: string;
+    startLine: number;
+    endLine: number;
+    score: number;
+    avgScore: number;
+    recallCount: number;
+    recencyDecay: number;
+    alreadyPromotedByKey: boolean;
+    alreadyPromotedByHash: boolean;
+    skippedReason: string | null;
+};
+export declare function previewDreamingDeepPromotion(params: {
+    workspaceDir: string;
+    config?: Partial<DreamingDeepConfig>;
+    limit?: number;
+    now?: Date;
+}): Promise<{
+    ok: boolean;
+    reason: string;
+    items: PreviewItem[];
+    memoryPath: string;
+}>;
+export {};