@xopcai/xopc 0.0.188 → 0.0.190

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

@@ -1,115 +0,0 @@
-import { recordDreamingDecision } from "../../../storage/sqlite/dreaming-repository.js";
-import { appendMemorySignal, appendMemoryTraceEvent, listMemoryRecords, listMemorySignals } from "../../../storage/sqlite/memory-records-repository.js";
-import "../../../storage/sqlite/index.js";
-//#region src/agent/memory/dreaming/light-sweep.ts
-function resolveConfig(overrides) {
-	return {
-		enabled: overrides?.enabled === true,
-		lookbackDays: Math.max(1, Math.floor(Number(overrides?.lookbackDays) || 2)),
-		limit: Math.max(0, Math.floor(Number(overrides?.limit) || 100))
-	};
-}
-/** Stage recent structured records as consolidation observations. */
-async function runLightSweep(params) {
-	const cfg = resolveConfig(params.config);
-	const now = params.now ?? /* @__PURE__ */ new Date();
-	const started = Date.now();
-	if (!cfg.enabled) {
-		trace(params.workspaceDir, "light sweep disabled", 0, [], started);
-		return {
-			ok: true,
-			reason: "light sweep disabled",
-			scannedEntries: 0,
-			newSignals: 0,
-			deduped: 0
-		};
-	}
-	try {
-		const cutoff = now.getTime() - cfg.lookbackDays * 864e5;
-		const records = listMemoryRecords({
-			providerId: "local",
-			workspaceId: params.workspaceDir,
-			limit: 500
-		}).filter((record) => Date.parse(record.updatedAt) >= cutoff).slice(0, cfg.limit);
-		const existing = listMemorySignals({
-			workspaceId: params.workspaceDir,
-			limit: 500
-		});
-		const staged = new Set(existing.filter((signal) => signal.source === "dreaming" && signal.metadata.phase === "light" && Date.parse(signal.createdAt) >= cutoff).map((signal) => signal.recordId).filter((id) => Boolean(id)));
-		let newSignals = 0;
-		for (const record of records) {
-			if (staged.has(record.id)) {
-				recordDreamingDecision({
-					runId: params.runId,
-					recordId: record.id,
-					action: "skip",
-					reasonCode: "already_staged"
-				});
-				continue;
-			}
-			appendMemorySignal({
-				signal: {
-					source: "dreaming",
-					recordId: record.id,
-					score: record.importance,
-					content: record.content,
-					metadata: {
-						phase: "light",
-						recordStatus: record.status ?? "active"
-					}
-				},
-				providerId: "local",
-				sourceAgentId: record.provenance.sourceAgentId,
-				workspaceId: params.workspaceDir
-			});
-			newSignals += 1;
-			recordDreamingDecision({
-				runId: params.runId,
-				recordId: record.id,
-				action: "observe",
-				reasonCode: "recent_record_staged",
-				score: record.importance
-			});
-		}
-		const deduped = records.length - newSignals;
-		trace(params.workspaceDir, "light sweep complete", newSignals, records.map((record) => record.id), started);
-		return {
-			ok: true,
-			reason: "light sweep complete",
-			scannedEntries: records.length,
-			newSignals,
-			deduped
-		};
-	} catch (err) {
-		const reason = err instanceof Error ? err.message : String(err);
-		appendMemoryTraceEvent({
-			phase: "dreaming_light",
-			providerId: "local",
-			request: { workspaceId: params.workspaceDir },
-			error: reason,
-			durationMs: Date.now() - started
-		});
-		return {
-			ok: false,
-			reason,
-			scannedEntries: 0,
-			newSignals: 0,
-			deduped: 0
-		};
-	}
-}
-function trace(workspaceId, reason, resultCount, selectedRecordIds, started) {
-	appendMemoryTraceEvent({
-		phase: "dreaming_light",
-		providerId: "local",
-		request: {
-			workspaceId,
-			reason
-		},
-		resultCount,
-		selectedRecordIds,
-		durationMs: Date.now() - started
-	});
-}
-//#endregion
-export { runLightSweep };

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

@@ -1,23 +0,0 @@
-import type { DreamingDeepConfig } from './config.js';
-type PreviewItem = {
-    recordId: string;
-    content: string;
-    score: number;
-    avgScore: number;
-    recallCount: number;
-    uniqueQueries: number;
-    recencyDecay: number;
-    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 {};

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

@@ -1,52 +0,0 @@
-import { listMemoryRecords, listMemorySignals } from "../../../storage/sqlite/memory-records-repository.js";
-import "../../../storage/sqlite/index.js";
-import { resolveDeepDefaults } from "./utils.js";
-//#region src/agent/memory/dreaming/preview.ts
-async function previewDreamingDeepPromotion(params) {
-	const cfg = resolveDeepDefaults(params.config);
-	const memoryPath = "sqlite://memory_records";
-	if (!cfg.enabled) return {
-		ok: true,
-		reason: "dreaming disabled",
-		items: [],
-		memoryPath
-	};
-	const now = params.now ?? /* @__PURE__ */ new Date();
-	const cutoff = now.getTime() - cfg.maxAgeDays * 864e5;
-	const signals = listMemorySignals({
-		workspaceId: params.workspaceDir,
-		limit: 500
-	});
-	const limit = Math.min(Math.max(params.limit ?? 20, 1), 50);
-	return {
-		ok: true,
-		reason: "ok",
-		items: listMemoryRecords({
-			providerId: "local",
-			workspaceId: params.workspaceDir,
-			status: "candidate",
-			limit: 500
-		}).map((record) => {
-			const recalls = signals.filter((signal) => signal.recordId === record.id && Date.parse(signal.createdAt) >= cutoff && (signal.source === "search_recall" || signal.source === "context_injection"));
-			const uniqueQueries = new Set(recalls.map((signal) => String(signal.metadata.query ?? "")).filter(Boolean));
-			const avgScore = recalls.length ? recalls.reduce((sum, signal) => sum + (signal.score ?? 0), 0) / recalls.length : 0;
-			const ageDays = Math.max(0, (now.getTime() - Date.parse(record.updatedAt)) / 864e5);
-			const recencyDecay = Math.pow(.5, ageDays / cfg.recencyHalfLifeDays);
-			const score = Math.max(0, Math.min(1, avgScore * recencyDecay));
-			const skippedReason = recalls.length < cfg.minRecallCount ? "insufficient recalls" : uniqueQueries.size < cfg.minUniqueQueries ? "insufficient query diversity" : score < cfg.minScore ? "score below threshold" : null;
-			return {
-				recordId: record.id,
-				content: record.content,
-				score,
-				avgScore,
-				recallCount: recalls.length,
-				uniqueQueries: uniqueQueries.size,
-				recencyDecay,
-				skippedReason
-			};
-		}).sort((left, right) => right.score - left.score).slice(0, limit),
-		memoryPath
-	};
-}
-//#endregion
-export { previewDreamingDeepPromotion };

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

@@ -1,16 +0,0 @@
-import type { MemoryRecord, MemorySensitivity } from '../types.js';
-export interface RemInsightInput {
-    agentId: string;
-    workspaceId: string;
-    memberKeys: string[];
-    representative: string;
-    distinctPaths: string[];
-    strength: number;
-    observedAt: string;
-    evidence: string[];
-    sensitivity: MemorySensitivity;
-    status?: 'active' | 'candidate';
-}
-export declare function remPatternKey(memberKeys: string[]): string;
-/** Persist a REM cluster as a stable, recallable derived insight. */
-export declare function activateRemInsight(input: RemInsightInput): MemoryRecord;

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

@@ -1,44 +0,0 @@
-import { upsertMemoryRecord } from "../../../storage/sqlite/memory-records-repository.js";
-import "../../../storage/sqlite/index.js";
-import { createHash } from "node:crypto";
-//#region src/agent/memory/dreaming/promotion-lifecycle.ts
-function remPatternKey(memberKeys) {
-	return createHash("sha256").update([...memberKeys].sort().join("\0")).digest("hex").slice(0, 24);
-}
-/** Persist a REM cluster as a stable, recallable derived insight. */
-function activateRemInsight(input) {
-	const patternKey = remPatternKey(input.memberKeys);
-	const content = `Recurring context across ${input.distinctPaths.length} memory sources: ${input.representative}`;
-	return upsertMemoryRecord({
-		id: `dreaming-rem:${input.agentId}:${patternKey}`,
-		providerId: "local",
-		kind: "derived_insight",
-		sourceAgentId: input.agentId,
-		workspaceId: input.workspaceId,
-		content,
-		source: { provider: "dreaming" },
-		confidence: input.strength,
-		status: input.status ?? "active",
-		sensitivity: input.sensitivity,
-		canonicalKey: `dreaming-rem:${patternKey}`,
-		explicitness: "inferred",
-		durability: "recurring",
-		importance: input.strength,
-		disclosurePolicy: "referenceable",
-		evidence: input.evidence.slice(0, 8).map((sourceText) => ({
-			relation: "derived_from",
-			sourceText,
-			observedAt: input.observedAt,
-			confidence: input.strength
-		})),
-		tags: [
-			"dreaming",
-			"rem",
-			"derived-insight",
-			`strength:${input.strength.toFixed(2)}`,
-			`sources:${input.distinctPaths.length}`
-		]
-	});
-}
-//#endregion
-export { activateRemInsight, remPatternKey };

package/dist/src/agent/memory/dreaming/rem-patterns.d.ts

@@ -1,19 +0,0 @@
-import { type DreamingActiveMode } from '../../../storage/sqlite/index.js';
-import type { DreamingRemConfig } from './config.js';
-type RemExecutionConfig = Pick<DreamingRemConfig, 'enabled' | 'lookbackDays' | 'limit' | 'minPatternStrength'>;
-/** Discover cross-session patterns from structured usage signals. */
-export declare function runRemPatterns(params: {
-    agentId: string;
-    runId: string;
-    mode: DreamingActiveMode;
-    workspaceDir: string;
-    config?: Partial<RemExecutionConfig>;
-    sensitiveWritePolicy?: 'deny' | 'confirm' | 'allow';
-    now?: Date;
-}): Promise<{
-    ok: boolean;
-    reason: string;
-    patternsDiscovered: number;
-    entriesAnalyzed: number;
-}>;
-export {};

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

@@ -1,150 +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, getMemoryRecord, listMemorySignals } from "../../../storage/sqlite/memory-records-repository.js";
-import "../../../storage/sqlite/index.js";
-import { inferMemorySensitivity } from "../sensitivity.js";
-import { activateRemInsight } from "./promotion-lifecycle.js";
-import { createHash } from "node:crypto";
-//#region src/agent/memory/dreaming/rem-patterns.ts
-init_logger();
-const log = createLogger("Dreaming:REM");
-function resolveConfig(overrides) {
-	return {
-		enabled: overrides?.enabled === true,
-		lookbackDays: Math.max(1, Math.floor(Number(overrides?.lookbackDays) || 7)),
-		limit: Math.max(0, Math.floor(Number(overrides?.limit) || 10)),
-		minPatternStrength: Math.max(0, Math.min(1, Number(overrides?.minPatternStrength) || .75))
-	};
-}
-/** Discover cross-session patterns from structured usage signals. */
-async function runRemPatterns(params) {
-	const cfg = resolveConfig(params.config);
-	const now = params.now ?? /* @__PURE__ */ new Date();
-	const started = Date.now();
-	if (!cfg.enabled) {
-		trace(params, "REM patterns disabled", [], 0, started);
-		return {
-			ok: true,
-			reason: "REM patterns disabled",
-			patternsDiscovered: 0,
-			entriesAnalyzed: 0
-		};
-	}
-	try {
-		const cutoff = now.getTime() - cfg.lookbackDays * 864e5;
-		const signals = listMemorySignals({
-			workspaceId: params.workspaceDir,
-			limit: 500
-		}).filter((signal) => signal.recordId && Date.parse(signal.createdAt) >= cutoff && (signal.source === "search_recall" || signal.source === "context_injection"));
-		const groups = /* @__PURE__ */ new Map();
-		for (const signal of signals) {
-			const query = String(signal.metadata.query ?? "").trim().toLocaleLowerCase();
-			if (!query || !signal.recordId) continue;
-			const queryKey = createHash("sha256").update(query).digest("hex").slice(0, 24);
-			const group = groups.get(queryKey) ?? /* @__PURE__ */ new Set();
-			group.add(signal.recordId);
-			groups.set(queryKey, group);
-		}
-		const patterns = [...groups.values()].filter((recordIds) => recordIds.size >= 2).map((recordIds) => [...recordIds].map((id) => getMemoryRecord(id)).filter((record) => record != null)).filter((records) => records.length >= 2).map((records) => ({
-			records,
-			strength: Math.min(1, records.length / 4)
-		})).filter((pattern) => pattern.strength >= cfg.minPatternStrength).sort((left, right) => right.strength - left.strength).slice(0, cfg.limit);
-		const canPropose = params.mode !== "observe";
-		let written = 0;
-		for (const pattern of patterns) {
-			const sensitivity = inferMemorySensitivity(pattern.records.map((record) => record.content).join("\n"));
-			if (sensitivity !== "normal" && params.sensitiveWritePolicy !== "allow") {
-				recordDreamingDecision({
-					runId: params.runId,
-					action: "skip",
-					reasonCode: "sensitive_write_blocked",
-					score: pattern.strength
-				});
-				continue;
-			}
-			recordDreamingDecision({
-				runId: params.runId,
-				action: canPropose ? "propose" : "observe",
-				reasonCode: "rem_pattern_threshold_met",
-				score: pattern.strength,
-				evidence: { memberRecordIds: pattern.records.map((record) => record.id) }
-			});
-			if (canPropose) {
-				const record = activateRemInsight({
-					agentId: params.agentId,
-					workspaceId: params.workspaceDir,
-					memberKeys: pattern.records.map((record) => record.id),
-					representative: pattern.records[0].content,
-					distinctPaths: pattern.records.map((record) => record.id),
-					strength: pattern.strength,
-					observedAt: now.toISOString(),
-					evidence: pattern.records.map((record) => record.content),
-					sensitivity,
-					status: "candidate"
-				});
-				appendMemorySignal({
-					signal: {
-						source: "dreaming",
-						recordId: record.id,
-						score: pattern.strength,
-						content: record.content,
-						metadata: { phase: "rem" }
-					},
-					providerId: "local",
-					sourceAgentId: params.agentId,
-					workspaceId: params.workspaceDir
-				});
-				written += 1;
-			}
-		}
-		const selected = patterns.flatMap((pattern) => pattern.records.map((record) => record.id));
-		const reason = patterns.length === 0 ? "not enough evidence for recurring patterns" : canPropose ? "pattern candidates added for user review" : "patterns analyzed in observe mode";
-		trace(params, reason, selected, written, started);
-		log.info({
-			workspaceDir: params.workspaceDir,
-			patterns: patterns.length,
-			written,
-			canPropose
-		}, "REM pattern discovery complete");
-		return {
-			ok: true,
-			reason,
-			patternsDiscovered: patterns.length,
-			entriesAnalyzed: new Set(signals.map((signal) => signal.recordId)).size
-		};
-	} catch (err) {
-		const reason = err instanceof Error ? err.message : String(err);
-		appendMemoryTraceEvent({
-			phase: "dreaming_rem",
-			providerId: "local",
-			sourceAgentId: params.agentId,
-			request: { workspaceId: params.workspaceDir },
-			error: reason,
-			durationMs: Date.now() - started
-		});
-		return {
-			ok: false,
-			reason,
-			patternsDiscovered: 0,
-			entriesAnalyzed: 0
-		};
-	}
-}
-function trace(params, reason, selectedRecordIds, written, started) {
-	appendMemoryTraceEvent({
-		phase: "dreaming_rem",
-		providerId: "local",
-		sourceAgentId: params.agentId,
-		request: {
-			workspaceId: params.workspaceDir,
-			reason,
-			written
-		},
-		resultCount: selectedRecordIds.length,
-		selectedRecordIds,
-		durationMs: Date.now() - started
-	});
-}
-//#endregion
-export { runRemPatterns };

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,3 +0,0 @@
-import type { DreamingDeepConfig } from './config.js';
-export type DeepExecutionConfig = Omit<DreamingDeepConfig, 'schedule'>;
-export declare function resolveDeepDefaults(overrides?: Partial<DeepExecutionConfig>): DeepExecutionConfig;

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

@@ -1,31 +0,0 @@
-import "./constants.js";
-//#region src/agent/memory/dreaming/utils.ts
-function toPositiveInt(value, fallback) {
-	const num = Number(value);
-	if (!Number.isFinite(num)) return fallback;
-	const floored = Math.floor(num);
-	return floored > 0 ? floored : fallback;
-}
-function toNonNegInt(value, fallback) {
-	const num = Number(value);
-	if (!Number.isFinite(num)) return fallback;
-	const floored = Math.floor(num);
-	return floored >= 0 ? floored : fallback;
-}
-function clampScore(value, fallback) {
-	if (!Number.isFinite(value)) return fallback;
-	return Math.max(0, Math.min(1, value));
-}
-function resolveDeepDefaults(overrides) {
-	return {
-		enabled: overrides?.enabled !== false,
-		minScore: clampScore(Number(overrides?.minScore), .8),
-		minRecallCount: toPositiveInt(overrides?.minRecallCount, 3),
-		minUniqueQueries: toPositiveInt(overrides?.minUniqueQueries, 3),
-		limit: toNonNegInt(overrides?.limit, 10),
-		recencyHalfLifeDays: toPositiveInt(overrides?.recencyHalfLifeDays, 14),
-		maxAgeDays: toPositiveInt(overrides?.maxAgeDays, 30)
-	};
-}
-//#endregion
-export { resolveDeepDefaults };

package/dist/src/agent/streaming/reasoning-visibility-sse.d.ts

@@ -1,15 +0,0 @@
-/**
- * Outbound SSE visibility for session `reasoningLevel`.
- * Single choke point: call from the queue push path so agent subscribe stays free of policy branches.
- *
- * Note: Does not alter persisted messages or agent state; history/UI may still strip thinking separately.
- */
-import type { ReasoningLevel } from '../transcript/thinking-types.js';
-export type SseStreamEvent = {
-    type: string;
-    [key: string]: unknown;
-};
-/**
- * @returns `null` to drop the event; unchanged `event` otherwise.
- */
-export declare function applyReasoningVisibilityToSseEvent(event: SseStreamEvent, reasoningLevel: ReasoningLevel): SseStreamEvent | null;