@xopcai/xopc 0.0.189 → 0.0.190

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

@@ -1,286 +0,0 @@
-import { createLogger } from "../../../utils/logger/index.js";
-import { init_logger } from "../../../utils/logger.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 { 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 DEFAULT_MAX_CONTEXT_CHARS = 12e3;
-const DEFAULT_MAX_RESULTS = 12;
-const BASELINE_KINDS = [
-	"boundary",
-	"preference",
-	"tool_preference",
-	"routine",
-	"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";
-	return "task";
-}
-function rejectReason(record, now, hasReferenceConsent) {
-	if (record.tags?.includes("playbook:disabled")) return "disabled";
-	if (record.conflictGroupId && hasUnresolvedMemoryConflict(record.conflictGroupId)) return "conflict";
-	if (record.validFrom && Date.parse(record.validFrom) > now) return "not_yet_valid";
-	if (record.validTo && Date.parse(record.validTo) < now || record.expiresAt && Date.parse(record.expiresAt) < now) return "expired";
-	if (record.sensitivity === "secret" || record.sensitivity === "regulated") return "sensitive";
-	if (record.disclosurePolicy === "ask_before_reference" && !hasReferenceConsent) return "requires_consent";
-	if (record.status === "needs_review" || record.status === "stale" || resolveMemoryStability(record, now).reviewDue) return "needs_review";
-}
-function scoreResult(result, now) {
-	const confidence = result.record.confidence ?? .5;
-	const explicitness = result.record.explicitness === "explicit" ? 1 : result.record.explicitness === "observed" ? .65 : .4;
-	const stability = resolveMemoryStability(result.record, now).score;
-	return Math.max(0, Math.min(1, result.score * .45 + confidence * .1 + result.record.importance * .2 + explicitness * .1 + stability * .15));
-}
-function citationFor(result, requesterAgentId) {
-	const base = result.citation.path ?? `${result.citation.providerId}:${result.citation.recordId}`;
-	if (result.citation.lineStart == null) return base;
-	const end = result.citation.lineEnd && result.citation.lineEnd !== result.citation.lineStart ? `-L${result.citation.lineEnd}` : "";
-	return `${base}#L${result.citation.lineStart}${end}`;
-}
-function evidenceLabel(item) {
-	if (item.origin === "told_by_user") return "The user explicitly shared this";
-	if (item.origin === "observed") return "Observed across prior work";
-	if (item.origin === "connected_source") return "A connected source provided this";
-	return "An inference that may be wrong";
-}
-function prependAgentContext(message, block) {
-	if (!block) return message;
-	const prefix = `${block}\n\n`;
-	const content = readAgentMessageContent(message);
-	if (typeof content === "string") return {
-		...message,
-		content: prefix + content
-	};
-	if (Array.isArray(content) && content.length > 0) {
-		const first = content[0];
-		if (first.type === "text" && typeof first.text === "string") {
-			const copy = [...content];
-			copy[0] = {
-				type: "text",
-				text: prefix + first.text
-			};
-			return {
-				...message,
-				content: copy
-			};
-		}
-		return {
-			...message,
-			content: [{
-				type: "text",
-				text: prefix
-			}, ...content]
-		};
-	}
-	return message;
-}
-var UserContextPlanner = class {
-	async plan(params) {
-		const traceId = randomUUID();
-		const query = params.query.trim();
-		if (!query) return {
-			traceId,
-			modelMessage: params.userMessage,
-			items: [],
-			rejected: [],
-			consentRequests: [],
-			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 selfSummary = isUserSelfSummaryQuery(query);
-		const baselineKinds = selfSummary ? USER_CONTEXT_MEMORY_KINDS : BASELINE_KINDS;
-		const [searchedResults, baselineLists] = await Promise.all([params.memoryManager.search({
-			query,
-			scope,
-			maxResults,
-			minScore: .15
-		}).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) => isUserContextRecord(record)).filter((record) => selfSummary || record.kind === "boundary" || record.explicitness === "explicit" || record.importance >= .7).map((record) => ({
-			record,
-			score: record.kind === "boundary" ? .7 : selfSummary ? .6 : .42,
-			snippet: record.content,
-			citation: {
-				providerId: record.providerId,
-				recordId: record.id,
-				path: record.source.path,
-				lineStart: record.source.lineStart,
-				lineEnd: record.source.lineEnd,
-				createdAt: record.createdAt
-			}
-		}));
-		const results = [...taskResults, ...baselineResults];
-		const now = Date.now();
-		const excluded = new Set(params.excludedRecordIds ?? []);
-		const rejected = [];
-		const consentRequests = [];
-		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, maxResults);
-		const items = [];
-		let usedChars = 0;
-		for (const { result, score } of ranked) {
-			const needsConsent = result.record.disclosurePolicy === "ask_before_reference" && result.record.sensitivity !== "secret" && result.record.sensitivity !== "regulated";
-			const hasReferenceConsent = needsConsent ? hasMemoryReferenceConsent(result.record.id, params.sessionKey) : false;
-			const reason = rejectReason(result.record, now, hasReferenceConsent) ?? (score < .25 ? "low_score" : void 0);
-			if (reason) {
-				rejected.push({
-					recordId: result.record.id,
-					reason
-				});
-				if (reason === "requires_consent") {
-					const request = ensureMemoryReferenceConsentRequest({
-						recordId: result.record.id,
-						sessionKey: params.sessionKey,
-						purpose: query
-					});
-					consentRequests.push({
-						id: request.id,
-						recordId: request.recordId,
-						statement: result.record.content,
-						purpose: request.purpose
-					});
-				}
-				continue;
-			}
-			const content = result.snippet.trim();
-			if (usedChars + content.length > maxContextChars) {
-				rejected.push({
-					recordId: result.record.id,
-					reason: "budget"
-				});
-				continue;
-			}
-			if (needsConsent && !consumeMemoryReferenceConsent(result.record.id, params.sessionKey)) {
-				rejected.push({
-					recordId: result.record.id,
-					reason: "requires_consent"
-				});
-				const request = ensureMemoryReferenceConsentRequest({
-					recordId: result.record.id,
-					sessionKey: params.sessionKey,
-					purpose: query
-				});
-				consentRequests.push({
-					id: request.id,
-					recordId: request.recordId,
-					statement: result.record.content,
-					purpose: request.purpose
-				});
-				continue;
-			}
-			usedChars += content.length;
-			items.push({
-				recordId: result.record.id,
-				content,
-				score,
-				section: sectionFor(result.record),
-				citation: citationFor(result, params.agentId),
-				origin: classifyMemoryContextOrigin(result.record),
-				stability: resolveMemoryStability(result.record, now).score
-			});
-		}
-		const sections = [];
-		for (const [section, title] of [
-			["safety", "Boundaries"],
-			["task", "Relevant facts"],
-			["interaction", "Interaction preferences"]
-		]) {
-			const sectionItems = items.filter((item) => item.section === section);
-			if (sectionItems.length > 0) sections.push(`${title}:\n${sectionItems.map((item) => `- ${item.content}\n  Evidence: ${evidenceLabel(item)}`).join("\n")}`);
-		}
-		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,
-					contextItems: items.map((item) => ({
-						recordId: item.recordId,
-						section: item.section,
-						origin: item.origin,
-						stability: item.stability,
-						citation: item.citation
-					}))
-				},
-				resultCount: items.length,
-				selectedRecordIds: items.map((item) => item.recordId),
-				durationMs: Date.now() - started
-			});
-		} catch (err) {
-			log.debug({
-				err,
-				traceId,
-				sessionKey: params.sessionKey
-			}, "Context plan trace was not persisted");
-		}
-		return {
-			traceId,
-			modelMessage: prependAgentContext(params.userMessage, block),
-			items,
-			rejected,
-			consentRequests,
-			estimatedTokens: Math.ceil(block.length / 4),
-			allocation: params.allocation
-		};
-	}
-};
-//#endregion
-export { UserContextPlanner, isUserSelfSummaryQuery, prependAgentContext };

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

@@ -1,48 +0,0 @@
-import type { Config } from '../../../config/schema.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;
-    schedule: DreamingSchedule;
-    lookbackDays: number;
-    limit: number;
-};
-export type DreamingDeepConfig = {
-    enabled: boolean;
-    schedule: DreamingSchedule;
-    minScore: number;
-    minRecallCount: number;
-    minUniqueQueries: number;
-    limit: number;
-    recencyHalfLifeDays: number;
-    maxAgeDays: number;
-};
-export type DreamingRemConfig = {
-    enabled: boolean;
-    schedule: DreamingSchedule;
-    lookbackDays: number;
-    limit: number;
-    minPatternStrength: number;
-};
-export type DreamingResolvedConfig = {
-    requestedMode: DreamingMode;
-    mode: DreamingMode;
-    enabled: boolean;
-    writeDisposition: 'none' | 'candidate' | 'active';
-    automaticReady: boolean;
-    downgradeReason?: 'memory_policy' | 'quality_gate';
-    timezone: string;
-    phases: {
-        light: DreamingLightConfig;
-        deep: DreamingDeepConfig;
-        rem: DreamingRemConfig;
-    };
-};
-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,98 +0,0 @@
-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;
-	return Math.max(0, Math.min(1, value));
-}
-function toPositiveInt(value, fallback) {
-	const num = typeof value === "string" ? Number(value) : Number(value);
-	if (!Number.isFinite(num)) return fallback;
-	const floored = Math.floor(num);
-	return floored > 0 ? floored : fallback;
-}
-function toNonNegInt(value, fallback) {
-	const num = typeof value === "string" ? Number(value) : Number(value);
-	if (!Number.isFinite(num)) return fallback;
-	const floored = Math.floor(num);
-	return floored >= 0 ? floored : fallback;
-}
-function resolveDreamingSettings(cfg) {
-	const dreaming = cfg?.userContext.dreaming;
-	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
-			}
-		}
-	};
-}
-/** 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 && settings.phases.light.enabled,
-		schedule: settings.phases.light.schedule,
-		lookbackDays: toPositiveInt(lightRaw?.lookbackDays, 2),
-		limit: toNonNegInt(lightRaw?.limit, 100)
-	};
-	const deepRaw = dreaming?.phases?.deep ?? {};
-	const deep = {
-		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),
-		limit: toNonNegInt(deepRaw?.limit, 10),
-		recencyHalfLifeDays: toPositiveInt(deepRaw?.recencyHalfLifeDays, 14),
-		maxAgeDays: toPositiveInt(deepRaw?.maxAgeDays, 30)
-	};
-	const remRaw = dreaming?.phases?.rem ?? {};
-	const rem = {
-		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,
-		writeDisposition,
-		automaticReady,
-		...requestedMode === "automatic" && mode !== "automatic" ? { downgradeReason: memoryMode === "confirmWrite" || memoryMode === "readOnly" ? "memory_policy" : "quality_gate" } : {},
-		timezone,
-		phases: {
-			light,
-			deep,
-			rem
-		}
-	};
-}
-/** Check if a specific phase is enabled (global + phase-level). */
-function isPhaseEnabled(config, phase) {
-	return config.enabled && config.phases[phase].enabled;
-}
-//#endregion
-export { isPhaseEnabled, resolveDreamingConfig, resolveDreamingSettings };

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

@@ -1,12 +0,0 @@
-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_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;

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

@@ -1,18 +0,0 @@
-//#region src/agent/memory/dreaming/constants.ts
-const DREAMING_ALGORITHM_VERSION = "structured-v1";
-const DREAMING_PHASES = [
-	"light",
-	"deep",
-	"rem"
-];
-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_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;
-//#endregion
-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,19 +0,0 @@
-import { type DreamingActiveMode } from '../../../storage/sqlite/index.js';
-import type { DreamingDeepConfig } from './config.js';
-export type { DreamingDeepConfig } from './config.js';
-/** Consolidate useful candidates from structured recall and injection signals. */
-export declare function runDreamingDeepPromotion(params: {
-    agentId: string;
-    runId: string;
-    mode: DreamingActiveMode;
-    workspaceDir: string;
-    config?: Partial<DreamingDeepConfig>;
-    sensitiveWritePolicy?: 'deny' | 'confirm' | 'allow';
-    now?: Date;
-}): Promise<{
-    ok: boolean;
-    reason: string;
-    candidates: number;
-    applied: number;
-    memoryPath: string;
-}>;

package/dist/src/agent/memory/dreaming/deep-promotion.js

@@ -1,152 +0,0 @@
-import { createLogger } from "../../../utils/logger/index.js";
-import { init_logger } from "../../../utils/logger.js";
-import { recordDreamingDecision } from "../../../storage/sqlite/dreaming-repository.js";
-import { appendMemorySignal, appendMemoryTraceEvent, listMemoryRecords, listMemorySignals, setMemoryRecordStatus } from "../../../storage/sqlite/memory-records-repository.js";
-import "../../../storage/sqlite/index.js";
-import { resolveDeepDefaults } from "./utils.js";
-//#region src/agent/memory/dreaming/deep-promotion.ts
-init_logger();
-const log = createLogger("Dreaming:Deep");
-const MEMORY_STORE_URI = "sqlite://memory_records";
-/** Consolidate useful candidates from structured recall and injection signals. */
-async function runDreamingDeepPromotion(params) {
-	const cfg = resolveDeepDefaults(params.config);
-	const now = params.now ?? /* @__PURE__ */ new Date();
-	const started = Date.now();
-	if (!cfg.enabled || cfg.limit === 0) {
-		const reason = !cfg.enabled ? "dreaming disabled" : "dreaming limit=0";
-		trace(params, reason, [], 0, started);
-		return {
-			ok: true,
-			reason,
-			candidates: 0,
-			applied: 0,
-			memoryPath: MEMORY_STORE_URI
-		};
-	}
-	try {
-		const cutoff = now.getTime() - cfg.maxAgeDays * 864e5;
-		const records = listMemoryRecords({
-			providerId: "local",
-			workspaceId: params.workspaceDir,
-			status: "candidate",
-			limit: 500
-		});
-		const signals = listMemorySignals({
-			workspaceId: params.workspaceDir,
-			limit: 500
-		});
-		const byRecord = /* @__PURE__ */ new Map();
-		for (const signal of signals) {
-			if (!signal.recordId || Date.parse(signal.createdAt) < cutoff) continue;
-			const group = byRecord.get(signal.recordId) ?? [];
-			group.push(signal);
-			byRecord.set(signal.recordId, group);
-		}
-		const ranked = records.flatMap((record) => {
-			if ((record.sensitivity ?? "normal") !== "normal" && params.sensitiveWritePolicy !== "allow") return [];
-			const recallSignals = (byRecord.get(record.id) ?? []).filter((signal) => signal.source === "search_recall" || signal.source === "context_injection");
-			const queries = new Set(recallSignals.map((signal) => String(signal.metadata.query ?? "")).filter(Boolean));
-			const avgScore = recallSignals.length ? recallSignals.reduce((sum, signal) => sum + (signal.score ?? 0), 0) / recallSignals.length : 0;
-			const ageDays = Math.max(0, (now.getTime() - Date.parse(record.updatedAt)) / 864e5);
-			const score = Math.max(0, Math.min(1, avgScore * Math.pow(.5, ageDays / cfg.recencyHalfLifeDays)));
-			if (recallSignals.length < cfg.minRecallCount || queries.size < cfg.minUniqueQueries || score < cfg.minScore) return [];
-			return [{
-				recordId: record.id,
-				score,
-				recallCount: recallSignals.length,
-				uniqueQueries: queries.size,
-				content: record.content
-			}];
-		}).sort((left, right) => right.score - left.score).slice(0, cfg.limit);
-		const policy = params.mode === "automatic" ? "allow" : params.mode === "review" ? "confirm" : "deny";
-		let applied = 0;
-		for (const candidate of ranked) {
-			const action = policy === "allow" ? "activate" : policy === "confirm" ? "propose" : "observe";
-			recordDreamingDecision({
-				runId: params.runId,
-				recordId: candidate.recordId,
-				action,
-				reasonCode: "deep_evidence_threshold_met",
-				score: candidate.score,
-				evidence: {
-					recallCount: candidate.recallCount,
-					uniqueQueries: candidate.uniqueQueries
-				}
-			});
-			if (policy === "allow") {
-				if (!setMemoryRecordStatus(candidate.recordId, "active", now.getTime())) continue;
-				applied += 1;
-				appendMemorySignal({
-					signal: {
-						source: "dreaming",
-						recordId: candidate.recordId,
-						score: candidate.score,
-						content: candidate.content,
-						metadata: {
-							phase: "deep",
-							recallCount: candidate.recallCount,
-							uniqueQueries: candidate.uniqueQueries
-						}
-					},
-					providerId: "local",
-					sourceAgentId: params.agentId,
-					workspaceId: params.workspaceDir
-				});
-			}
-		}
-		const reason = ranked.length === 0 ? "no eligible candidates" : policy === "allow" ? "candidate consolidation complete" : policy === "confirm" ? "candidates retained for user review" : "analysis complete; writes denied by policy";
-		trace(params, reason, ranked.map((candidate) => candidate.recordId), applied, started);
-		log.info({
-			workspaceDir: params.workspaceDir,
-			candidates: ranked.length,
-			applied,
-			policy
-		}, "Dreaming deep consolidation complete");
-		return {
-			ok: true,
-			reason,
-			candidates: ranked.length,
-			applied,
-			memoryPath: MEMORY_STORE_URI
-		};
-	} catch (err) {
-		const error = err instanceof Error ? err.message : String(err);
-		appendMemoryTraceEvent({
-			phase: "dreaming_deep",
-			providerId: "local",
-			sourceAgentId: params.agentId,
-			request: { workspaceId: params.workspaceDir },
-			error,
-			durationMs: Date.now() - started
-		});
-		log.error({
-			err,
-			workspaceDir: params.workspaceDir
-		}, `Dreaming deep consolidation failed: ${error}`);
-		return {
-			ok: false,
-			reason: error,
-			candidates: 0,
-			applied: 0,
-			memoryPath: MEMORY_STORE_URI
-		};
-	}
-}
-function trace(params, reason, selectedRecordIds, applied, started) {
-	appendMemoryTraceEvent({
-		phase: "dreaming_deep",
-		providerId: "local",
-		sourceAgentId: params.agentId,
-		request: {
-			workspaceId: params.workspaceDir,
-			reason,
-			applied
-		},
-		resultCount: selectedRecordIds.length,
-		selectedRecordIds,
-		durationMs: Date.now() - started
-	});
-}
-//#endregion
-export { runDreamingDeepPromotion };

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

@@ -1,16 +0,0 @@
-import type { DreamingLightConfig } from './config.js';
-type LightExecutionConfig = Pick<DreamingLightConfig, 'enabled' | 'lookbackDays' | 'limit'>;
-/** Stage recent structured records as consolidation observations. */
-export declare function runLightSweep(params: {
-    runId: string;
-    workspaceDir: string;
-    config?: Partial<LightExecutionConfig>;
-    now?: Date;
-}): Promise<{
-    ok: boolean;
-    reason: string;
-    scannedEntries: number;
-    newSignals: number;
-    deduped: number;
-}>;
-export {};