@graphorin/memory 0.5.0

package/dist/consolidator/runtime.js

@@ -0,0 +1,580 @@
+import { DEFAULT_SALIENCE_WEIGHTS } from "./decay.js";
+import { CustomTierMisconfiguredError, ProviderNotConfiguredError } from "./errors.js";
+import { BudgetTracker } from "./budget.js";
+import { classifyError, describeError, nextBackoffMs } from "./dlq.js";
+import { tipMessageId } from "./idempotency.js";
+import { LockManager } from "./lock.js";
+import { runDeepPhase } from "./phases/deep.js";
+import { runLightPhase } from "./phases/light.js";
+import { runStandardPhase } from "./phases/standard.js";
+import { runReflectionPass } from "./phases/reflect.js";
+import { registerConsolidatorTriggers } from "./scheduler.js";
+import { CONSOLIDATOR_TIER_DEFAULTS } from "./types.js";
+import { NOOP_TRACER } from "@graphorin/core";
+
+//#region src/consolidator/runtime.ts
+/**
+* Build the runtime consolidator.
+*
+* @stable
+*/
+function createConsolidator(opts) {
+	return new ConsolidatorImpl(opts);
+}
+var ConsolidatorImpl = class {
+	#semantic;
+	#episodic;
+	#store;
+	#consolidatorStore;
+	#tracer;
+	#now;
+	#randomId;
+	#provider;
+	/** Per-phase provider overrides (MCON-7); fall back to `#provider`. */
+	#cheapProvider;
+	#deepProvider;
+	#defaultScope;
+	#listeners = /* @__PURE__ */ new Set();
+	#lockManager;
+	#budget;
+	#config;
+	#running = false;
+	#manuallyPaused = false;
+	#deferredRuns = 0;
+	/**
+	* Message ids of the batch the most recent `#dispatch` operated on
+	* (MCON-10). Captured so a thrown phase can enqueue its DLQ row with
+	* the REAL failed slice instead of `[]` — replays must target the
+	* window that failed, not whatever the cursor points at later.
+	*/
+	#lastDispatchMessageIds = [];
+	/**
+	* Bumped when the runtime cannot persist a deferred run to the
+	* audit log (e.g., adapter omits the consolidator surface). The
+	* `status()` reader merges this with the persisted count so
+	* library-mode callers still observe the deferral.
+	*/
+	#deferredRunsAdjustment = 0;
+	#emptyExtractions = 0;
+	constructor(opts) {
+		this.#semantic = opts.semantic;
+		this.#episodic = opts.episodic ?? null;
+		this.#store = opts.store;
+		this.#consolidatorStore = this.#store.consolidator ?? null;
+		this.#tracer = opts.tracer ?? NOOP_TRACER;
+		this.#now = opts.now ?? Date.now;
+		this.#randomId = opts.randomId ?? (() => {
+			return `cr_${Math.floor(Math.random() * 1e9).toString(36)}${Math.floor(Math.random() * 1e9).toString(36)}`;
+		});
+		this.#provider = opts.provider ?? null;
+		this.#cheapProvider = opts.cheapProvider ?? null;
+		this.#deepProvider = opts.deepProvider ?? null;
+		this.#defaultScope = opts.defaultScope ?? null;
+		this.#config = resolveConfig(opts);
+		this.#lockManager = new LockManager({
+			store: this.#consolidatorStore,
+			waitMs: this.#config.lockWaitMs,
+			maxRunDurationMs: this.#config.ceilings.maxRunDurationMs,
+			now: this.#now,
+			randomId: this.#randomId
+		});
+		this.#budget = new BudgetTracker({
+			maxTokensPerDay: this.#config.ceilings.maxTokensPerDay,
+			maxCostPerDay: this.#config.ceilings.maxCostPerDay,
+			onExceed: this.#config.onExceed,
+			resetSemantics: this.#config.budgetResetSemantics,
+			now: this.#now
+		});
+	}
+	async start() {
+		this.#running = true;
+	}
+	async stop() {
+		this.#running = false;
+	}
+	async pause() {
+		this.#manuallyPaused = true;
+	}
+	async resume() {
+		this.#manuallyPaused = false;
+	}
+	config() {
+		return this.#config;
+	}
+	async registerWithScheduler(scheduler) {
+		if (this.#defaultScope === null) throw new Error("[graphorin/memory] Consolidator.registerWithScheduler requires a defaultScope. Pass `defaultScope` to createConsolidator / createMemory, or call registerConsolidatorTriggers(consolidator, scheduler, { scope }) directly.");
+		return registerConsolidatorTriggers(this, scheduler, { scope: this.#defaultScope });
+	}
+	isFree() {
+		return this.#config.tier === "free";
+	}
+	onPhaseFinished(listener) {
+		this.#listeners.add(listener);
+		return () => {
+			this.#listeners.delete(listener);
+		};
+	}
+	recordExternalSpend(tokens, costUsd) {
+		if (!Number.isFinite(tokens) || tokens <= 0) return;
+		this.#budget.record({
+			phase: "deep",
+			tokens,
+			costUsd: costUsd ?? 0
+		});
+	}
+	async setTier(tier) {
+		const preset = CONSOLIDATOR_TIER_DEFAULTS[tier];
+		if (preset === void 0) throw new Error(`[graphorin/memory] unknown consolidator tier '${tier}'`);
+		if (tier === "custom") throw new Error("[graphorin/memory] consolidator.setTier(\"custom\") requires explicit ceilings — re-create the consolidator with `tier: \"custom\"` + `ceilings`.");
+		this.#config = Object.freeze({
+			...this.#config,
+			tier,
+			phases: preset.phases,
+			ceilings: preset.ceilings,
+			onExceed: preset.onExceed,
+			formEpisodes: preset.formEpisodes,
+			importanceScoring: preset.importanceScoring,
+			reflection: preset.reflection,
+			importanceThreshold: preset.importanceThreshold,
+			reflectionMaxQuestions: preset.reflectionMaxQuestions,
+			contextualRetrieval: preset.contextualRetrieval
+		});
+		this.#budget.reconfigure({
+			maxTokensPerDay: preset.ceilings.maxTokensPerDay,
+			maxCostPerDay: preset.ceilings.maxCostPerDay
+		});
+	}
+	async status() {
+		let lastRunAt;
+		let lastPhase;
+		const lastRuns = {};
+		let pendingConflicts = 0;
+		let dlqSize = 0;
+		let deferredFromStore = 0;
+		if (this.#consolidatorStore !== null && this.#defaultScope !== null) {
+			const state = await this.#consolidatorStore.getState(this.#defaultScope);
+			if (state !== null) {
+				if (state.lastCompletedAt !== null) lastRunAt = new Date(state.lastCompletedAt).toISOString();
+				if (state.lastPhase !== null) lastPhase = state.lastPhase;
+			}
+			dlqSize = (await this.#consolidatorStore.listFailedBatches(this.#defaultScope, 1e3)).length;
+			const recent = await this.#consolidatorStore.listRecentRuns(this.#defaultScope, 500);
+			for (const run of recent) {
+				if (run.status === "deferred") {
+					deferredFromStore += 1;
+					continue;
+				}
+				if (run.status !== "completed" && run.status !== "partial") continue;
+				const stamp = new Date(run.finishedAt ?? run.startedAt).toISOString();
+				if (run.phase === "light" && lastRuns.light === void 0) lastRuns.light = stamp;
+				else if (run.phase === "standard" && lastRuns.standard === void 0) lastRuns.standard = stamp;
+				else if (run.phase === "deep" && lastRuns.deep === void 0) lastRuns.deep = stamp;
+			}
+		}
+		if (this.#store.conflicts !== void 0 && this.#defaultScope !== null) pendingConflicts = (await this.#store.conflicts.listPending(this.#defaultScope, 1e3)).length;
+		const snapshot = this.#budget.snapshot();
+		const persistedDeferred = deferredFromStore + this.#deferredRunsAdjustment;
+		const totalDeferred = Math.max(persistedDeferred, this.#deferredRuns);
+		return {
+			tier: this.#config.tier,
+			triggers: this.#config.triggers,
+			phases: this.#config.phases,
+			running: this.#running,
+			paused: this.#manuallyPaused || snapshot.paused,
+			pendingConflicts,
+			queueDepth: pendingConflicts,
+			dlqSize,
+			deferredRuns: totalDeferred,
+			emptyExtractions: this.#emptyExtractions,
+			lastRuns: Object.freeze(lastRuns),
+			budget: {
+				tokensUsedToday: snapshot.tokensUsedToday,
+				costUsedToday: snapshot.costUsedToday,
+				tokensRemaining: snapshot.tokensRemaining,
+				costRemaining: snapshot.costRemaining,
+				resetAt: snapshot.resetAt
+			},
+			budgetRemaining: {
+				tokens: snapshot.tokensRemaining,
+				costUsd: snapshot.costRemaining
+			},
+			...lastRunAt !== void 0 ? { lastRunAt } : {},
+			...lastPhase !== void 0 ? { lastPhase } : {}
+		};
+	}
+	async trigger(reason, scope) {
+		if (!this.#running) return null;
+		if (this.#manuallyPaused) return null;
+		const phases = this.#planPhases(reason);
+		if (phases.length === 0) return null;
+		if (reason.kind !== "manual" && this.#config.ceilings.cooldownMs > 0) {
+			const eligibleAt = (this.#consolidatorStore !== null ? await this.#consolidatorStore.getState(scope) : null)?.nextEligibleAt ?? null;
+			const firstPhase = phases[0] ?? "light";
+			if (eligibleAt !== null && this.#now() < eligibleAt) return this.#emit({
+				...skipOutcome(firstPhase, "cooldown"),
+				phase: firstPhase
+			}, scope, reason);
+		}
+		let last = null;
+		for (const phase of phases) {
+			last = await this.#runPhase(phase, scope, reason);
+			if (last?.status === "failed" || last?.status === "deferred") break;
+		}
+		return last;
+	}
+	async fireNow(phase, scope) {
+		const target = scope ?? this.#defaultScope;
+		if (target === null) throw new Error("[graphorin/memory] consolidator.fireNow requires a scope (default scope was not configured).");
+		if (!this.#config.phases.includes(phase) && phase !== "light") process.stderr.write(`[graphorin/memory] consolidator.fireNow('${phase}') runs a phase not enabled for tier '${this.#config.tier}' — proceeding (manual flushes bypass phase gating).\n`);
+		return this.#runPhase(phase, target, {
+			kind: "manual",
+			value: phase
+		});
+	}
+	async drainDlq(scope) {
+		const store = this.#consolidatorStore;
+		if (store === null) return 0;
+		const ready = await store.claimReadyBatches(scope, this.#now(), 50);
+		let drained = 0;
+		for (const row of ready) {
+			const replayPhase = row.phase ?? "standard";
+			let succeeded = false;
+			let deferred = false;
+			let lastError = null;
+			try {
+				const outcome = await this.#runPhase(replayPhase, scope, {
+					kind: "manual",
+					value: `dlq-replay:${replayPhase}`
+				});
+				if (outcome?.status === "completed" || outcome?.status === "partial") succeeded = true;
+				else if (outcome?.status === "deferred") {
+					deferred = true;
+					lastError = new Error(outcome.errorMessage ?? "replay deferred");
+				} else if (outcome?.errorMessage != null) lastError = new Error(outcome.errorMessage);
+			} catch (err) {
+				lastError = err;
+			}
+			if (succeeded) {
+				await store.markBatchSucceeded(row.id);
+				drained += 1;
+				continue;
+			}
+			if (deferred) {
+				const delayMs = nextBackoffMs({
+					retryCount: row.retryCount + 1,
+					baseMs: this.#config.dlqBaseBackoffMs,
+					maxMs: this.#config.dlqMaxBackoffMs
+				});
+				await store.rescheduleBatch(row.id, row.retryCount, this.#now() + delayMs);
+				continue;
+			}
+			const nextRetryCount = row.retryCount + 1;
+			if (nextRetryCount >= this.#config.dlqMaxRetries) await store.markBatchExhausted(row.id, describeError(lastError), nextRetryCount);
+			else {
+				const delayMs = nextBackoffMs({
+					retryCount: nextRetryCount,
+					baseMs: this.#config.dlqBaseBackoffMs,
+					maxMs: this.#config.dlqMaxBackoffMs
+				});
+				await store.rescheduleBatch(row.id, nextRetryCount, this.#now() + delayMs);
+			}
+		}
+		return drained;
+	}
+	#planPhases(reason) {
+		const enabled = new Set(this.#config.phases);
+		const planned = [];
+		if (reason.kind === "turn" || reason.kind === "idle" || reason.kind === "event") {
+			if (enabled.has("light")) planned.push("light");
+			if (enabled.has("standard")) planned.push("standard");
+		} else if (reason.kind === "cron" || reason.kind === "manual" || reason.kind === "budget") {
+			if (enabled.has("light")) planned.push("light");
+			if (enabled.has("standard")) planned.push("standard");
+			if (enabled.has("deep")) planned.push("deep");
+		}
+		return planned;
+	}
+	async #runPhase(phase, scope, reason) {
+		const precheck = this.#budget.precheck(phase);
+		if (!precheck.allowed && phase !== "light") return this.#emit({
+			...skipOutcome(phase, precheck.reason ?? "paused"),
+			phase
+		}, scope, reason);
+		const acquisition = await this.#lockManager.acquire(scope);
+		if (acquisition.kind === "deferred") {
+			this.#deferredRuns += 1;
+			const deferredRunId = this.#randomId();
+			const deferredAt = this.#now();
+			if (this.#consolidatorStore !== null) try {
+				await this.#consolidatorStore.recordRunStart({
+					id: deferredRunId,
+					scope,
+					triggerKind: reason.kind,
+					phase,
+					startedAt: deferredAt
+				});
+				await this.#consolidatorStore.recordRunFinish({
+					id: deferredRunId,
+					finishedAt: deferredAt,
+					status: "deferred",
+					errorMessage: `lock held by ${acquisition.heldBy ?? "unknown"}`
+				});
+			} catch {
+				this.#deferredRunsAdjustment += 1;
+			}
+			else this.#deferredRunsAdjustment += 1;
+			return this.#emit({
+				phase,
+				status: "deferred",
+				factsCreated: 0,
+				factsUpdated: 0,
+				conflictsResolved: 0,
+				episodesFormed: 0,
+				insightsCreated: 0,
+				noiseFilteredCount: 0,
+				emptyExtractions: 0,
+				llmTokensUsed: 0,
+				llmCostUsd: null,
+				errorMessage: `lock held by ${acquisition.heldBy ?? "unknown"}`
+			}, scope, reason);
+		}
+		const runId = acquisition.runId;
+		const startedAt = this.#now();
+		if (this.#consolidatorStore !== null) await this.#consolidatorStore.recordRunStart({
+			id: runId,
+			scope,
+			triggerKind: reason.kind,
+			phase,
+			startedAt
+		});
+		let outcome;
+		try {
+			outcome = await this.#dispatch(phase, scope);
+		} catch (err) {
+			outcome = {
+				phase,
+				status: "failed",
+				factsCreated: 0,
+				factsUpdated: 0,
+				conflictsResolved: 0,
+				episodesFormed: 0,
+				insightsCreated: 0,
+				noiseFilteredCount: 0,
+				emptyExtractions: 0,
+				llmTokensUsed: 0,
+				llmCostUsd: null,
+				errorMessage: describeError(err)
+			};
+			const isDlqReplay = reason.kind === "manual" && typeof reason.value === "string" && reason.value.startsWith("dlq-replay:");
+			if (this.#consolidatorStore !== null && !isDlqReplay) await this.#consolidatorStore.enqueueFailedBatch({
+				id: this.#randomId(),
+				consolidatorRunId: runId,
+				scope,
+				messageIds: this.#lastDispatchMessageIds,
+				errorKind: classifyError(err),
+				errorMessage: describeError(err),
+				failedAt: this.#now(),
+				nextRetryAt: this.#now() + nextBackoffMs({
+					retryCount: 0,
+					baseMs: this.#config.dlqBaseBackoffMs,
+					maxMs: this.#config.dlqMaxBackoffMs
+				}),
+				retryCount: 0,
+				phase
+			});
+		}
+		if (outcome.emptyExtractions > 0) this.#emptyExtractions += outcome.emptyExtractions;
+		if (this.#consolidatorStore !== null) {
+			await this.#consolidatorStore.recordRunFinish({
+				id: runId,
+				finishedAt: this.#now(),
+				status: outcome.status,
+				llmTokensUsed: outcome.llmTokensUsed,
+				llmCostUsd: outcome.llmCostUsd,
+				factsCreated: outcome.factsCreated,
+				factsUpdated: outcome.factsUpdated,
+				conflictsResolved: outcome.conflictsResolved,
+				noiseFilteredCount: outcome.noiseFilteredCount,
+				emptyExtractions: outcome.emptyExtractions,
+				episodesFormed: outcome.episodesFormed,
+				insightsCreated: outcome.insightsCreated,
+				errorMessage: outcome.errorMessage
+			});
+			await this.#consolidatorStore.upsertState(scope, {
+				lastPhase: phase,
+				lastCompletedAt: this.#now(),
+				nextEligibleAt: this.#now() + this.#config.ceilings.cooldownMs
+			});
+		}
+		await this.#lockManager.release(scope, runId);
+		return this.#emit(outcome, scope, reason);
+	}
+	async #dispatch(phase, scope) {
+		this.#lastDispatchMessageIds = [];
+		const lastProcessedMessageId = (this.#consolidatorStore !== null ? await this.#consolidatorStore.getState(scope) : null)?.lastProcessedMessageId ?? null;
+		if (phase === "light") return await runLightPhase({
+			store: this.#store,
+			consolidatorStore: this.#consolidatorStore,
+			tracer: this.#tracer,
+			scope,
+			now: this.#now,
+			decayTauDays: this.#config.decayTauDays,
+			decayArchiveThreshold: this.#config.decayArchiveThreshold,
+			decayCapacity: this.#config.decayCapacity,
+			salienceWeights: this.#config.salienceWeights,
+			noiseFilters: this.#config.noiseFilters,
+			maxBatchSize: this.#config.maxStandardBatchSize,
+			lastProcessedMessageId,
+			tier: this.#config.tier
+		});
+		if (phase === "standard") {
+			const standardProvider = this.#cheapProvider ?? this.#provider;
+			if (standardProvider === null) throw new ProviderNotConfiguredError("standard");
+			const session = this.#store.session;
+			const rawBatch = typeof session.listMessagesSince === "function" ? await session.listMessagesSince(scope, lastProcessedMessageId, this.#config.maxStandardBatchSize) : [];
+			this.#lastDispatchMessageIds = rawBatch.map((r) => r.id);
+			const out = await runStandardPhase({
+				semantic: this.#semantic,
+				episodic: this.#episodic,
+				formEpisodes: this.#config.formEpisodes,
+				importanceScoring: this.#config.importanceScoring,
+				autoPromoteExtraction: this.#config.autoPromoteExtraction,
+				contextualRetrieval: this.#config.contextualRetrieval,
+				store: this.#store,
+				consolidatorStore: this.#consolidatorStore,
+				provider: standardProvider,
+				tracer: this.#tracer,
+				scope,
+				cheapModel: this.#config.cheapModel,
+				noiseFilters: this.#config.noiseFilters,
+				maxBatchSize: this.#config.maxStandardBatchSize,
+				lastProcessedMessageId,
+				budget: this.#budget,
+				tier: this.#config.tier === "free" ? "cheap" : this.#config.tier,
+				now: this.#now,
+				batch: rawBatch
+			});
+			const cursor = tipMessageId(rawBatch);
+			if (cursor !== null && this.#consolidatorStore !== null) await this.#consolidatorStore.upsertState(scope, { lastProcessedMessageId: cursor });
+			return out;
+		}
+		const deepProvider = this.#deepProvider ?? this.#provider;
+		if (deepProvider === null) throw new ProviderNotConfiguredError("deep");
+		const deepOut = await runDeepPhase({
+			store: this.#store,
+			consolidatorStore: this.#consolidatorStore,
+			provider: deepProvider,
+			tracer: this.#tracer,
+			scope,
+			deepModel: this.#config.deepModel,
+			maxConflictsPerRun: this.#config.maxDeepConflictsPerRun,
+			budget: this.#budget,
+			tier: this.#config.tier === "free" || this.#config.tier === "cheap" ? "standard" : this.#config.tier,
+			now: this.#now
+		});
+		const insightStore = this.#store.insights;
+		if (this.#config.reflection && this.#episodic !== null && insightStore !== void 0) {
+			const priorWatermark = this.#consolidatorStore !== null ? (await this.#consolidatorStore.getState(scope))?.reflectionWatermark ?? null : null;
+			const reflection = await runReflectionPass({
+				provider: deepProvider,
+				tracer: this.#tracer,
+				scope,
+				semantic: this.#semantic,
+				episodic: this.#episodic,
+				insights: insightStore,
+				budget: this.#budget,
+				importanceThreshold: this.#config.importanceThreshold,
+				reflectionWatermark: priorWatermark,
+				maxQuestions: this.#config.reflectionMaxQuestions,
+				now: this.#now
+			});
+			if (this.#consolidatorStore !== null && reflection.nextWatermark !== priorWatermark) await this.#consolidatorStore.upsertState(scope, { reflectionWatermark: reflection.nextWatermark });
+			return {
+				...deepOut,
+				insightsCreated: reflection.insightsCreated,
+				llmTokensUsed: deepOut.llmTokensUsed + reflection.tokens,
+				llmCostUsd: deepOut.llmCostUsd === null && reflection.costUsd === 0 ? null : (deepOut.llmCostUsd ?? 0) + reflection.costUsd
+			};
+		}
+		return deepOut;
+	}
+	#emit(outcome, scope, reason) {
+		for (const listener of this.#listeners) try {
+			listener({
+				...outcome,
+				scope,
+				trigger: reason
+			});
+		} catch {}
+		return outcome;
+	}
+};
+function skipOutcome(phase, reason) {
+	return {
+		phase,
+		status: "deferred",
+		factsCreated: 0,
+		factsUpdated: 0,
+		conflictsResolved: 0,
+		episodesFormed: 0,
+		insightsCreated: 0,
+		noiseFilteredCount: 0,
+		emptyExtractions: 0,
+		llmTokensUsed: 0,
+		llmCostUsd: null,
+		errorMessage: `phase skipped — ${reason}`
+	};
+}
+/** Resolve operator-supplied options into a fully-defaulted config. */
+function resolveConfig(opts) {
+	const tier = opts.tier ?? "free";
+	const preset = CONSOLIDATOR_TIER_DEFAULTS[tier];
+	if (preset === void 0) throw new Error(`[graphorin/memory] unknown consolidator tier '${tier}'`);
+	const ceilings = {
+		...preset.ceilings,
+		...opts.ceilings ?? {}
+	};
+	const phases = opts.phases ?? preset.phases;
+	if (tier === "custom") {
+		const missing = [];
+		if (ceilings.maxTokensPerDay <= 0) missing.push("ceilings.maxTokensPerDay");
+		if (ceilings.maxCostPerDay <= 0) missing.push("ceilings.maxCostPerDay");
+		if (phases.length === 0) missing.push("phases");
+		if (missing.length > 0) throw new CustomTierMisconfiguredError(missing);
+	}
+	return Object.freeze({
+		triggers: Object.freeze([...opts.triggers ?? defaultTriggers()]),
+		tier,
+		phases: Object.freeze([...phases]),
+		ceilings,
+		onExceed: opts.onExceed ?? preset.onExceed,
+		cheapModel: opts.cheapModel ?? preset.cheapModel,
+		deepModel: opts.deepModel ?? preset.deepModel,
+		budgetResetSemantics: opts.budgetResetSemantics ?? "utc",
+		noiseFilters: Object.freeze([...opts.noiseFilters ?? ["default"]]),
+		lockWaitMs: opts.lockWaitMs ?? 3e4,
+		decayTauDays: opts.decayTauDays ?? 7,
+		decayArchiveThreshold: opts.decayArchiveThreshold ?? .05,
+		decayCapacity: opts.decayCapacity ?? null,
+		salienceWeights: opts.salienceWeights ?? DEFAULT_SALIENCE_WEIGHTS,
+		maxStandardBatchSize: opts.maxStandardBatchSize ?? 50,
+		maxDeepConflictsPerRun: opts.maxDeepConflictsPerRun ?? 20,
+		dlqMaxRetries: opts.dlqMaxRetries ?? 5,
+		dlqBaseBackoffMs: opts.dlqBaseBackoffMs ?? 6e4,
+		dlqMaxBackoffMs: opts.dlqMaxBackoffMs ?? 3600 * 1e3,
+		formEpisodes: opts.formEpisodes ?? preset.formEpisodes,
+		importanceScoring: opts.importanceScoring ?? preset.importanceScoring,
+		autoPromoteExtraction: opts.autoPromoteExtraction ?? false,
+		reflection: opts.reflection ?? preset.reflection,
+		importanceThreshold: opts.importanceThreshold ?? preset.importanceThreshold,
+		reflectionMaxQuestions: opts.reflectionMaxQuestions ?? preset.reflectionMaxQuestions,
+		contextualRetrieval: opts.contextualRetrieval ?? preset.contextualRetrieval
+	});
+}
+function defaultTriggers() {
+	return ["idle:5m", "cron:0 4 * * *"];
+}
+
+//#endregion
+export { createConsolidator };
+//# sourceMappingURL=runtime.js.map