@xopcai/xopc 0.0.180 → 0.0.188

package/dist/src/agent/memory/context/planner.js

@@ -1,17 +1,18 @@
 import { createLogger } from "../../../utils/logger/index.js";
 import { init_logger } from "../../../utils/logger.js";
-import { appendMemoryTraceEvent, hasUnresolvedMemoryConflict } from "../../../storage/sqlite/memory-records-repository.js";
+import { appendMemorySignal, appendMemoryTraceEvent, hasUnresolvedMemoryConflict } from "../../../storage/sqlite/memory-records-repository.js";
 import { consumeMemoryReferenceConsent, ensureMemoryReferenceConsentRequest, hasMemoryReferenceConsent } from "../../../storage/sqlite/memory-reference-consent-repository.js";
 import "../../../storage/sqlite/index.js";
 import { readAgentMessageContent } from "../agent-message-access.js";
-import { buildUserContextBlock } from "../context-fence.js";
 import { resolveMemoryStability } from "../lifecycle.js";
 import { classifyMemoryContextOrigin } from "../source-origin.js";
+import { USER_CONTEXT_MEMORY_KINDS, isUserContextRecord } from "../../../user-context/projection.js";
+import { buildUserContextBlock } from "../context-fence.js";
 import { randomUUID } from "node:crypto";
 //#region src/agent/memory/context/planner.ts
 init_logger();
-const MAX_CONTEXT_CHARS = 6e3;
-const MAX_RESULTS = 8;
+const DEFAULT_MAX_CONTEXT_CHARS = 12e3;
+const DEFAULT_MAX_RESULTS = 12;
 const BASELINE_KINDS = [
 	"boundary",
 	"preference",
@@ -20,7 +21,18 @@ const BASELINE_KINDS = [
 	"user_profile",
 	"personal_logistics"
 ];
+const SELF_SUMMARY_PATTERNS = [
+	/(?:介绍|说说|描述|总结)(?:一下|下)?你?(?:所)?(?:了解|知道|认知)(?:到)?的?我/u,
+	/你眼中的我/u,
+	/(?:关于我你|你(?:对我|关于我))(?:有)?(?:哪些|什么)?(?:了解|认知|知道|记得|印象)/u,
+	/(?:what (?:do|can) you|what you) (?:know|understand|remember) about me/i,
+	/(?:describe|summari[sz]e|introduce) me/i,
+	/(?:how do you see|your impression of) me/i
+];
 const log = createLogger("UserContextPlanner");
+function isUserSelfSummaryQuery(query) {
+	return SELF_SUMMARY_PATTERNS.some((pattern) => pattern.test(query));
+}
 function sectionFor(record) {
 	if (record.kind === "boundary") return "safety";
 	if (record.kind === "preference" || record.kind === "user_profile" || record.kind === "relationship" || record.kind === "routine" || record.kind === "personal_logistics" || record.kind === "tool_preference") return "interaction";
@@ -53,7 +65,7 @@ function evidenceLabel(item) {
 	if (item.origin === "connected_source") return "A connected source provided this";
 	return "An inference that may be wrong";
 }
-function prependContext(message, block) {
+function prependAgentContext(message, block) {
 	if (!block) return message;
 	const prefix = `${block}\n\n`;
 	const content = readAgentMessageContent(message);
@@ -94,30 +106,36 @@ var UserContextPlanner = class {
 			items: [],
 			rejected: [],
 			consentRequests: [],
-			estimatedTokens: 0
+			estimatedTokens: 0,
+			allocation: params.allocation
 		};
+		const maxResults = params.allocation?.maxResults ?? DEFAULT_MAX_RESULTS;
+		const maxContextChars = params.allocation?.maxChars ?? DEFAULT_MAX_CONTEXT_CHARS;
 		const started = Date.now();
 		const scope = {
 			userId: "local-owner",
 			sessionKey: params.sessionKey
 		};
-		const [taskResults, baselineLists] = await Promise.all([params.memoryManager.search({
+		const selfSummary = isUserSelfSummaryQuery(query);
+		const baselineKinds = selfSummary ? USER_CONTEXT_MEMORY_KINDS : BASELINE_KINDS;
+		const [searchedResults, baselineLists] = await Promise.all([params.memoryManager.search({
 			query,
 			scope,
-			maxResults: MAX_RESULTS,
+			maxResults,
 			minScore: .15
-		}).catch(() => []), Promise.all(BASELINE_KINDS.map((kind) => params.memoryManager.list({
+		}).catch(() => []), Promise.all(baselineKinds.map((kind) => params.memoryManager.list({
 			kind,
 			status: "active",
 			scope
 		}).catch(() => [])))]);
+		const taskResults = selfSummary ? searchedResults.filter((result) => isUserContextRecord(result.record)) : searchedResults;
 		const taskIds = new Set(taskResults.map((result) => result.record.id));
-		const baselineResults = baselineLists.flat().filter((record) => !taskIds.has(record.id)).filter((record) => record.kind === "boundary" || record.explicitness === "explicit" || record.importance >= .7).map((record) => ({
+		const baselineResults = baselineLists.flat().filter((record) => !taskIds.has(record.id)).filter((record) => isUserContextRecord(record)).filter((record) => selfSummary || record.kind === "boundary" || record.explicitness === "explicit" || record.importance >= .7).map((record) => ({
 			record,
-			score: record.kind === "boundary" ? .7 : .42,
+			score: record.kind === "boundary" ? .7 : selfSummary ? .6 : .42,
 			snippet: record.content,
 			citation: {
-				providerId: record.source.provider ?? "local",
+				providerId: record.providerId,
 				recordId: record.id,
 				path: record.source.path,
 				lineStart: record.source.lineStart,
@@ -133,7 +151,7 @@ var UserContextPlanner = class {
 		const ranked = results.filter((result) => !excluded.has(result.record.id)).map((result) => ({
 			result,
 			score: scoreResult(result, now)
-		})).sort((a, b) => b.score - a.score).filter((entry, index, all) => all.findIndex((candidate) => candidate.result.record.id === entry.result.record.id) === index).slice(0, MAX_RESULTS);
+		})).sort((a, b) => b.score - a.score).filter((entry, index, all) => all.findIndex((candidate) => candidate.result.record.id === entry.result.record.id) === index).slice(0, maxResults);
 		const items = [];
 		let usedChars = 0;
 		for (const { result, score } of ranked) {
@@ -161,7 +179,7 @@ var UserContextPlanner = class {
 				continue;
 			}
 			const content = result.snippet.trim();
-			if (usedChars + content.length > MAX_CONTEXT_CHARS) {
+			if (usedChars + content.length > maxContextChars) {
 				rejected.push({
 					recordId: result.record.id,
 					reason: "budget"
@@ -209,11 +227,28 @@ var UserContextPlanner = class {
 		const consentNotice = consentRequests.length > 0 ? "A relevant saved understanding requires the user’s explicit permission before it can be referenced. Do not infer or reveal its contents. Briefly ask the user to approve the pending item in You > Understanding, then continue without it." : "";
 		const block = [buildUserContextBlock(sections.join("\n\n")), consentNotice].filter(Boolean).join("\n\n");
 		try {
+			for (const item of items) appendMemorySignal({
+				signal: {
+					source: "context_injection",
+					recordId: item.recordId,
+					score: item.score,
+					content: item.content,
+					metadata: {
+						traceId,
+						turnId: params.turnId,
+						query
+					}
+				},
+				providerId: "local",
+				sourceAgentId: params.agentId,
+				sessionKey: params.sessionKey
+			});
 			appendMemoryTraceEvent({
 				traceId,
 				phase: "inject",
 				providerId: "user-understanding",
 				sessionKey: params.sessionKey,
+				turnId: params.turnId,
 				request: {
 					query,
 					rejected,
@@ -238,13 +273,14 @@ var UserContextPlanner = class {
 		}
 		return {
 			traceId,
-			modelMessage: prependContext(params.userMessage, block),
+			modelMessage: prependAgentContext(params.userMessage, block),
 			items,
 			rejected,
 			consentRequests,
-			estimatedTokens: Math.ceil(block.length / 4)
+			estimatedTokens: Math.ceil(block.length / 4),
+			allocation: params.allocation
 		};
 	}
 };
 //#endregion
-export { UserContextPlanner };
+export { UserContextPlanner, isUserSelfSummaryQuery, prependAgentContext };

package/dist/src/agent/memory/context/types.d.ts

@@ -24,4 +24,10 @@ export interface UserContextPlan {
         purpose: string;
     }>;
     estimatedTokens: number;
+    allocation?: {
+        profile: 'standard' | 'deep' | 'critical';
+        maxResults: number;
+        maxChars: number;
+        reason: string;
+    };
 }

package/dist/src/agent/memory/create-memory-manager.d.ts

@@ -1,5 +1,4 @@
 import type { Config } from '../../config/schema.js';
-import { BuiltinMemoryStore } from './builtin-memory-store.js';
 import { MemoryManager } from './manager.js';
 export type MemoryProviderId = 'none' | 'stub';
-export declare function createMemoryManagerFromConfig(workspaceDir: string, store: BuiltinMemoryStore, config: Config | undefined, agentId?: string): MemoryManager;
+export declare function createMemoryManagerFromConfig(config: Config | undefined): MemoryManager;

package/dist/src/agent/memory/create-memory-manager.js

@@ -3,18 +3,18 @@ import { BuiltinMemoryProvider } from "./builtin-provider.js";
 import { MemoryManager } from "./manager.js";
 import { loadMemoryPluginProviders } from "./plugin-discovery.js";
 //#region src/agent/memory/create-memory-manager.ts
-function createMemoryManagerFromConfig(workspaceDir, store, config, agentId) {
-	const routing = resolveMemoryManagerOptions(workspaceDir, config, agentId);
+function createMemoryManagerFromConfig(config) {
+	const routing = resolveMemoryManagerOptions(config);
 	const enabled = isMemorySubsystemEnabled(config);
 	const mgr = new MemoryManager({
 		...routing,
 		...enabled ? { loadProviders: () => loadMemoryPluginProviders({ config }) } : {}
 	});
-	mgr.addProvider(new BuiltinMemoryProvider(store));
+	mgr.addProvider(new BuiltinMemoryProvider());
 	if (!enabled) return mgr;
 	return mgr;
 }
-function resolveMemoryManagerOptions(workspaceDir, config, requestedAgentId) {
+function resolveMemoryManagerOptions(config) {
 	if (!config) return {};
 	const providerRouting = config.userContext.providerRouting;
 	return {

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

@@ -1,16 +1,16 @@
 import type { Config } from '../../../config/schema.js';
-import { type MemoryWriteCheckResult } from '../../../agent-runtime/memory-runtime.js';
+import type { DreamingMode } from '../../../storage/sqlite/index.js';
+import type { DreamingSchedule, DreamingSettings } from '../../../user-context/config.js';
 import { type DreamingPhaseId } from './constants.js';
 export type DreamingLightConfig = {
     enabled: boolean;
-    cron: string;
+    schedule: DreamingSchedule;
     lookbackDays: number;
     limit: number;
-    dedupeSimilarity: number;
 };
 export type DreamingDeepConfig = {
     enabled: boolean;
-    cron: string;
+    schedule: DreamingSchedule;
     minScore: number;
     minRecallCount: number;
     minUniqueQueries: number;
@@ -20,26 +20,29 @@ export type DreamingDeepConfig = {
 };
 export type DreamingRemConfig = {
     enabled: boolean;
-    cron: string;
+    schedule: DreamingSchedule;
     lookbackDays: number;
     limit: number;
     minPatternStrength: number;
 };
 export type DreamingResolvedConfig = {
+    requestedMode: DreamingMode;
+    mode: DreamingMode;
     enabled: boolean;
-    promotionWritePolicy: MemoryWriteCheckResult;
-    frequency: string;
-    timezone?: string;
+    writeDisposition: 'none' | 'candidate' | 'active';
+    automaticReady: boolean;
+    downgradeReason?: 'memory_policy' | 'quality_gate';
+    timezone: string;
     phases: {
         light: DreamingLightConfig;
         deep: DreamingDeepConfig;
         rem: DreamingRemConfig;
     };
-    deep: DreamingDeepConfig;
 };
-/** Resolve the full three-phase dreaming config from an agent manifest. */
-export declare function resolveDreamingConfig(cfg: Config | undefined, requestedAgentId?: string | null): DreamingResolvedConfig;
-/** Get the cron expression for a specific phase from resolved config. */
-export declare function getPhaseCron(config: DreamingResolvedConfig, phase: DreamingPhaseId): string;
+export declare function resolveDreamingSettings(cfg: Config | undefined): DreamingSettings;
+/** Resolve the full three-phase dreaming config and its effective write authority. */
+export declare function resolveDreamingConfig(cfg: Config | undefined, options?: {
+    automaticReady?: boolean;
+}): DreamingResolvedConfig;
 /** Check if a specific phase is enabled (global + phase-level). */
 export declare function isPhaseEnabled(config: DreamingResolvedConfig, phase: DreamingPhaseId): boolean;

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

@@ -1,5 +1,5 @@
-import { buildMemoryRuntime } from "../../../agent-runtime/memory-runtime.js";
-import { DEFAULT_DEEP_CRON, DEFAULT_LIGHT_CRON, DEFAULT_REM_CRON } from "./constants.js";
+import "./constants.js";
+import { DEFAULT_DREAMING_SCHEDULES, resolveDreamingTimezone } from "./schedule.js";
 //#region src/agent/memory/dreaming/config.ts
 function clampScore(value, fallback) {
 	if (!Number.isFinite(value)) return fallback;
@@ -17,40 +17,49 @@ function toNonNegInt(value, fallback) {
 	const floored = Math.floor(num);
 	return floored >= 0 ? floored : fallback;
 }
-function trimmedStringOr(value, fallback) {
-	return typeof value === "string" && value.trim() ? value.trim() : fallback;
-}
-function optionalTrimmedString(value) {
-	return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
-/** Resolve the full three-phase dreaming config from an agent manifest. */
-function resolveDreamingConfig(cfg, requestedAgentId) {
+function resolveDreamingSettings(cfg) {
 	const dreaming = cfg?.userContext.dreaming;
-	const enabled = dreaming?.enabled === true && cfg?.userContext.enabled === true && cfg.userContext.memory.mode !== "off";
-	const promotionWritePolicy = cfg ? buildMemoryRuntime(cfg.userContext).checkWrite({
-		target: "curated",
-		content: "Dreaming automatic memory promotion",
-		source: "dreaming",
-		confidence: 1,
-		sensitive: false
-	}) : {
-		decision: "deny",
-		reason: "user context configuration is unavailable"
+	return {
+		mode: dreaming?.mode ?? "off",
+		timezone: resolveDreamingTimezone(dreaming?.timezone),
+		phases: {
+			light: {
+				enabled: dreaming?.phases?.light?.enabled !== false,
+				schedule: dreaming?.phases?.light?.schedule ?? DEFAULT_DREAMING_SCHEDULES.light
+			},
+			deep: {
+				enabled: dreaming?.phases?.deep?.enabled !== false,
+				schedule: dreaming?.phases?.deep?.schedule ?? DEFAULT_DREAMING_SCHEDULES.deep
+			},
+			rem: {
+				enabled: dreaming?.phases?.rem?.enabled !== false,
+				schedule: dreaming?.phases?.rem?.schedule ?? DEFAULT_DREAMING_SCHEDULES.rem
+			}
+		}
 	};
-	const frequency = trimmedStringOr(dreaming?.frequency, DEFAULT_DEEP_CRON);
-	const timezone = optionalTrimmedString(dreaming?.timezone);
+}
+/** Resolve the full three-phase dreaming config and its effective write authority. */
+function resolveDreamingConfig(cfg, options = {}) {
+	const dreaming = cfg?.userContext.dreaming;
+	const settings = resolveDreamingSettings(cfg);
+	const requestedMode = settings.mode;
+	const memoryMode = cfg?.userContext.memory.mode ?? "off";
+	const automaticReady = options.automaticReady === true;
+	const mode = cfg?.userContext.enabled !== true || memoryMode === "off" ? "off" : memoryMode === "readOnly" ? requestedMode === "off" ? "off" : "observe" : memoryMode === "confirmWrite" && requestedMode === "automatic" ? "review" : requestedMode === "automatic" && !automaticReady ? "review" : requestedMode;
+	const enabled = mode !== "off";
+	const writeDisposition = mode === "automatic" ? "active" : mode === "review" ? "candidate" : "none";
+	const timezone = settings.timezone;
 	const lightRaw = dreaming?.phases?.light ?? {};
 	const light = {
-		enabled: enabled && lightRaw?.enabled !== false,
-		cron: trimmedStringOr(lightRaw?.cron, DEFAULT_LIGHT_CRON),
+		enabled: enabled && settings.phases.light.enabled,
+		schedule: settings.phases.light.schedule,
 		lookbackDays: toPositiveInt(lightRaw?.lookbackDays, 2),
-		limit: toNonNegInt(lightRaw?.limit, 100),
-		dedupeSimilarity: clampScore(Number(lightRaw?.dedupeSimilarity), .9)
+		limit: toNonNegInt(lightRaw?.limit, 100)
 	};
 	const deepRaw = dreaming?.phases?.deep ?? {};
 	const deep = {
-		enabled: enabled && deepRaw?.enabled !== false && promotionWritePolicy.decision === "allow",
-		cron: trimmedStringOr(deepRaw?.cron, frequency),
+		enabled: enabled && settings.phases.deep.enabled,
+		schedule: settings.phases.deep.schedule,
 		minScore: clampScore(Number(deepRaw?.minScore), .8),
 		minRecallCount: toPositiveInt(deepRaw?.minRecallCount, 3),
 		minUniqueQueries: toPositiveInt(deepRaw?.minUniqueQueries, 3),
@@ -60,32 +69,30 @@ function resolveDreamingConfig(cfg, requestedAgentId) {
 	};
 	const remRaw = dreaming?.phases?.rem ?? {};
 	const rem = {
-		enabled: enabled && remRaw?.enabled !== false,
-		cron: trimmedStringOr(remRaw?.cron, DEFAULT_REM_CRON),
+		enabled: enabled && settings.phases.rem.enabled,
+		schedule: settings.phases.rem.schedule,
 		lookbackDays: toPositiveInt(remRaw?.lookbackDays, 7),
 		limit: toNonNegInt(remRaw?.limit, 10),
 		minPatternStrength: clampScore(Number(remRaw?.minPatternStrength), .75)
 	};
 	return {
+		requestedMode,
+		mode,
 		enabled,
-		promotionWritePolicy,
-		frequency,
-		...timezone ? { timezone } : {},
+		writeDisposition,
+		automaticReady,
+		...requestedMode === "automatic" && mode !== "automatic" ? { downgradeReason: memoryMode === "confirmWrite" || memoryMode === "readOnly" ? "memory_policy" : "quality_gate" } : {},
+		timezone,
 		phases: {
 			light,
 			deep,
 			rem
-		},
-		deep
+		}
 	};
 }
-/** Get the cron expression for a specific phase from resolved config. */
-function getPhaseCron(config, phase) {
-	return config.phases[phase].cron;
-}
 /** Check if a specific phase is enabled (global + phase-level). */
 function isPhaseEnabled(config, phase) {
 	return config.enabled && config.phases[phase].enabled;
 }
 //#endregion
-export { getPhaseCron, isPhaseEnabled, resolveDreamingConfig };
+export { isPhaseEnabled, resolveDreamingConfig, resolveDreamingSettings };

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

@@ -1,29 +1,12 @@
 export type DreamingPhaseId = 'light' | 'deep' | 'rem';
+export declare const DREAMING_ALGORITHM_VERSION = "structured-v1";
 export declare const DREAMING_PHASES: readonly DreamingPhaseId[];
 export declare const DREAMING_SWEEP_TOKEN = "__xopc_memory_dreaming_sweep__";
 export declare const DREAMING_LIGHT_SWEEP_TOKEN = "__xopc_memory_dreaming_light_sweep__";
 export declare const DREAMING_REM_SWEEP_TOKEN = "__xopc_memory_dreaming_rem_sweep__";
-export declare const DREAMING_CRON_TAG = "[managed-by=xopc.memory.dreaming]";
-export declare const DREAMING_CRON_NAME = "Memory Dreaming - Deep Promotion";
-export declare const DREAMING_LIGHT_CRON_NAME = "Memory Dreaming - Light Sweep";
-export declare const DREAMING_REM_CRON_NAME = "Memory Dreaming - REM Patterns";
-export declare const DEFAULT_DEEP_CRON = "0 3 * * *";
-export declare const DEFAULT_LIGHT_CRON = "0 */6 * * *";
-export declare const DEFAULT_REM_CRON = "0 5 * * 0";
+export declare const DREAMING_AUTOMATION_TAG = "[managed-by=xopc.memory.dreaming]";
+export declare const DREAMING_DEEP_AUTOMATION_NAME = "Memory Dreaming - Deep Promotion";
+export declare const DREAMING_LIGHT_AUTOMATION_NAME = "Memory Dreaming - Light Sweep";
+export declare const DREAMING_REM_AUTOMATION_NAME = "Memory Dreaming - REM Patterns";
 export declare const DEFAULT_RECENCY_HALF_LIFE_DAYS = 14;
 export declare const DEFAULT_MAX_AGE_DAYS = 30;
-/** Milliseconds in one day (used for time-decay calculations). */
-export declare const MS_PER_DAY = 86400000;
-/** Weight applied to recall-count reinforcement (logarithmic boost). */
-export declare const REINFORCEMENT_WEIGHT = 0.12;
-/** Weight applied to signal-diversity bonus. */
-export declare const DIVERSITY_WEIGHT = 0.08;
-/** Number of signal dimensions used for diversity calculation. */
-export declare const DIVERSITY_DIMENSION_COUNT = 4;
-export declare const DREAMING_DIR_RELATIVE = ".dreams";
-export declare const SHORT_TERM_RECALL_STORE_RELATIVE: string;
-export declare const SHORT_TERM_PROMOTION_LOCK_RELATIVE: string;
-export declare const DREAMING_LAST_RUN_RELATIVE: string;
-export declare const DREAMING_EVENTS_LOG_RELATIVE: string;
-export declare const MEMORY_MD_FILENAME = "MEMORY.md";
-export declare const DREAMS_MD_FILENAME = "DREAMS.md";

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

@@ -1,5 +1,5 @@
-import path from "node:path";
 //#region src/agent/memory/dreaming/constants.ts
+const DREAMING_ALGORITHM_VERSION = "structured-v1";
 const DREAMING_PHASES = [
 	"light",
 	"deep",
@@ -8,29 +8,11 @@ const DREAMING_PHASES = [
 const DREAMING_SWEEP_TOKEN = "__xopc_memory_dreaming_sweep__";
 const DREAMING_LIGHT_SWEEP_TOKEN = "__xopc_memory_dreaming_light_sweep__";
 const DREAMING_REM_SWEEP_TOKEN = "__xopc_memory_dreaming_rem_sweep__";
-const DREAMING_CRON_TAG = "[managed-by=xopc.memory.dreaming]";
-const DREAMING_CRON_NAME = "Memory Dreaming - Deep Promotion";
-const DREAMING_LIGHT_CRON_NAME = "Memory Dreaming - Light Sweep";
-const DREAMING_REM_CRON_NAME = "Memory Dreaming - REM Patterns";
-const DEFAULT_DEEP_CRON = "0 3 * * *";
-const DEFAULT_LIGHT_CRON = "0 */6 * * *";
-const DEFAULT_REM_CRON = "0 5 * * 0";
+const DREAMING_AUTOMATION_TAG = "[managed-by=xopc.memory.dreaming]";
+const DREAMING_DEEP_AUTOMATION_NAME = "Memory Dreaming - Deep Promotion";
+const DREAMING_LIGHT_AUTOMATION_NAME = "Memory Dreaming - Light Sweep";
+const DREAMING_REM_AUTOMATION_NAME = "Memory Dreaming - REM Patterns";
 const DEFAULT_RECENCY_HALF_LIFE_DAYS = 14;
 const DEFAULT_MAX_AGE_DAYS = 30;
-/** Milliseconds in one day (used for time-decay calculations). */
-const MS_PER_DAY = 864e5;
-/** Weight applied to recall-count reinforcement (logarithmic boost). */
-const REINFORCEMENT_WEIGHT = .12;
-/** Weight applied to signal-diversity bonus. */
-const DIVERSITY_WEIGHT = .08;
-/** Number of signal dimensions used for diversity calculation. */
-const DIVERSITY_DIMENSION_COUNT = 4;
-const DREAMING_DIR_RELATIVE = ".dreams";
-const SHORT_TERM_RECALL_STORE_RELATIVE = path.join(DREAMING_DIR_RELATIVE, "short-term-recall.json");
-const SHORT_TERM_PROMOTION_LOCK_RELATIVE = path.join(DREAMING_DIR_RELATIVE, "short-term-promotion.lock");
-const DREAMING_LAST_RUN_RELATIVE = path.join(DREAMING_DIR_RELATIVE, "last-run.json");
-const DREAMING_EVENTS_LOG_RELATIVE = path.join(DREAMING_DIR_RELATIVE, "events.jsonl");
-const MEMORY_MD_FILENAME = "MEMORY.md";
-const DREAMS_MD_FILENAME = "DREAMS.md";
 //#endregion
-export { DEFAULT_DEEP_CRON, DEFAULT_LIGHT_CRON, DEFAULT_MAX_AGE_DAYS, DEFAULT_RECENCY_HALF_LIFE_DAYS, DEFAULT_REM_CRON, DIVERSITY_DIMENSION_COUNT, DIVERSITY_WEIGHT, DREAMING_CRON_NAME, DREAMING_CRON_TAG, DREAMING_DIR_RELATIVE, DREAMING_EVENTS_LOG_RELATIVE, DREAMING_LAST_RUN_RELATIVE, DREAMING_LIGHT_CRON_NAME, DREAMING_LIGHT_SWEEP_TOKEN, DREAMING_PHASES, DREAMING_REM_CRON_NAME, DREAMING_REM_SWEEP_TOKEN, DREAMING_SWEEP_TOKEN, DREAMS_MD_FILENAME, MEMORY_MD_FILENAME, MS_PER_DAY, REINFORCEMENT_WEIGHT, SHORT_TERM_PROMOTION_LOCK_RELATIVE, SHORT_TERM_RECALL_STORE_RELATIVE };
+export { DEFAULT_MAX_AGE_DAYS, DEFAULT_RECENCY_HALF_LIFE_DAYS, DREAMING_ALGORITHM_VERSION, DREAMING_AUTOMATION_TAG, DREAMING_DEEP_AUTOMATION_NAME, DREAMING_LIGHT_AUTOMATION_NAME, DREAMING_LIGHT_SWEEP_TOKEN, DREAMING_PHASES, DREAMING_REM_AUTOMATION_NAME, DREAMING_REM_SWEEP_TOKEN, DREAMING_SWEEP_TOKEN };

package/dist/src/agent/memory/dreaming/deep-promotion.d.ts

@@ -1,21 +1,14 @@
-import { type DreamingStoreEntry } from './short-term-store.js';
+import { type DreamingActiveMode } from '../../../storage/sqlite/index.js';
 import type { DreamingDeepConfig } from './config.js';
-import type { MemoryManager } from '../manager.js';
 export type { DreamingDeepConfig } from './config.js';
-export type DreamingPromotionCandidate = DreamingStoreEntry & {
-    avgScore: number;
-    /** Time-decay-adjusted final score used for ranking. */
-    score: number;
-    /** Raw recency decay multiplier (0–1). */
-    recencyDecay: number;
-};
+/** Consolidate useful candidates from structured recall and injection signals. */
 export declare function runDreamingDeepPromotion(params: {
     agentId: string;
+    runId: string;
+    mode: DreamingActiveMode;
     workspaceDir: string;
-    dreamingRoot: string;
     config?: Partial<DreamingDeepConfig>;
     sensitiveWritePolicy?: 'deny' | 'confirm' | 'allow';
-    memoryManager?: MemoryManager;
     now?: Date;
 }): Promise<{
     ok: boolean;