@xopcai/xopc 0.0.180 → 0.0.187

package/dist/src/agent/memory/builtin-memory-store.js

@@ -1,315 +0,0 @@
-import { dirname, join } from "node:path";
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import lockfile from "proper-lockfile";
-//#region src/agent/memory/builtin-memory-store.ts
-/**
-* Bounded curated memory under the shared user context directory, §-delimited entries.
-* Snapshot for system prompt is captured at load time and not mutated until next load.
-*/
-const MEMORY_ENTRY_DELIMITER = "\n§\n";
-const DEFAULT_MEMORY_LIMIT = 2200;
-const DEFAULT_USER_LIMIT = 1375;
-var BuiltinMemoryStore = class {
-	memoryEntries = [];
-	userEntries = [];
-	snapshot = {
-		memory: "",
-		user: ""
-	};
-	constructor(config) {
-		this.config = config;
-	}
-	/** When false, global user memory is omitted from the snapshot and should not be edited via `curated_memory`. */
-	isUserProfileEnabled() {
-		return this.config.userProfileEnabled !== false;
-	}
-	/** Shared curated memory directory (`~/.xopc/user/memories/`). */
-	get memoriesDir() {
-		return this.config.memoriesDir;
-	}
-	/** Global user memory file (`~/.xopc/user/MEMORY.md`). */
-	get userMemoryPath() {
-		return this.config.userMemoryPath;
-	}
-	/** Workspace whose profile and curated files participate in local memory search. */
-	get workspaceDir() {
-		return this.config.workspaceDir;
-	}
-	pathFor(target) {
-		return target === "memory" ? join(this.memoriesDir, "MEMORY.md") : this.userMemoryPath;
-	}
-	/**
-	* Load from disk and freeze {@link getSnapshot}. Sync for agent creation (prefix cache stability).
-	*/
-	loadFromDiskSync() {
-		mkdirSync(this.memoriesDir, { recursive: true });
-		this.memoryEntries = this.parseFileContent(this.readPathSync(join(this.memoriesDir, "MEMORY.md")));
-		this.userEntries = this.config.userProfileEnabled === false ? [] : this.parseFileContent(this.readPathSync(this.userMemoryPath));
-		this.memoryEntries = dedupePreserveOrder(this.memoryEntries);
-		this.userEntries = dedupePreserveOrder(this.userEntries);
-		this.snapshot = {
-			memory: this.renderBlock("memory", this.memoryEntries),
-			user: this.renderBlock("user", this.userEntries)
-		};
-	}
-	readPathSync(path) {
-		try {
-			if (!existsSync(path)) return "";
-			return readFileSync(path, { encoding: "utf-8" });
-		} catch {
-			return "";
-		}
-	}
-	parseFileContent(raw) {
-		if (!raw.trim()) return [];
-		return raw.split(MEMORY_ENTRY_DELIMITER).map((e) => e.trim()).filter(Boolean);
-	}
-	getSnapshot() {
-		return this.snapshot;
-	}
-	/**
-	* Live entries for read/debug (may differ from snapshot after mutations).
-	*/
-	getLiveEntries(target) {
-		return target === "memory" ? [...this.memoryEntries] : [...this.userEntries];
-	}
-	async add(target, content) {
-		const trimmed = content.trim();
-		if (!trimmed) return {
-			success: false,
-			error: "Content cannot be empty."
-		};
-		const scanError = scanForThreats(trimmed);
-		if (scanError) return {
-			success: false,
-			error: scanError
-		};
-		return this.withFileLock(target, async () => {
-			await this.reloadTargetFromDisk(target);
-			const entries = target === "memory" ? this.memoryEntries : this.userEntries;
-			const limit = this.charLimit(target);
-			if (entries.includes(trimmed)) return {
-				success: false,
-				error: "Entry already exists"
-			};
-			if (calculateTotal([...entries, trimmed]) > limit) return {
-				success: false,
-				error: `Memory at ${calculateTotal(entries)}/${limit} chars. Adding would exceed limit.`
-			};
-			entries.push(trimmed);
-			await this.flushTargetToDisk(target);
-			return {
-				success: true,
-				message: "Entry added."
-			};
-		});
-	}
-	async replace(target, oldText, newContent) {
-		const ot = oldText.trim();
-		const nc = newContent.trim();
-		if (!ot) return {
-			success: false,
-			error: "old_text cannot be empty."
-		};
-		if (!nc) return {
-			success: false,
-			error: "new_content cannot be empty. Use remove to delete entries."
-		};
-		const scanError = scanForThreats(nc);
-		if (scanError) return {
-			success: false,
-			error: scanError
-		};
-		return this.withFileLock(target, async () => {
-			await this.reloadTargetFromDisk(target);
-			const entries = target === "memory" ? this.memoryEntries : this.userEntries;
-			const matches = [];
-			for (let i = 0; i < entries.length; i++) if (entries[i].includes(ot)) matches.push({
-				index: i,
-				entry: entries[i]
-			});
-			if (matches.length === 0) return {
-				success: false,
-				error: `No entry matched '${ot}'.`
-			};
-			if (matches.length > 1) {
-				if (new Set(matches.map((m) => m.entry)).size > 1) return {
-					success: false,
-					error: `Multiple entries matched '${ot}'. Be more specific. Previews: ${matches.map((m) => m.entry.length > 80 ? `${m.entry.slice(0, 80)}...` : m.entry).join(" | ")}`
-				};
-			}
-			const idx = matches[0].index;
-			const limit = this.charLimit(target);
-			const testEntries = [...entries];
-			testEntries[idx] = nc;
-			if (calculateTotal(testEntries) > limit) return {
-				success: false,
-				error: `Replacement would put memory at ${calculateTotal(testEntries)}/${limit} chars.`
-			};
-			entries[idx] = nc;
-			await this.flushTargetToDisk(target);
-			return {
-				success: true,
-				message: "Entry replaced."
-			};
-		});
-	}
-	async remove(target, oldText) {
-		const ot = oldText.trim();
-		if (!ot) return {
-			success: false,
-			error: "old_text cannot be empty."
-		};
-		return this.withFileLock(target, async () => {
-			await this.reloadTargetFromDisk(target);
-			const entries = target === "memory" ? this.memoryEntries : this.userEntries;
-			const matches = [];
-			for (let i = 0; i < entries.length; i++) if (entries[i].includes(ot)) matches.push(i);
-			if (matches.length === 0) return {
-				success: false,
-				error: `No entry matched '${ot}'.`
-			};
-			if (matches.length > 1) {
-				if (new Set(matches.map((i) => entries[i])).size > 1) return {
-					success: false,
-					error: `Multiple entries matched '${ot}'. Be more specific. Previews: ${matches.map((i) => {
-						const e = entries[i];
-						return e.length > 80 ? `${e.slice(0, 80)}...` : e;
-					}).join(" | ")}`
-				};
-			}
-			entries.splice(matches[0], 1);
-			await this.flushTargetToDisk(target);
-			return {
-				success: true,
-				message: "Entry removed."
-			};
-		});
-	}
-	async withFileLock(target, fn) {
-		const filePath = this.pathFor(target);
-		await mkdir(dirname(filePath), { recursive: true });
-		if (!existsSync(filePath)) await writeFile(filePath, "", "utf-8");
-		await lockfile.lock(filePath, {
-			retries: 3,
-			stale: 1e4
-		});
-		try {
-			return await fn();
-		} finally {
-			await lockfile.unlock(filePath);
-		}
-	}
-	async reloadTargetFromDisk(target) {
-		const path = this.pathFor(target);
-		let raw = "";
-		try {
-			raw = await readFile(path, "utf-8");
-		} catch {
-			raw = "";
-		}
-		const parsed = dedupePreserveOrder(this.parseFileContent(raw));
-		if (target === "memory") this.memoryEntries = parsed;
-		else this.userEntries = parsed;
-	}
-	async flushTargetToDisk(target) {
-		const entries = target === "memory" ? this.memoryEntries : this.userEntries;
-		const filePath = this.pathFor(target);
-		const content = entries.join(MEMORY_ENTRY_DELIMITER);
-		const tmpPath = `${filePath}.tmp.${Date.now()}`;
-		await mkdir(dirname(filePath), { recursive: true });
-		await writeFile(tmpPath, content, "utf-8");
-		await rename(tmpPath, filePath);
-	}
-	charLimit(target) {
-		return target === "memory" ? this.config.memoryCharLimit ?? DEFAULT_MEMORY_LIMIT : this.config.userCharLimit ?? DEFAULT_USER_LIMIT;
-	}
-	renderBlock(target, entries) {
-		if (entries.length === 0) return "";
-		const limit = this.charLimit(target);
-		const content = entries.join(MEMORY_ENTRY_DELIMITER);
-		const current = content.length;
-		const pct = Math.min(100, Math.round(current / limit * 100));
-		const header = target === "user" ? `USER PROFILE (who the user is) [${pct}% — ${current.toLocaleString()}/${limit.toLocaleString()} chars]` : `MEMORY (your personal notes) [${pct}% — ${current.toLocaleString()}/${limit.toLocaleString()} chars]`;
-		const separator = "═".repeat(46);
-		return `${separator}\n${header}\n${separator}\n${content}`;
-	}
-};
-function dedupePreserveOrder(entries) {
-	const seen = /* @__PURE__ */ new Set();
-	const out = [];
-	for (const e of entries) {
-		if (seen.has(e)) continue;
-		seen.add(e);
-		out.push(e);
-	}
-	return out;
-}
-function calculateTotal(entries) {
-	if (entries.length === 0) return 0;
-	return entries.join(MEMORY_ENTRY_DELIMITER).length;
-}
-function scanForThreats(content) {
-	for (const { regex, id } of [
-		{
-			regex: /ignore\s+(previous|all|above|prior)\s+instructions/i,
-			id: "prompt_injection"
-		},
-		{
-			regex: /you\s+are\s+now\s+/i,
-			id: "role_hijack"
-		},
-		{
-			regex: /do\s+not\s+tell\s+the\s+user/i,
-			id: "deception_hide"
-		},
-		{
-			regex: /system\s+prompt\s+override/i,
-			id: "sys_prompt_override"
-		},
-		{
-			regex: /disregard\s+(your|all|any)\s+(instructions|rules|guidelines)/i,
-			id: "disregard_rules"
-		},
-		{
-			regex: /act\s+as\s+(if|though)\s+you\s+(have\s+no|don't\s+have)\s+(restrictions|limits|rules)/i,
-			id: "bypass_restrictions"
-		},
-		{
-			regex: /curl\s+[^\n]*\$\{?\w*(KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|API)/i,
-			id: "exfil_curl"
-		},
-		{
-			regex: /wget\s+[^\n]*\$\{?\w*(KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|API)/i,
-			id: "exfil_wget"
-		},
-		{
-			regex: /cat\s+[^\n]*(\.env|credentials|\.netrc|\.pgpass|\.npmrc|\.pypirc)/i,
-			id: "read_secrets"
-		},
-		{
-			regex: /authorized_keys/i,
-			id: "ssh_backdoor"
-		},
-		{
-			regex: /\$HOME\/\.ssh|\~\/\.ssh/i,
-			id: "ssh_access"
-		}
-	]) if (regex.test(content)) return `Blocked: content matches threat pattern '${id}'. Memory entries are injected into the system prompt and must not contain injection payloads.`;
-	for (const char of [
-		"​",
-		"‌",
-		"‍",
-		"⁠",
-		"",
-		"‪",
-		"‫",
-		"‬",
-		"‭",
-		"‮"
-	]) if (content.includes(char)) return `Blocked: content contains invisible unicode character U+${char.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")} (possible injection).`;
-	return null;
-}
-//#endregion
-export { BuiltinMemoryStore, MEMORY_ENTRY_DELIMITER, scanForThreats };

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

@@ -1,36 +0,0 @@
-import { type DreamingPhaseId } from './constants.js';
-export type DreamingEventBase = {
-    timestamp: string;
-    phase: DreamingPhaseId;
-    ok: boolean;
-    reason: string;
-    durationMs: number;
-};
-export type DreamingLightEvent = DreamingEventBase & {
-    phase: 'light';
-    scannedEntries: number;
-    newSignals: number;
-    deduped: number;
-};
-export type DreamingDeepEvent = DreamingEventBase & {
-    phase: 'deep';
-    candidates: number;
-    applied: number;
-};
-export type DreamingRemEvent = DreamingEventBase & {
-    phase: 'rem';
-    patternsDiscovered: number;
-    entriesAnalyzed: number;
-};
-export type DreamingEvent = DreamingLightEvent | DreamingDeepEvent | DreamingRemEvent;
-/**
- * Append a single event line to an agent's `memories/.dreams/events.jsonl`.
- * Creates the directory and file if they don't exist.
- * Failures are silently ignored so audit logging never blocks execution.
- */
-export declare function appendDreamingEvent(dreamingRoot: string, event: DreamingEvent): Promise<void>;
-/**
- * Read the most recent N events from the events log.
- * Returns newest-first. If the file doesn't exist, returns an empty array.
- */
-export declare function readDreamingEvents(dreamingRoot: string, limit?: number): Promise<DreamingEvent[]>;

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

@@ -1,42 +0,0 @@
-import { DREAMING_DIR_RELATIVE, DREAMING_EVENTS_LOG_RELATIVE } from "./constants.js";
-import path from "node:path";
-import fs from "node:fs/promises";
-//#region src/agent/memory/dreaming/events.ts
-/**
-* Append a single event line to an agent's `memories/.dreams/events.jsonl`.
-* Creates the directory and file if they don't exist.
-* Failures are silently ignored so audit logging never blocks execution.
-*/
-async function appendDreamingEvent(dreamingRoot, event) {
-	try {
-		const dirPath = path.join(dreamingRoot, DREAMING_DIR_RELATIVE);
-		await fs.mkdir(dirPath, { recursive: true });
-		const filePath = path.join(dreamingRoot, DREAMING_EVENTS_LOG_RELATIVE);
-		const line = JSON.stringify(event) + "\n";
-		await fs.appendFile(filePath, line, "utf-8");
-	} catch {}
-}
-/**
-* Read the most recent N events from the events log.
-* Returns newest-first. If the file doesn't exist, returns an empty array.
-*/
-async function readDreamingEvents(dreamingRoot, limit = 50) {
-	const filePath = path.join(dreamingRoot, DREAMING_EVENTS_LOG_RELATIVE);
-	let raw;
-	try {
-		raw = await fs.readFile(filePath, "utf-8");
-	} catch (err) {
-		if (err?.code === "ENOENT") return [];
-		throw err;
-	}
-	const tail = raw.split("\n").map((line) => line.trim()).filter(Boolean).slice(-Math.abs(limit));
-	const events = [];
-	for (const line of tail) try {
-		const parsed = JSON.parse(line);
-		if (parsed && typeof parsed === "object" && parsed.timestamp && parsed.phase) events.push(parsed);
-	} catch {}
-	events.reverse();
-	return events;
-}
-//#endregion
-export { appendDreamingEvent, readDreamingEvents };

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

@@ -1,80 +0,0 @@
-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 an agent's `memories/.dreams/last-run.json`.
- */
-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: {
-    dreamingRoot: string;
-    lastRun: DreamingDeepLastRun;
-}): Promise<void>;

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

@@ -1,96 +0,0 @@
-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.dreamingRoot, 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 };

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

@@ -1,75 +0,0 @@
-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 source-side sweep phases. */
-    sourceCount: 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;
-    lastObservedAt?: 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: {
-    dreamingRoot: string;
-    query: string;
-    matches: MemoryMatch[];
-    options?: MemorySearchOptions;
-    now?: Date;
-}): Promise<{
-    recorded: number;
-    skipped: number;
-    storePath: string;
-}>;
-/** Serialize all read-modify-write operations against the shared Dreaming store. */
-export declare function withDreamingStoreLock<T>(dreamingRoot: string, task: () => Promise<T>): Promise<T>;
-/** @deprecated Use the store-level name; retained for callers outside this module. */
-export declare function withDreamingPromotionLock<T>(dreamingRoot: string, task: () => Promise<T>): Promise<T>;
-export declare function loadDreamingStore(params: {
-    dreamingRoot: string;
-}): Promise<{
-    store: DreamingStore;
-    storePath: string;
-}>;
-export declare function saveDreamingStore(params: {
-    dreamingRoot: string;
-    store: DreamingStore;
-}): Promise<void>;
-export declare function resetDreamingStore(params: {
-    dreamingRoot: string;
-    now?: Date;
-}): Promise<number>;
-/** Remove only a stale lock whose owning process is no longer alive. */
-export declare function clearStaleDreamingLock(dreamingRoot: string): Promise<boolean>;
-type PhaseSignalField = 'sourceCount' | '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 {};