@mastra/memory 1.27.0-alpha.1 → 1.27.0-alpha.3

package/dist/{src-_7ADtEwc.cjs → src-Ik0ksTOt.cjs}

@@ -43,17 +43,17 @@ let async_mutex = require("async-mutex");
 let lru_cache = require("lru-cache");
 let xxhash_wasm = require("xxhash-wasm");
 xxhash_wasm = __toESM$1(xxhash_wasm, 1);
+let _mastra_core_storage = require("@mastra/core/storage");
+let crypto$1 = require("crypto");
+let _mastra_core_tools = require("@mastra/core/tools");
 let _mastra_core_llm = require("@mastra/core/llm");
 let fs = require("fs");
 let path = require("path");
 let _mastra_core_request_context = require("@mastra/core/request-context");
 let tokenx = require("tokenx");
-let crypto$1 = require("crypto");
-let _mastra_core_storage = require("@mastra/core/storage");
 let async_hooks = require("async_hooks");
 let probe_image_size_sync_js = require("probe-image-size/sync.js");
 probe_image_size_sync_js = __toESM$1(probe_image_size_sync_js, 1);
-let _mastra_core_tools = require("@mastra/core/tools");
 let _mastra_core_schema = require("@mastra/core/schema");
 let _mastra_core_error = require("@mastra/core/error");
 let _mastra_core_processors = require("@mastra/core/processors");
@@ -14637,162 +14637,6 @@ createIdGenerator({
 	size: 24
 });
 //#endregion
-//#region src/processors/observational-memory/constants.ts
-var constants_exports = /* @__PURE__ */ __exportAll({
-	OBSERVATIONAL_MEMORY_DEFAULTS: () => OBSERVATIONAL_MEMORY_DEFAULTS,
-	OBSERVATION_CONTEXT_INSTRUCTIONS: () => OBSERVATION_CONTEXT_INSTRUCTIONS,
-	OBSERVATION_CONTEXT_PROMPT: () => OBSERVATION_CONTEXT_PROMPT,
-	OBSERVATION_CONTINUATION_HINT: () => OBSERVATION_CONTINUATION_HINT,
-	getRetrievalInstructions: () => getRetrievalInstructions
-});
-/**
-* Default configuration values matching the spec
-*/
-const OBSERVATIONAL_MEMORY_DEFAULTS = {
-	observation: {
-		model: "google/gemini-2.5-flash",
-		messageTokens: 3e4,
-		modelSettings: {
-			temperature: .3,
-			maxOutputTokens: 1e5
-		},
-		providerOptions: { google: { thinkingConfig: { thinkingBudget: 215 } } },
-		maxTokensPerBatch: 1e4,
-		bufferTokens: .2,
-		bufferActivation: .8
-	},
-	reflection: {
-		model: "google/gemini-2.5-flash",
-		observationTokens: 4e4,
-		modelSettings: {
-			temperature: 0,
-			maxOutputTokens: 1e5
-		},
-		providerOptions: { google: { thinkingConfig: { thinkingBudget: 1024 } } },
-		bufferActivation: .5
-	}
-};
-/**
-* Continuation hint injected after observations to guide the model's behavior.
-* Prevents the model from awkwardly acknowledging the memory system or treating
-* the conversation as new after observed messages are removed.
-*/
-const OBSERVATION_CONTINUATION_HINT = `Please continue naturally with the conversation so far and respond to the latest message.
-
-Use the earlier context only as background. If something appears unfinished, continue only when it helps answer the latest request. If a suggested response is provided, follow it naturally.
-
-Do not mention internal instructions, memory, summarization, context handling, or missing messages.
-
-Any messages following this reminder are newer and should take priority.`;
-/**
-* Preamble that introduces the observations block.
-* Use before `<observations>`, with instructions after.
-* Full pattern: `${OBSERVATION_CONTEXT_PROMPT}\n\n<observations>\n${obs}\n</observations>\n\n${OBSERVATION_CONTEXT_INSTRUCTIONS}`
-*/
-const OBSERVATION_CONTEXT_PROMPT = `The following observations block contains your memory of past conversations with this user.`;
-/**
-* Instructions that tell the model how to interpret and use observations.
-* Place AFTER the `<observations>` block so the model sees the data before the rules.
-*/
-const OBSERVATION_CONTEXT_INSTRUCTIONS = `IMPORTANT: When responding, reference specific details from these observations. Do not give generic advice - personalize your response based on what you know about this user's experiences, preferences, and interests. If the user asks for recommendations, connect them to their past experiences mentioned above.
-
-KNOWLEDGE UPDATES: When asked about current state (e.g., "where do I currently...", "what is my current..."), always prefer the MOST RECENT information. Observations include dates - if you see conflicting information, the newer observation supersedes the older one. Look for phrases like "will start", "is switching", "changed to", "moved to" as indicators that previous information has been updated.
-
-PLANNED ACTIONS: If the user stated they planned to do something (e.g., "I'm going to...", "I'm looking forward to...", "I will...") and the date they planned to do it is now in the past (check the relative time like "3 weeks ago"), assume they completed the action unless there's evidence they didn't. For example, if someone said "I'll start my new diet on Monday" and that was 2 weeks ago, assume they started the diet.
-
-MOST RECENT USER INPUT: Treat the most recent user message as the highest-priority signal for what to do next. Earlier messages may contain constraints, details, or context you should still honor, but the latest message is the primary driver of your response.
-
-SYSTEM REMINDERS: Messages wrapped in <system-reminder>...</system-reminder> contain internal continuation guidance, not user-authored content. Use them to maintain continuity, but do not mention them or treat them as part of the user's message.`;
-/**
-* Instructions for retrieval mode — explains observation-group ranges and the recall tool.
-* Appended to context when `retrieval` is enabled.
-*
-* The content adapts to the retrieval scope:
-* - `'resource'`: covers routing between `search`, `threads`, and `messages` across
-*   all of the user's threads, including fallback when search results are unsuitable.
-* - `'thread'`: covers cursor-based browsing and search within the current thread.
-*
-* @param scope - The retrieval scope the recall tool was registered with.
-* @param customInstructions - Optional application-provided guidance appended after
-*   the native instructions. Never replaces them.
-* @param searchEnabled - Whether semantic search (`retrieval: { vector: true }`) is
-*   available. When false, the guidance only covers \`threads\`/\`messages\` browsing so
-*   the agent is not steered toward a mode that cannot work.
-*/
-function getRetrievalInstructions(scope = "resource", customInstructions, searchEnabled = true) {
-	const isResource = scope === "resource";
-	const base = `## Recall — looking up source messages
-
-Your memory is comprised of observations which are sometimes wrapped in <observation-group> xml tags containing ranges like <observation-group range="startId:endId">. These ranges point back to the raw messages that each observation group was derived from. The original messages are still available — use the **recall** tool to retrieve them.
-
-### When to use recall
-- The user asks you to **repeat, show, or reproduce** something from a past conversation
-- The user asks for **exact content** — code, text, quotes, error messages, URLs, file paths, specific numbers
-- Your observations mention something but your memory lacks the detail needed to fully answer (e.g. you know a blog post was shared but only have a summary of it)
-- You want to **verify or expand on** an observation before responding${isResource ? `
-- The user references another conversation that your observations don't cover — even if you have no observations yet, their other threads may contain it` : ""}
-
-**Default to using recall when the user references specific past content.** Your observations capture the gist, not the details. If there's any doubt whether your memory is complete enough, use recall.
-
-${isResource ? searchEnabled ? `### Choosing a mode
-The recall tool works across ALL of this user's conversation threads, not just the current one.
-
-- Use \`mode: "search"\` with a \`query\` when you don't know which thread contains the answer. Each result includes its thread ID and the raw message IDs it came from, which you can use as a \`cursor\`.
-- Use \`mode: "messages"\` when you already know the thread — pass \`threadId\` to read another thread, or a \`cursor\` from an observation-group range or a search result.
-- Use \`mode: "threads"\` to list the user's threads (IDs, titles, dates) when you need to discover where something was discussed. Use \`before\`/\`after\` to narrow by date.
-
-**If search results look irrelevant, do not give up.** Search only covers content that has been indexed — a short or recent conversation may exist in raw message history before any observation of it was created. When search returns nothing suitable but the user is clearly referring to a past conversation, call \`mode: "threads"\` to find candidate threads (titles and dates are strong clues), then read them with \`mode: "messages"\`. If a search result already gives you a thread ID, go straight to \`mode: "messages"\`.` : `### Choosing a mode
-The recall tool works across ALL of this user's conversation threads, not just the current one.
-
-- Use \`mode: "threads"\` to list the user's threads (IDs, titles, dates) when you need to discover where something was discussed. Use \`before\`/\`after\` to narrow by date.
-- Use \`mode: "messages"\` when you know the thread — pass \`threadId\` to read another thread, or a \`cursor\` from an observation-group range.
-
-When the user refers to a past conversation you don't have a cursor for, call \`mode: "threads"\` to find candidate threads (titles and dates are strong clues), then read them with \`mode: "messages"\`. Raw history may exist for threads that have no observations yet.` : `### Choosing a mode
-The recall tool is limited to the current conversation thread.
-
-- Use \`mode: "messages"\` (default) to page through this thread's message history near a cursor.${searchEnabled ? `
-- Use \`mode: "search"\` with a \`query\` to find messages by content within this thread.` : ""}
-- Use \`mode: "threads"\` to get the current thread's ID, title, and dates.`}
-
-### How to use recall with a cursor
-Each range has the format \`startId:endId\` where both are message IDs separated by a colon.
-
-1. Find the observation group relevant to the user's question and extract the start or end ID from its range.
-2. Call \`recall\` with that ID as the \`cursor\`.
-3. Use \`page: 1\` (or omit) to read forward from the cursor, \`page: -1\` to read backward.
-4. If the first page doesn't have what you need, increment the page number to keep paginating.
-5. Check \`hasNextPage\`/\`hasPrevPage\` in the result to know if more pages exist in each direction.
-
-### Detail levels
-By default recall returns **low** detail: truncated text and tool names only. Each message shows its ID and each part has a positional index like \`[p0]\`, \`[p1]\`, etc.
-
-- Use \`detail: "high"\` to get full message content including tool arguments and results. This will only return the high detail version of a single message part at a time.
-- Use \`partIndex\` with a cursor to fetch a single part at full detail — for example, to read one specific tool result or code block without loading every part.
-
-If the result says \`truncated: true\`, the output was cut to fit the token budget. You can paginate or use \`partIndex\` to target specific content. If a single part is itself too large, follow the returned \`nextCharOffset\` as described below.
-
-### Following up on truncated parts
-Low-detail results may include truncation hints like:
-\`[truncated — call recall cursor="..." partIndex=N detail="high" for full content]\`
-
-**When you see these hints and need the full content, make the exact call described in the hint.** This is the normal workflow: first recall at low detail to scan, then drill into specific parts at high detail. Do not stop at the low-detail result if the user asked for exact content.
-
-If a single part is larger than the token budget, the \`partIndex\` result is \`truncated: true\` and includes \`nextCharOffset\`. Repeat the same call with \`charOffset\` set to that exact value to read the next chunk from where the previous one ended. Keep following \`nextCharOffset\` until the result no longer includes it — the chunks together contain the full part. Retrying without \`charOffset\` returns the same prefix again.
-
-### When recall is NOT needed
-- The user is asking for a high-level summary and your observations already cover it
-- The question is about general preferences or facts that don't require source text
-${isResource ? `- No relevant observation range exists AND ${searchEnabled ? "`search`/`threads`" : "`threads`"} turned up nothing — but remember that raw history may exist for threads that have no observations yet, so check before concluding the information is unavailable` : `- There is no relevant range in your observations for the topic`}
-
-Observation groups with range IDs and your recall tool allows you to think back and remember details you're fuzzy on.`;
-	const custom = customInstructions?.trim();
-	if (!custom) return base;
-	return `${base}
-
-### Additional recall guidance
-${custom}`;
-}
-//#endregion
 //#region src/processors/observational-memory/extractor.ts
 const BUILT_IN_SLUGS = /* @__PURE__ */ new Set([
 	"current-task",
@@ -14867,24 +14711,29 @@ var Extractor = class Extractor {
 		const name = config.name.trim();
 		const instructions = typeof config.instructions === "string" ? config.instructions.trim() : void 0;
 		const slug = slugifyExtractorName(name);
+		const isHook = config.mode === "hook";
 		if (!name) throw new Error("Extractor name is required.");
+		if (!isHook && !config.instructions) throw new Error(`Extractor "${name}" must include instructions.`);
 		if (instructions !== void 0 && !instructions) throw new Error(`Extractor "${name}" must include instructions.`);
+		if (isHook && !config.onExtracted) throw new Error(`Hook extractor "${name}" must include an onExtracted handler.`);
+		if (isHook && (config.instructions || config.schema)) throw new Error(`Hook extractor "${name}" cannot include instructions or a schema.`);
 		assertValidSlug(slug, name);
 		if (!internal && RESERVED_XML_TAGS.has(slug)) throw new Error(`Extractor slug "${slug}" is reserved by Observational Memory.`);
 		this.name = name;
 		this.slug = slug;
-		this.instructionsConfig = config.instructions;
+		this.instructionsConfig = config.instructions ?? "";
 		this.schemaConfig = config.schema;
 		this.instructions = instructions ?? "";
-		this.schema = typeof config.schema === "function" ? zod.z.string() : config.schema ?? zod.z.string();
-		this.mode = internal || !config.schema ? "inline" : "structured";
-		this.includePreviousExtraction = config.includePreviousExtraction ?? true;
-		this.metadataKeyPath = config.metadataKeyPath ?? `extracted.${slug}`;
+		this.schema = isHook ? zod.z.unknown() : typeof config.schema === "function" ? zod.z.string() : config.schema ?? zod.z.string();
+		this.mode = isHook ? "hook" : internal || !config.schema ? "inline" : "structured";
+		this.includePreviousExtraction = isHook ? false : config.includePreviousExtraction ?? true;
+		this.metadataKeyPath = isHook ? false : config.metadataKeyPath ?? `extracted.${slug}`;
 		this.onExtracted = config.onExtracted;
 		this.retryStructuredExtractionOnEmptyObject = config.retryStructuredExtractionOnEmptyObject ?? false;
 		this.internal = internal;
 	}
 	async resolve(context) {
+		if (this.mode === "hook") return this;
 		const instructions = typeof this.instructionsConfig === "function" ? (await this.instructionsConfig(context)).trim() : this.instructionsConfig.trim();
 		if (!instructions) throw new Error(`Extractor "${this.name}" must include instructions.`);
 		const schema = typeof this.schemaConfig === "function" ? await this.schemaConfig(context) : this.schemaConfig;
@@ -15021,81 +14870,2416 @@ function buildExtractorPriorLines(extractors, priorExtractedValues) {
 	return lines;
 }
 //#endregion
-//#region src/processors/observational-memory/extracted-values.ts
-const BUILT_IN_METADATA_FIELDS = {
-	"current-task": {
-		metadataField: "currentTask",
-		builtInField: "currentTask"
-	},
-	"suggested-response": {
-		metadataField: "suggestedResponse",
-		builtInField: "suggestedContinuation"
-	},
-	"thread-title": {
-		metadataField: "threadTitle",
-		builtInField: "threadTitle"
+//#region src/processors/observational-memory/subconscious/activity.ts
+const SUBCONSCIOUS_ACTIVITY_STATE_ID = "subconscious-activity";
+async function getActivityTarget(store, event, scope) {
+	if (event.recordType === "node") {
+		const node = await store.getNode(event.recordId);
+		if (!node || !(0, _mastra_core_storage.isKnowledgeScopeVisible)(node.scope, scope)) return {
+			id: event.recordId,
+			type: "node"
+		};
+		return {
+			id: node.id,
+			name: node.name,
+			type: "node"
+		};
 	}
-};
-function isPresentExtractedValue(value) {
-	return value !== void 0 && value !== null && value !== "";
+	const record = await store.getKnowledge({
+		id: event.recordId,
+		includeDeleted: true
+	});
+	const node = record ? await store.getNode(record.node) : void 0;
+	if (!node || !(0, _mastra_core_storage.isKnowledgeScopeVisible)(node.scope, scope)) return {
+		id: event.recordId,
+		type: "node"
+	};
+	return {
+		id: node.id,
+		name: node.name,
+		type: "node"
+	};
 }
-function normalizeExtractedValues(values) {
-	if (!values) return;
-	const normalized = Object.fromEntries(Object.entries(values).filter(([, value]) => isPresentExtractedValue(value)));
-	return Object.keys(normalized).length > 0 ? normalized : void 0;
+async function buildSubconsciousActivitySnapshot(input) {
+	const events = await input.store.listActivity({
+		scope: input.scope,
+		limit: input.recentUpdates
+	});
+	const resolvedUpdates = await Promise.all(events.map(async (event) => {
+		const target = await getActivityTarget(input.store, event, input.scope);
+		return {
+			action: event.action,
+			type: event.recordType,
+			name: target.name,
+			targetId: target.id,
+			targetType: target.type,
+			createdAt: event.createdAt.toISOString()
+		};
+	}));
+	const hotByRecord = /* @__PURE__ */ new Map();
+	for (const update of resolvedUpdates) {
+		if (!update.name) continue;
+		const key = `${update.targetType}:${update.targetId}`;
+		const existing = hotByRecord.get(key);
+		if (existing) existing.updates += 1;
+		else hotByRecord.set(key, {
+			type: update.targetType,
+			name: update.name,
+			updates: 1
+		});
+	}
+	const hot = [...hotByRecord.values()].sort((a, b) => b.updates - a.updates || a.name.localeCompare(b.name)).slice(0, input.recentUpdates);
+	const updates = resolvedUpdates.map((update) => ({
+		action: update.action,
+		type: update.type,
+		...update.name ? { name: update.name } : {},
+		createdAt: update.createdAt
+	}));
+	const errors = input.errors?.filter(Boolean).slice(0, input.recentUpdates);
+	return {
+		updates,
+		hot,
+		...errors?.length ? { errors } : {}
+	};
 }
-function mergeExtractedValues(...valueSets) {
-	const merged = {};
-	for (const values of valueSets) {
-		const normalized = normalizeExtractedValues(values);
-		if (normalized) Object.assign(merged, normalized);
-	}
-	return Object.keys(merged).length > 0 ? merged : void 0;
+function renderSubconsciousActivity(snapshot) {
+	const lines = snapshot.updates.map((update) => {
+		const target = update.name ? `${update.type} [[${update.name}]]` : update.type;
+		return `- ${update.action}: ${target}`;
+	});
+	const hot = snapshot.hot.map((record) => `[[${record.name}]] (${record.updates})`).join(", ");
+	return [
+		hot ? `Hot: ${hot}` : "Hot: none",
+		"Recent updates:",
+		...lines.length ? lines : ["- none"],
+		...snapshot.errors?.length ? ["Errors:", ...snapshot.errors.map((error) => `- ${error}`)] : []
+	].join("\n");
+}
+async function publishSubconsciousError(input) {
+	await input.writer?.custom({
+		type: "data-subconscious-error",
+		data: {
+			error: input.error,
+			agent: input.agent
+		}
+	});
+	if (!input.sendStateSignal) return;
+	const snapshot = {
+		updates: [],
+		hot: [],
+		errors: [input.error]
+	};
+	const contents = renderSubconsciousActivity(snapshot);
+	await input.sendStateSignal({
+		id: SUBCONSCIOUS_ACTIVITY_STATE_ID,
+		mode: "snapshot",
+		cacheKey: (0, crypto$1.createHash)("sha256").update(contents).digest("hex"),
+		tagName: "state",
+		attributes: { id: SUBCONSCIOUS_ACTIVITY_STATE_ID },
+		metadata: { origin: "subconscious" },
+		contents,
+		value: snapshot
+	});
 }
-function mergeExtractionFailures(...failureSets) {
-	const failures = failureSets.flatMap((set) => set ?? []);
-	return failures.length > 0 ? failures : void 0;
+async function publishSubconsciousActivity(input) {
+	if (!input.sendStateSignal) return void 0;
+	const snapshot = await buildSubconsciousActivitySnapshot(input);
+	const contents = renderSubconsciousActivity(snapshot);
+	const cacheKey = (0, crypto$1.createHash)("sha256").update(contents).digest("hex");
+	await input.sendStateSignal({
+		id: SUBCONSCIOUS_ACTIVITY_STATE_ID,
+		mode: "snapshot",
+		cacheKey,
+		tagName: "state",
+		attributes: { id: SUBCONSCIOUS_ACTIVITY_STATE_ID },
+		metadata: { origin: "subconscious" },
+		contents,
+		value: snapshot
+	});
+	return snapshot;
 }
-const UNSAFE_METADATA_PATH_SEGMENTS = /* @__PURE__ */ new Set([
-	"__proto__",
-	"constructor",
-	"prototype"
-]);
-function getMetadataPathSegments(keyPath) {
-	if (keyPath === false) return;
-	const segments = keyPath.split(".").filter(Boolean);
-	if (segments.some((segment) => UNSAFE_METADATA_PATH_SEGMENTS.has(segment))) throw new Error(`Extractor metadataKeyPath "${keyPath}" contains an unsafe path segment.`);
-	return segments.length > 0 ? segments : void 0;
+//#endregion
+//#region src/processors/observational-memory/subconscious/pinned.ts
+/** Processor id and state-signal id for the pinned-knowledge lane. */
+const SUBCONSCIOUS_PINS_STATE_ID = "subconscious-pins";
+/** Snapshot tag the model sees; the delta tag appends `-update`. */
+const PINNED_SNAPSHOT_TAG = "pinned-knowledge";
+const PINNED_DELTA_TAG = "pinned-knowledge-update";
+/** Reserved node holding the pin set. One record, at one fixed scope level. */
+const PINNED_NODE_NAME = "pinned";
+const PINNED_NODE_KIND = "system";
+const PINNED_NODE_SCOPE_LEVEL = "resource";
+const DEFAULT_PINNED_MAX_CHARACTERS = 2e3;
+const MAX_PINNED_MAX_CHARACTERS = 8e3;
+const PIN_IDENTITY = "subconscious:pin";
+function pinnedNodeScope(scope, maxScope) {
+	return (0, _mastra_core_storage.expandKnowledgeScope)(scope, maxScope === "thread" ? "thread" : PINNED_NODE_SCOPE_LEVEL);
+}
+async function resolvePinnedNodeId(store, scope) {
+	return (await store.resolveNode({
+		name: PINNED_NODE_NAME,
+		scope
+	}))?.id;
+}
+/** Reuse the node wherever it is visible; otherwise create it. `createNode` is an idempotent upsert on (name, scope). */
+async function ensurePinnedNodeId(store, scope, maxScope) {
+	const existing = await resolvePinnedNodeId(store, scope);
+	if (existing) return existing;
+	return (await store.createNode({
+		name: PINNED_NODE_NAME,
+		kind: PINNED_NODE_KIND,
+		scope: pinnedNodeScope(scope, maxScope)
+	})).id;
 }
-function getValueAtPath(metadata, keyPath) {
-	if (!metadata) return;
-	const segments = getMetadataPathSegments(keyPath);
-	if (!segments) return;
-	let current = metadata;
-	for (const segment of segments) {
-		if (!current || typeof current !== "object" || Array.isArray(current)) return;
-		current = current[segment];
-	}
-	return current;
+/**
+* Assembles the current pin set.
+*
+* Reads use the FULL visible scope context, never a level-narrowed write scope: visibility is
+* subset containment, so querying at the node's level would drop pins written at narrower
+* levels. Deleted records are excluded explicitly.
+*/
+async function listPinnedKnowledge(input) {
+	const nodeId = await resolvePinnedNodeId(input.store, input.scope);
+	if (!nodeId) return { pins: [] };
+	const pins = [];
+	let after;
+	do {
+		const page = await input.store.listKnowledgeAbout({
+			node: nodeId,
+			scope: input.scope,
+			after,
+			includeDeleted: false
+		});
+		pins.push(...page.records);
+		after = page.nextCursor;
+	} while (after);
+	return {
+		nodeId,
+		pins
+	};
 }
-function setValueAtPath(metadata, keyPath, value) {
-	if (!isPresentExtractedValue(value)) return;
-	const segments = getMetadataPathSegments(keyPath);
-	if (!segments) return;
-	let current = metadata;
-	for (const segment of segments.slice(0, -1)) {
-		const next = current[segment];
-		if (!next || typeof next !== "object" || Array.isArray(next)) current[segment] = {};
-		current = current[segment];
-	}
-	current[segments[segments.length - 1]] = value;
+function totalCharacters(pins) {
+	return pins.reduce((sum, pin) => sum + pin.text.length, 0);
 }
-function readBuiltInMetadataValues(metadata) {
-	const values = {};
-	for (const slug of BUILT_IN_EXTRACTOR_SLUGS) {
-		const { metadataField } = BUILT_IN_METADATA_FIELDS[slug];
-		values[slug] = metadata[metadataField];
-	}
+function assertBudget(options, pins, incomingText, replacing) {
+	const kept = replacing ? pins.filter((pin) => pin.id !== replacing.id) : pins;
+	if (!replacing && kept.length >= options.maxPins) throw new Error(`Pin limit reached: the set holds at most ${options.maxPins}. Unpin something first.`);
+	if (totalCharacters(kept) + incomingText.length > options.maxCharacters) throw new Error(`Pin budget exceeded: the pin set is limited to ${options.maxCharacters} characters in total.`);
+}
+function clampPinLevel(level) {
+	return level === "org" ? "resource" : level;
+}
+function resolveWriteScope$1(options, level) {
+	let effective = clampPinLevel(level ?? options.defaultScope);
+	if (!level && options.maxScope === "thread") effective = "thread";
+	const scope = (0, _mastra_core_storage.expandKnowledgeScope)(options.scope, effective);
+	(0, _mastra_core_storage.assertKnowledgeScopeWithinCeiling)(scope, options.maxScope);
+	return scope;
+}
+const scopeLevelSchema$1 = {
+	type: "string",
+	enum: ["resource", "thread"]
+};
+/** Shared pin write path used by the tool and capture-time pinning. */
+async function writePinnedKnowledge(store, options, text, level, metadata) {
+	const { pins } = await listPinnedKnowledge({
+		store,
+		scope: options.scope
+	});
+	assertBudget(options, pins, text);
+	const nodeId = await ensurePinnedNodeId(store, options.scope, options.maxScope);
+	return store.appendKnowledge({
+		node: nodeId,
+		text,
+		scope: resolveWriteScope$1(options, level),
+		sourceThreadId: options.sourceThreadId,
+		maxScope: options.maxScope,
+		metadata,
+		resolutionScope: options.scope,
+		defaultScope: (0, _mastra_core_storage.expandKnowledgeScope)(options.scope, options.defaultScope)
+	});
+}
+async function getStore$1(memory) {
+	const store = await memory.storage.getStore("knowledge");
+	if (!store) throw new Error("Pinned knowledge requires a configured knowledge storage domain.");
+	return store;
+}
+async function requirePin(store, recordId, options) {
+	const record = await store.getKnowledge({
+		id: recordId,
+		includeDeleted: false
+	});
+	if (!record) throw new Error(`Pin not found: ${recordId}`);
+	const nodeId = await resolvePinnedNodeId(store, options.scope);
+	if (!nodeId || record.node !== nodeId) throw new Error(`Record is not a pin: ${recordId}`);
+	if (!(0, _mastra_core_storage.isKnowledgeScopeVisible)(record.scope, options.scope)) throw new Error("Pin is outside the visible scope.");
+	return record;
+}
+/**
+* Pin lifecycle tools. Pin appends a record on the reserved node; unpin soft-deletes it
+* (auditable, restorable); edit is remove plus append because knowledge records are immutable,
+* so an edited pin carries a new record id.
+*/
+function createPinnedTools(memory, options) {
+	return {
+		knowledge_pin: (0, _mastra_core_tools.createTool)({
+			id: "knowledge_pin",
+			description: "Pin knowledge that must stay in context every turn without being asked for. Pins cost context permanently; pin only what is unconditionally relevant.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					text: {
+						type: "string",
+						minLength: 1
+					},
+					scope: scopeLevelSchema$1,
+					reason: {
+						type: "string",
+						minLength: 1,
+						description: "One short sentence: why this must stay in context permanently."
+					}
+				},
+				required: ["text"],
+				additionalProperties: false
+			},
+			execute: async (input) => {
+				const value = input;
+				return writePinnedKnowledge(await getStore$1(memory), options, value.text, value.scope, value.reason ? { reason: value.reason } : void 0);
+			}
+		}),
+		knowledge_unpin: (0, _mastra_core_tools.createTool)({
+			id: "knowledge_unpin",
+			description: "Remove a pin. The underlying knowledge record is soft-deleted and drops out of the pinned context.",
+			inputSchema: {
+				type: "object",
+				properties: { recordId: {
+					type: "string",
+					minLength: 1
+				} },
+				required: ["recordId"],
+				additionalProperties: false
+			},
+			execute: async (input) => {
+				const store = await getStore$1(memory);
+				const record = await requirePin(store, input.recordId, options);
+				return store.removeKnowledge({
+					id: record.id,
+					deletedBy: PIN_IDENTITY
+				});
+			}
+		}),
+		knowledge_edit_pin: (0, _mastra_core_tools.createTool)({
+			id: "knowledge_edit_pin",
+			description: "Replace the text of an existing pin. The replacement carries a new knowledge record id.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					recordId: {
+						type: "string",
+						minLength: 1
+					},
+					text: {
+						type: "string",
+						minLength: 1
+					},
+					reason: {
+						type: "string",
+						minLength: 1,
+						description: "One short sentence: why this must stay in context permanently."
+					}
+				},
+				required: ["recordId", "text"],
+				additionalProperties: false
+			},
+			execute: async (input) => {
+				const value = input;
+				const store = await getStore$1(memory);
+				const record = await requirePin(store, value.recordId, options);
+				const { pins } = await listPinnedKnowledge({
+					store,
+					scope: options.scope
+				});
+				assertBudget(options, pins, value.text, record);
+				await store.removeKnowledge({
+					id: record.id,
+					deletedBy: PIN_IDENTITY
+				});
+				return store.appendKnowledge({
+					node: record.node,
+					text: value.text,
+					scope: record.scope,
+					sourceThreadId: options.sourceThreadId,
+					maxScope: record.maxScope,
+					metadata: value.reason ? {
+						...record.metadata,
+						reason: value.reason
+					} : record.metadata,
+					resolutionScope: options.scope,
+					defaultScope: (0, _mastra_core_storage.expandKnowledgeScope)(options.scope, options.defaultScope)
+				});
+			}
+		})
+	};
+}
+//#endregion
+//#region src/processors/observational-memory/subconscious/scope.ts
+/**
+* Resolves the resource rung of a subconscious knowledge scope.
+*
+* When the request context carries a `knowledgeResourceId` override, every
+* scope resolver anchors the resource rung on it instead of the run's
+* resourceId. This lets a host (for example, the factory) share one knowledge
+* graph across many runs of the same project while leaving thread identity and
+* observational memory untouched. Without the override, behavior is unchanged:
+* the fallback (the run's resourceId) is used as-is.
+*/
+function resolveKnowledgeResourceId(requestContext, fallback) {
+	const override = requestContext?.get?.("knowledgeResourceId");
+	if (typeof override === "string" && override.trim()) return override;
+	return fallback;
+}
+//#endregion
+//#region src/processors/observational-memory/subconscious/capture.ts
+const CAPTURE_GUIDANCE_PAGE = "capture-guidance";
+const MAX_CAPTURE_GUIDANCE_LENGTH = 4e3;
+const SCOPE_ORDER = {
+	org: 0,
+	resource: 1,
+	thread: 2
+};
+const subconsciousCaptureSchema = zod.z.object({ nodes: zod.z.array(zod.z.object({
+	name: zod.z.string().trim().min(1),
+	kind: zod.z.string().trim().min(1),
+	scope: zod.z.enum([
+		"org",
+		"resource",
+		"thread"
+	]).optional(),
+	records: zod.z.array(zod.z.object({
+		text: zod.z.string().trim().min(1),
+		scope: zod.z.enum([
+			"org",
+			"resource",
+			"thread"
+		]).optional(),
+		when: zod.z.string().trim().min(1).optional(),
+		reason: zod.z.string().trim().min(1)
+	}))
+})) });
+const subconsciousCapturePinningSchema = zod.z.object({ nodes: zod.z.array(zod.z.object({
+	name: zod.z.string().trim().min(1),
+	kind: zod.z.string().trim().min(1),
+	scope: zod.z.enum([
+		"org",
+		"resource",
+		"thread"
+	]).optional(),
+	records: zod.z.array(zod.z.object({
+		text: zod.z.string().trim().min(1),
+		scope: zod.z.enum([
+			"org",
+			"resource",
+			"thread"
+		]).optional(),
+		when: zod.z.string().trim().min(1).optional(),
+		reason: zod.z.string().trim().min(1),
+		pin: zod.z.boolean().optional()
+	}))
+})) });
+const CAPTURE_PINNING_INSTRUCTIONS = `Mark pin: true only for durable user preferences or hard constraints that should apply in every future session without being asked for.`;
+const CAPTURE_INSTRUCTIONS = `Extract durable, explicitly stated knowledge from the observations.
+Return nodes with short stable names, a freeform kind, and knowledge records nested under the node each record is about.
+Use common kinds such as person, task, event, project, organization, or document when they fit.
+Set node scope to the narrowest level where that identity and content should be shared. Omit it to use the configured default scope.
+Knowledge records must be grounded in the conversation, concise, and written as prose. Do not infer unstated information.
+Wrap every named node mentioned in record text in [[wikilinks]].
+Set a record scope only when the conversation establishes where it applies. Use org for organization-wide records, resource for records shared across this resource's conversations, and thread for conversation-private records.
+Omit scope when uncertain; omitted record scopes stay private to the current thread.
+Emit when only when the conversation anchors the referred time. Resolve relative dates against the current date and use ISO 8601.
+Capture what was learned through the work, not what the session was told: skip records that merely restate standing instructions, configured rules, or the text of the task or issue the session was handed. The exception is an explicit request from the user to remember something, which is always captured even when it duplicates an existing instruction.`;
+const CAPTURE_REASON_INSTRUCTIONS = `Every record requires a reason: the concrete why behind capturing it, in one short sentence - what it cost to learn or when it will matter again (and for pinned records, why it must stay in context). Never write generic filler such as "seemed relevant" or "useful context".`;
+function clampScope(level, ceiling) {
+	return ceiling && SCOPE_ORDER[level] < SCOPE_ORDER[ceiling] ? ceiling : level;
+}
+function requireScopeContext(context) {
+	const organizationId = context.requestContext?.get("organizationId");
+	if (typeof organizationId !== "string" || !organizationId.trim()) throw new Error("Subconscious requires requestContext.organizationId to derive scoped knowledge. Set organizationId on the request context for this conversation.");
+	const resourceId = resolveKnowledgeResourceId(context.requestContext, context.resourceId);
+	if (!resourceId) throw new Error("Subconscious requires resourceId to derive scoped knowledge.");
+	if (!context.threadId) throw new Error("Subconscious requires threadId to derive scoped knowledge.");
+	return [
+		`org:${organizationId}`,
+		`resource:${resourceId}`,
+		`thread:${context.threadId}`
+	];
+}
+async function getKnowledgeStore$1(context) {
+	if (!context.memory) throw new Error("Subconscious capture requires an active Memory instance.");
+	const store = await context.memory.storage.getStore("knowledge");
+	if (!store) throw new Error("Subconscious requires a knowledge storage domain. Configure a storage adapter that provides stores.knowledge.");
+	return store;
+}
+function parseWhen(value) {
+	if (!value) return void 0;
+	const when = new Date(value);
+	if (Number.isNaN(when.getTime())) throw new Error(`Invalid Subconscious record time: ${value}`);
+	return when;
+}
+var SubconsciousCaptureExtractor = class extends Extractor {
+	constructor(options) {
+		const capturePinning = options.pins !== false && options.pins !== void 0 && options.pins.capturePinning;
+		const pinNotes = /* @__PURE__ */ new WeakMap();
+		const defaultImplementation = async (context) => {
+			const scopeContext = requireScopeContext(context);
+			const store = await getKnowledgeStore$1(context);
+			const droppedPins = [];
+			for (const extractedNode of context.current.nodes) {
+				const nodeScope = (0, _mastra_core_storage.expandKnowledgeScope)(scopeContext, clampScope(extractedNode.scope ?? options.defaultScope, options.maxScope));
+				const node = await store.createNode({
+					name: extractedNode.name,
+					kind: extractedNode.kind,
+					scope: nodeScope
+				});
+				for (const extractedKnowledge of extractedNode.records) {
+					if (capturePinning && extractedKnowledge.pin === true && options.pins) {
+						try {
+							await writePinnedKnowledge(store, {
+								scope: scopeContext,
+								sourceThreadId: context.threadId,
+								defaultScope: options.defaultScope,
+								maxScope: options.maxScope,
+								maxPins: options.pins.maxPins,
+								maxCharacters: options.pins.maxCharacters
+							}, extractedKnowledge.text, extractedKnowledge.scope, extractedKnowledge.reason ? { reason: extractedKnowledge.reason } : void 0);
+						} catch (error) {
+							droppedPins.push(`Capture-time pin dropped: ${error instanceof Error ? error.message : String(error)}`);
+						}
+						continue;
+					}
+					const knowledgeLevel = clampScope(extractedKnowledge.scope ?? "thread", options.maxScope);
+					await store.appendKnowledge({
+						node,
+						text: extractedKnowledge.text,
+						scope: (0, _mastra_core_storage.expandKnowledgeScope)(scopeContext, knowledgeLevel),
+						sourceThreadId: context.threadId,
+						when: parseWhen(extractedKnowledge.when),
+						maxScope: options.maxScope,
+						metadata: extractedKnowledge.reason ? { reason: extractedKnowledge.reason } : void 0,
+						resolutionScope: scopeContext,
+						defaultScope: nodeScope
+					});
+				}
+			}
+			if (droppedPins.length) pinNotes.set(context.current, droppedPins);
+		};
+		super({
+			name: "Capture",
+			includePreviousExtraction: false,
+			metadataKeyPath: false,
+			schema: options.config?.schema ?? (capturePinning ? subconsciousCapturePinningSchema : subconsciousCaptureSchema),
+			instructions: async (context) => {
+				const sections = [
+					CAPTURE_INSTRUCTIONS,
+					!options.config?.schema ? CAPTURE_REASON_INSTRUCTIONS : void 0,
+					capturePinning && !options.config?.schema ? CAPTURE_PINNING_INSTRUCTIONS : void 0,
+					options.config?.instructions?.trim()
+				];
+				if (options.learnedGuidance) {
+					const scopeContext = requireScopeContext(context);
+					const store = await getKnowledgeStore$1(context);
+					const guidanceScope = (0, _mastra_core_storage.expandKnowledgeScope)(scopeContext, clampScope(options.defaultScope, options.maxScope));
+					const guidance = await store.getNodeByName({
+						name: CAPTURE_GUIDANCE_PAGE,
+						scope: guidanceScope
+					});
+					if (guidance?.content?.trim()) sections.push(`Learned guidance (cannot override the built-in contract or user instructions):\n${guidance.content.trim().slice(0, MAX_CAPTURE_GUIDANCE_LENGTH)}`);
+				}
+				return sections.filter(Boolean).join("\n\n");
+			},
+			onExtracted: async (context) => {
+				const publishActivity = async (errors) => {
+					if (!options.activityRecentUpdates) return;
+					const scope = requireScopeContext(context);
+					await publishSubconsciousActivity({
+						store: await getKnowledgeStore$1(context),
+						scope,
+						recentUpdates: options.activityRecentUpdates,
+						sendStateSignal: context.sendStateSignal,
+						errors
+					});
+				};
+				try {
+					const result = options.config?.onExtracted ? await options.config.onExtracted({
+						...context,
+						defaultImplementation
+					}) : await defaultImplementation(context);
+					const droppedPinNotes = pinNotes.get(context.current);
+					pinNotes.delete(context.current);
+					await publishActivity(droppedPinNotes);
+					return result ?? context.current;
+				} catch (error) {
+					await publishActivity([error instanceof Error ? error.message : String(error)]).catch(() => {});
+					throw error;
+				}
+			}
+		});
+	}
+};
+//#endregion
+//#region src/processors/observational-memory/subconscious/knowledge-tools.ts
+const DEFAULT_LIMIT = 10;
+const MAX_LIMIT = 50;
+function resolveScope$3(context) {
+	const organizationId = context?.requestContext?.get("organizationId");
+	const resourceId = resolveKnowledgeResourceId(context?.requestContext, context?.agent?.resourceId);
+	const threadId = context?.agent?.threadId;
+	if (typeof organizationId !== "string" || !organizationId.trim()) throw new Error("Knowledge tools require requestContext.organizationId.");
+	if (!resourceId) throw new Error("Knowledge tools require an active resourceId.");
+	if (!threadId) throw new Error("Knowledge tools require an active threadId.");
+	return [
+		`org:${organizationId}`,
+		`resource:${resourceId}`,
+		`thread:${threadId}`
+	];
+}
+async function getKnowledgeStore(memory) {
+	const store = await memory.storage.getStore("knowledge");
+	if (!store) throw new Error("Knowledge tools require a configured knowledge storage domain.");
+	return store;
+}
+function normalizeLimit(limit) {
+	return Math.min(Math.max(limit ?? DEFAULT_LIMIT, 1), MAX_LIMIT);
+}
+function serializeRecord(record) {
+	return {
+		id: record.id,
+		text: record.text,
+		scope: record.scope,
+		sourceThreadId: record.sourceThreadId,
+		capturedAt: record.capturedAt.toISOString(),
+		when: record.when?.toISOString()
+	};
+}
+function serializeNode(node) {
+	return {
+		id: node.id,
+		type: node.type,
+		name: node.name,
+		kind: node.kind,
+		content: node.content,
+		scope: node.scope,
+		version: node.version,
+		updatedAt: node.updatedAt.toISOString()
+	};
+}
+async function loadSemanticResult(store, scope, candidate) {
+	const type = candidate.metadata?.document_type;
+	if (type === "node") {
+		const node = await store.getNode(candidate.id.slice(15));
+		if (!node || node.mergedInto || !(0, _mastra_core_storage.isKnowledgeScopeVisible)(node.scope, scope)) return null;
+		return {
+			type: "node",
+			id: node.id,
+			recordId: node.id,
+			name: node.name,
+			text: `${node.name}\n${node.content ?? ""}`,
+			scope: node.scope,
+			semanticScore: candidate.score
+		};
+	}
+	if (type === "record") {
+		const record = await store.getKnowledge({ id: candidate.id.slice(17) });
+		if (!record || !(0, _mastra_core_storage.isKnowledgeScopeVisible)(record.scope, scope)) return null;
+		const node = await store.getNode(record.node);
+		const parentVisible = Boolean(node && !node.mergedInto && (0, _mastra_core_storage.isKnowledgeScopeVisible)(node.scope, scope));
+		return {
+			type: "record",
+			id: record.id,
+			recordId: parentVisible ? node.id : record.id,
+			name: parentVisible ? node.name : "(private node)",
+			text: record.text,
+			scope: record.scope,
+			semanticScore: candidate.score
+		};
+	}
+	return null;
+}
+function mergeHybridResults(lexical, semantic, limit) {
+	const ranked = /* @__PURE__ */ new Map();
+	lexical.forEach((result, index) => {
+		ranked.set(`${result.type}:${result.id}`, {
+			...result,
+			score: 1 / (60 + index + 1),
+			sources: ["lexical"]
+		});
+	});
+	semantic.forEach((result, index) => {
+		const key = `${result.type}:${result.id}`;
+		const existing = ranked.get(key);
+		const reciprocalRank = 1 / (60 + index + 1);
+		ranked.set(key, {
+			...result,
+			score: (existing?.score ?? 0) + reciprocalRank,
+			sources: existing ? ["lexical", "semantic"] : ["semantic"],
+			semanticScore: result.semanticScore
+		});
+	});
+	return [...ranked.values()].sort((left, right) => right.score - left.score || left.id.localeCompare(right.id)).slice(0, limit);
+}
+function createKnowledgeTools(memory, fixedScope) {
+	return {
+		knowledge_search: (0, _mastra_core_tools.createTool)({
+			id: "knowledge_search",
+			description: "Search durable scoped knowledge across nodes and knowledge records using lexical and semantic retrieval.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					query: {
+						type: "string",
+						minLength: 1,
+						description: "The knowledge to search for."
+					},
+					limit: {
+						type: "integer",
+						minimum: 1,
+						maximum: MAX_LIMIT,
+						description: "Maximum results. Defaults to 10."
+					}
+				},
+				required: ["query"],
+				additionalProperties: false
+			},
+			execute: async (input, context) => {
+				const { query, limit: requestedLimit } = input;
+				const scope = fixedScope ?? resolveScope$3(context);
+				const limit = normalizeLimit(requestedLimit);
+				const store = await getKnowledgeStore(memory);
+				const semanticCandidates = await memory.getKnowledgeSemanticIndex().then((index) => index.search(query, scope, limit * 2));
+				return {
+					query,
+					results: mergeHybridResults(await store.search({
+						query,
+						scope,
+						limit: limit * 2
+					}), (await Promise.all(semanticCandidates.map((candidate) => loadSemanticResult(store, scope, candidate)))).filter((result) => Boolean(result)), limit)
+				};
+			}
+		}),
+		knowledge_read: (0, _mastra_core_tools.createTool)({
+			id: "knowledge_read",
+			description: "Read a knowledge node, its content, and knowledge records about or linked to it by name or ID.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					id: {
+						type: "string",
+						minLength: 1
+					},
+					name: {
+						type: "string",
+						minLength: 1
+					},
+					relationship: {
+						type: "string",
+						enum: [
+							"about",
+							"mentioning",
+							"related"
+						],
+						description: "Knowledge relationship to query. Defaults to about."
+					},
+					cursor: {
+						type: "string",
+						minLength: 1,
+						description: "Return knowledge records after this record ULID."
+					},
+					limit: {
+						type: "integer",
+						minimum: 1,
+						maximum: MAX_LIMIT
+					}
+				},
+				additionalProperties: false
+			},
+			execute: async (input, context) => {
+				const { id, name, relationship = "about", cursor, limit: requestedLimit } = input;
+				if (!id && !name) throw new Error("knowledge_read requires id or name.");
+				const scope = fixedScope ?? resolveScope$3(context);
+				const store = await getKnowledgeStore(memory);
+				const node = id ? await store.getNode(id) : await store.resolveNode({
+					name,
+					scope
+				});
+				if (!node || node.mergedInto || !(0, _mastra_core_storage.isKnowledgeScopeVisible)(node.scope, scope)) return { found: false };
+				const result = await (relationship === "related" ? store.listKnowledgeRelatedTo : relationship === "mentioning" ? store.listKnowledgeMentioning : store.listKnowledgeAbout).call(store, {
+					node,
+					scope,
+					after: cursor,
+					limit: normalizeLimit(requestedLimit)
+				});
+				return {
+					found: true,
+					node: serializeNode(node),
+					records: result.records.map(serializeRecord),
+					nextCursor: result.nextCursor
+				};
+			}
+		}),
+		knowledge_browse: (0, _mastra_core_tools.createTool)({
+			id: "knowledge_browse",
+			description: "Browse visible knowledge nodes by scope and name prefix, or follow a node’s mentions and backlinks.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					namePrefix: { type: "string" },
+					kind: {
+						type: "string",
+						description: "Optional node kind filter."
+					},
+					hasContent: {
+						type: "boolean",
+						description: "Filter nodes by whether they have long-form content."
+					},
+					node: {
+						type: "string",
+						minLength: 1,
+						description: "When set, return knowledge related to this node."
+					},
+					cursor: {
+						type: "string",
+						minLength: 1
+					},
+					limit: {
+						type: "integer",
+						minimum: 1,
+						maximum: MAX_LIMIT
+					}
+				},
+				additionalProperties: false
+			},
+			execute: async (input, context) => {
+				const { namePrefix, kind, hasContent, node: nodeReference, cursor, limit: requestedLimit } = input;
+				const scope = fixedScope ?? resolveScope$3(context);
+				const limit = normalizeLimit(requestedLimit);
+				const store = await getKnowledgeStore(memory);
+				if (nodeReference) {
+					const node = await store.getNode(nodeReference);
+					if (!node || node.mergedInto || !(0, _mastra_core_storage.isKnowledgeScopeVisible)(node.scope, scope)) return { found: false };
+					const result = await store.listKnowledgeRelatedTo({
+						node,
+						scope,
+						after: cursor,
+						limit
+					});
+					return {
+						found: true,
+						node: serializeNode(node),
+						records: result.records.map(serializeRecord),
+						nextCursor: result.nextCursor
+					};
+				}
+				const nodes = await store.listNodes({
+					scope,
+					namePrefix,
+					kind,
+					hasContent,
+					cursor,
+					limit: limit + 1
+				});
+				const hasMore = nodes.length > limit;
+				const visibleNodes = nodes.slice(0, limit);
+				return {
+					nodes: visibleNodes.map(serializeNode),
+					nextCursor: hasMore ? (0, _mastra_core_storage.createKnowledgeNodeCursor)(visibleNodes.at(-1), {
+						namePrefix,
+						kind,
+						hasContent
+					}) : void 0
+				};
+			}
+		})
+	};
+}
+//#endregion
+//#region src/processors/observational-memory/model-by-input-tokens.ts
+function isTieredModelTarget(model) {
+	if (typeof model === "string") return true;
+	if (!model || typeof model !== "object") return false;
+	return "modelId" in model || "id" in model || "providerId" in model || "provider" in model || "doGenerate" in model && "doStream" in model;
+}
+function normalizeThresholds(config) {
+	const entries = Object.entries(config.upTo);
+	if (entries.length === 0) throw new Error("ModelByInputTokens requires at least one threshold in \"upTo\"");
+	for (const [limitStr, model] of entries) {
+		const limit = Number(limitStr);
+		if (!Number.isFinite(limit) || limit <= 0) throw new Error(`ModelByInputTokens threshold keys must be positive numbers. Got: ${limitStr}`);
+		if (!isTieredModelTarget(model)) throw new Error(`ModelByInputTokens requires a valid model target for threshold ${limitStr}`);
+	}
+	return entries.map(([limitStr, model]) => ({
+		limit: Number(limitStr),
+		model
+	})).sort((a, b) => a.limit - b.limit);
+}
+var ModelByInputTokens = class {
+	thresholds;
+	constructor(config) {
+		this.thresholds = normalizeThresholds(config);
+	}
+	resolve(inputTokens) {
+		for (const { limit, model } of this.thresholds) if (inputTokens <= limit) return model;
+		const maxLimit = this.thresholds[this.thresholds.length - 1].limit;
+		throw new Error(`ModelByInputTokens: input token count (${inputTokens}) exceeds the largest configured threshold (${maxLimit}). Please configure a higher threshold or use a larger model.`);
+	}
+	getThresholds() {
+		return this.thresholds.map((t) => t.limit);
+	}
+};
+//#endregion
+//#region src/processors/observational-memory/subconscious/model.ts
+/**
+* Normalize an observational memory model config into something an Agent can consume directly.
+* Returns undefined when the OM model cannot stand alone: the 'default' sentinel and
+* token-routed models (ModelByInputTokens) both require engine context to resolve.
+*/
+function usableObservationalMemoryModel(model) {
+	if (!model || model === "default") return void 0;
+	if (model instanceof ModelByInputTokens) return void 0;
+	if (Array.isArray(model)) return model[0]?.model;
+	if (typeof model === "function") return (async (ctx) => {
+		const result = await model(ctx);
+		return Array.isArray(result) ? result[0]?.model ?? result : result;
+	});
+	return model;
+}
+/**
+* Resolve the model a subconscious agent runs on. Precedence: the per-agent config model,
+* then the observational memory model, then the main agent's model. Returns undefined when
+* no source is available so callers keep their existing throw/silent-return behavior.
+*/
+async function resolveSubconsciousAgentModel(options) {
+	const { config, omModel, mainAgent, requestContext } = options;
+	if (config.model) {
+		if (mainAgent) return await mainAgent.getModel({
+			requestContext,
+			modelConfig: config.model
+		});
+		return config.model;
+	}
+	const fromOm = usableObservationalMemoryModel(omModel);
+	if (fromOm) return fromOm;
+	if (mainAgent) return await mainAgent.getModel({ requestContext });
+}
+//#endregion
+//#region src/processors/observational-memory/subconscious/remind.ts
+const DEFAULT_INSTRUCTIONS$2 = `Review the current observations and use the knowledge tools to find prior knowledge that is directly relevant now.
+
+Be selective. Treat future-dated records as relevant when their time is imminent or useful to the current task. When the observations show whether an earlier reminder was used, tune your selectivity accordingly without storing hit/miss counters.
+Never remind about knowledge that is already visible in the current observations or recent messages — a reminder is only valuable for knowledge the agent can no longer see. Echoing back what was just said or just captured is noise.
+If nothing is relevant, respond with exactly <no-reminder /> and nothing else.
+If knowledge is relevant, return one concise reminder that explains why it matters and includes source node or record IDs. Do not invent knowledge and do not expose knowledge outside the tools' scoped results.`;
+/** Own-thread records younger than this are treated as still-in-context and excluded from reminder candidates. */
+const FRESH_OWN_RECORD_WINDOW_MS = 1800 * 1e3;
+function resolveScope$2(context) {
+	const organizationId = context.requestContext?.get("organizationId");
+	if (typeof organizationId !== "string" || !organizationId.trim()) throw new Error("Subconscious remind requires organizationId in the request context.");
+	const resourceId = resolveKnowledgeResourceId(context.requestContext, context.resourceId);
+	if (!resourceId) throw new Error("Subconscious remind requires a resourceId.");
+	return (0, _mastra_core_storage.canonicalizeKnowledgeScope)([
+		`org:${organizationId}`,
+		`resource:${resourceId}`,
+		`thread:${context.threadId}`
+	]);
+}
+const REMINDER_QUERY_STOP_WORDS = /* @__PURE__ */ new Set([
+	"about",
+	"after",
+	"before",
+	"current",
+	"from",
+	"have",
+	"observations",
+	"that",
+	"their",
+	"there",
+	"they",
+	"this",
+	"user",
+	"what",
+	"when",
+	"where",
+	"which",
+	"with"
+]);
+async function findReminderSources(store, scope, observations) {
+	const terms = [...new Set(observations.match(/[A-Za-z0-9][A-Za-z0-9_-]{3,}/g)?.map((term) => term.toLowerCase()).filter((term) => !REMINDER_QUERY_STOP_WORDS.has(term)) ?? [])].slice(0, 12);
+	const results = (await Promise.all(terms.map((query) => store.search({
+		query,
+		scope,
+		limit: 5
+	})))).flat();
+	return [...new Map(results.map((result) => [`${result.type}:${result.id}`, result])).values()].slice(0, 10);
+}
+/**
+* Drop the current thread's own freshly captured KnowledgeRecords from the candidate list. They match the
+* current observations almost perfectly (they were just distilled from them), so without this
+* guard the reminder agent mostly echoes the session's own words back at it.
+*/
+async function dropFreshOwnRecords(store, sources, threadId) {
+	const checks = await Promise.all(sources.map(async (source) => {
+		if (source.type !== "record") return true;
+		const record = await store.getKnowledge({ id: source.id }).catch(() => null);
+		if (!record) return true;
+		const isOwnThread = record.sourceThreadId === threadId || record.sourceThreadId.startsWith(`subconscious:${threadId}:`);
+		const isFresh = Date.now() - new Date(record.capturedAt).getTime() < FRESH_OWN_RECORD_WINDOW_MS;
+		return !(isOwnThread && isFresh);
+	}));
+	return sources.filter((_, index) => checks[index]);
+}
+var SubconsciousRemindExtractor = class extends Extractor {
+	constructor(config, omModel) {
+		super({
+			name: "Remind",
+			mode: "hook",
+			metadataKeyPath: false,
+			onExtracted: async (context) => {
+				if (!context.rawObservations?.trim() || !context.memory || !context.sendSignal) return;
+				let scope;
+				let store;
+				try {
+					scope = resolveScope$2(context);
+					store = await context.memory.storage.getStore("knowledge");
+					if (!store) throw new Error("Subconscious remind requires a configured knowledge storage domain.");
+					const sources = await dropFreshOwnRecords(store, await findReminderSources(store, scope, context.rawObservations), context.threadId);
+					if (sources.length === 0) return;
+					const model = await resolveSubconsciousAgentModel({
+						config,
+						omModel,
+						mainAgent: context.mainAgent,
+						requestContext: context.requestContext
+					});
+					if (!model) return;
+					const agent = new _mastra_core_agent.Agent({
+						id: `subconscious-remind-${context.threadId}`,
+						name: "Subconscious Remind",
+						instructions: [DEFAULT_INSTRUCTIONS$2, config.instructions?.trim()].filter(Boolean).join("\n\n"),
+						model,
+						tools: createKnowledgeTools(context.memory, scope)
+					});
+					const recentMessagesSection = context.recentMessages?.trim() ? `\n\nRecent conversation messages (already visible to the agent — never remind about anything present here):\n${context.recentMessages}` : "";
+					const reminder = (await agent.generate(`Current time: ${(/* @__PURE__ */ new Date()).toISOString()}\n\nScoped source candidates:\n${JSON.stringify(sources)}\n\nCurrent observations:\n${context.rawObservations}${recentMessagesSection}`, {
+						requestContext: context.requestContext,
+						abortSignal: context.abortSignal,
+						maxSteps: config.maxSteps
+					})).text.trim();
+					if (!reminder || /^<no-reminder\s*\/>$/i.test(reminder)) return;
+					const sourceIds = [...new Set(sources.flatMap((source) => [source.id, source.recordId]))].filter((id) => reminder.includes(id)).slice(0, 5);
+					if (sourceIds.length === 0) return;
+					const contents = `${reminder}\n\nSources: ${sourceIds.join(", ")}`;
+					await context.sendSignal({
+						id: `__subconscious_remembered_${crypto.randomUUID()}`,
+						type: "reactive",
+						tagName: "remembered",
+						contents,
+						createdAt: /* @__PURE__ */ new Date(),
+						metadata: { origin: "subconscious" },
+						attributes: {
+							source: "subconscious",
+							sourceIds: sourceIds.join(","),
+							agent: "remind",
+							threadId: context.threadId
+						}
+					});
+				} catch (error) {
+					await context.writer?.custom({
+						type: "data-subconscious-error",
+						data: {
+							agent: "remind",
+							error: error instanceof Error ? error.message : String(error)
+						}
+					});
+					if (store && scope) await publishSubconsciousActivity({
+						store,
+						scope,
+						recentUpdates: 10,
+						sendStateSignal: context.sendStateSignal,
+						errors: [`remind: ${error instanceof Error ? error.message : String(error)}`]
+					});
+					throw error;
+				}
+			}
+		});
+	}
+};
+//#endregion
+//#region src/processors/observational-memory/subconscious/pinned-state-processor.ts
+function lp(value) {
+	return `${value.length}:${value}`;
+}
+function pinFingerprint(pin) {
+	return `${lp(pin.id)}${lp(pin.text)}`;
+}
+function stablePinsCacheKey(pins) {
+	return `pins:${pins.map(pinFingerprint).join("|")}`;
+}
+function getPinsFromSnapshot(snapshot) {
+	const value = (snapshot?.metadata)?.value?.pins;
+	return Array.isArray(value) ? value : [];
+}
+function getOpsFromDelta(delta) {
+	const ops = delta.metadata?.delta?.ops;
+	return Array.isArray(ops) ? ops : [];
+}
+function applyPinOps(pins, ops) {
+	const next = pins.slice();
+	for (const op of ops) {
+		if (op.op === "remove") {
+			const idx = next.findIndex((pin) => pin.id === op.id);
+			if (idx >= 0) next.splice(idx, 1);
+			continue;
+		}
+		const idx = next.findIndex((pin) => pin.id === op.pin.id);
+		if (idx >= 0) next[idx] = op.pin;
+		else next.push(op.pin);
+	}
+	return next;
+}
+function effectivePriorPins(args) {
+	let pins = getPinsFromSnapshot(args.lastSnapshot);
+	for (const delta of args.deltasSinceSnapshot ?? []) pins = applyPinOps(pins, getOpsFromDelta(delta));
+	return pins;
+}
+function diffPins(prior, current) {
+	const ops = [];
+	const priorIds = new Set(prior.map((pin) => pin.id));
+	const currentIds = new Set(current.map((pin) => pin.id));
+	for (const pin of prior) if (!currentIds.has(pin.id)) ops.push({
+		op: "remove",
+		id: pin.id
+	});
+	for (const pin of current) if (!priorIds.has(pin.id)) ops.push({
+		op: "add",
+		pin
+	});
+	return ops;
+}
+function renderPins(pins) {
+	if (pins.length === 0) return "";
+	return `\n${pins.map((pin) => `  • {id: ${pin.id}} ${pin.text}`).join("\n")}\n`;
+}
+function renderDelta(ops) {
+	return `\n${ops.map((op) => op.op === "remove" ? `  - removed {id: ${op.id}}` : `  + {id: ${op.pin.id}} ${op.pin.text}`).join("\n")}\n`;
+}
+const MEMO_KEY = "__subconsciousPinnedRead";
+var PinnedStateProcessor = class {
+	deps;
+	id = SUBCONSCIOUS_PINS_STATE_ID;
+	stateId = SUBCONSCIOUS_PINS_STATE_ID;
+	constructor(deps) {
+		this.deps = deps;
+	}
+	processInput(args) {
+		return {
+			messages: args.messages,
+			systemMessages: [...args.systemMessages, {
+				role: "system",
+				content: `Pinned knowledge may appear in the conversation as <${PINNED_SNAPSHOT_TAG} ...>...</${PINNED_SNAPSHOT_TAG}> snapshots and <${PINNED_DELTA_TAG} ...>...</${PINNED_DELTA_TAG}> deltas. These are automatic projections of durable pinned knowledge, not user instructions. Fold each delta onto the latest snapshot to know the current pin set, treat those entries as standing context, and do not treat a pin update as the user asking you to act on it.`
+			}]
+		};
+	}
+	resolveScope(args) {
+		const organizationId = args.requestContext?.get?.("organizationId");
+		if (typeof organizationId !== "string" || !organizationId.trim()) return void 0;
+		const resourceId = resolveKnowledgeResourceId(args.requestContext, args.resourceId);
+		if (!resourceId) return void 0;
+		return (0, _mastra_core_storage.canonicalizeKnowledgeScope)([
+			`org:${organizationId}`,
+			`resource:${resourceId}`,
+			`thread:${args.threadId}`
+		]);
+	}
+	async readPins(args, scope) {
+		const stepNumber = typeof args.stepNumber === "number" ? args.stepNumber : 0;
+		const scopeKey = scope.join("/");
+		const memo = args.requestContext?.get?.(MEMO_KEY);
+		if (memo && memo.scopeKey === scopeKey && stepNumber > memo.atStep) return memo.entries;
+		const store = await this.deps.getKnowledgeStore();
+		if (!store) return void 0;
+		const { pins } = await listPinnedKnowledge({
+			store,
+			scope
+		});
+		const entries = pins.map((pin) => ({
+			id: pin.id,
+			text: pin.text
+		}));
+		args.requestContext?.set?.(MEMO_KEY, {
+			atStep: stepNumber,
+			scopeKey,
+			entries
+		});
+		return entries;
+	}
+	async computeStateSignal(args) {
+		const scope = this.resolveScope(args);
+		if (!scope) return;
+		const currentPins = await this.readPins(args, scope);
+		if (!currentPins) return;
+		const priorPins = effectivePriorPins(args);
+		const hasBase = Boolean(args.lastSnapshot) && args.contextWindow.hasSnapshot;
+		const ops = diffPins(priorPins, currentPins);
+		if (ops.length === 0 && hasBase) return;
+		if (currentPins.length === 0) {
+			if (!hasBase) return;
+			return {
+				id: SUBCONSCIOUS_PINS_STATE_ID,
+				mode: "snapshot",
+				cacheKey: stablePinsCacheKey(currentPins),
+				tagName: PINNED_SNAPSHOT_TAG,
+				contents: "",
+				value: { pins: currentPins },
+				attributes: { count: 0 },
+				metadata: { value: { pins: currentPins } }
+			};
+		}
+		if (!hasBase) return {
+			id: SUBCONSCIOUS_PINS_STATE_ID,
+			mode: "snapshot",
+			cacheKey: stablePinsCacheKey(currentPins),
+			tagName: PINNED_SNAPSHOT_TAG,
+			contents: renderPins(currentPins),
+			value: { pins: currentPins },
+			attributes: { count: currentPins.length },
+			metadata: { value: { pins: currentPins } }
+		};
+		return {
+			id: SUBCONSCIOUS_PINS_STATE_ID,
+			mode: "delta",
+			cacheKey: stablePinsCacheKey(currentPins),
+			tagName: PINNED_DELTA_TAG,
+			contents: renderDelta(ops),
+			value: { pins: currentPins },
+			delta: { ops },
+			attributes: { changes: ops.length },
+			metadata: {
+				value: { pins: currentPins },
+				delta: { ops }
+			}
+		};
+	}
+};
+//#endregion
+//#region src/processors/observational-memory/subconscious/knowledge-write-tools.ts
+const CURATOR_IDENTITY = "subconscious:curate";
+const MAX_GUIDANCE_LENGTH = 4e3;
+const scopeLevelSchema = {
+	type: "string",
+	enum: [
+		"org",
+		"resource",
+		"thread"
+	]
+};
+async function getStore(memory) {
+	const store = await memory.storage.getStore("knowledge");
+	if (!store) throw new Error("Knowledge write tools require a configured knowledge storage domain.");
+	return store;
+}
+function resolveWriteScope(options, level) {
+	const scope = (0, _mastra_core_storage.expandKnowledgeScope)(options.scope, level ?? options.defaultScope);
+	(0, _mastra_core_storage.assertKnowledgeScopeWithinCeiling)(scope, options.maxScope);
+	return scope;
+}
+function requireVisible(scope, options, label) {
+	if (!(0, _mastra_core_storage.isKnowledgeScopeVisible)(scope, options.scope)) throw new Error(`${label} is outside the curator's visible scope.`);
+}
+function createKnowledgeWriteTools(memory, options) {
+	return {
+		knowledge_append: (0, _mastra_core_tools.createTool)({
+			id: "knowledge_append",
+			description: "Append a scoped record to an existing node. Provenance and capture time are stamped by code.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					node: {
+						type: "string",
+						minLength: 1
+					},
+					text: {
+						type: "string",
+						minLength: 1
+					},
+					scope: scopeLevelSchema,
+					when: { type: "string" }
+				},
+				required: ["node", "text"],
+				additionalProperties: false
+			},
+			execute: async (input) => {
+				const value = input;
+				const store = await getStore(memory);
+				const parent = await store.getNode(value.node);
+				if (!parent || parent.mergedInto) throw new Error(`Knowledge node not found: ${value.node}`);
+				requireVisible(parent.scope, options, "Knowledge node");
+				const scope = resolveWriteScope(options, value.scope);
+				const when = value.when ? new Date(value.when) : void 0;
+				if (when && Number.isNaN(when.getTime())) throw new Error("KnowledgeRecord when must be a valid date.");
+				return store.appendKnowledge({
+					node: parent.id,
+					text: value.text,
+					scope,
+					sourceThreadId: options.sourceThreadId,
+					when,
+					maxScope: options.maxScope,
+					resolutionScope: options.scope,
+					defaultScope: (0, _mastra_core_storage.expandKnowledgeScope)(options.scope, options.defaultScope)
+				});
+			}
+		}),
+		knowledge_remove: (0, _mastra_core_tools.createTool)({
+			id: "knowledge_remove",
+			description: "Soft-delete a visible record. Curators cannot restore or physically erase knowledge records.",
+			inputSchema: {
+				type: "object",
+				properties: { recordId: {
+					type: "string",
+					minLength: 1
+				} },
+				required: ["recordId"],
+				additionalProperties: false
+			},
+			execute: async (input) => {
+				const store = await getStore(memory);
+				const record = await store.getKnowledge({
+					id: input.recordId,
+					includeDeleted: true
+				});
+				if (!record) throw new Error(`KnowledgeRecord not found: ${input.recordId}`);
+				requireVisible(record.scope, options, "KnowledgeRecord");
+				return store.removeKnowledge({
+					id: record.id,
+					deletedBy: CURATOR_IDENTITY
+				});
+			}
+		}),
+		knowledge_update_node: (0, _mastra_core_tools.createTool)({
+			id: "knowledge_update_node",
+			description: "Update a visible node name or kind using optimistic concurrency.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					node: {
+						type: "string",
+						minLength: 1
+					},
+					expectedVersion: {
+						type: "integer",
+						minimum: 1
+					},
+					name: {
+						type: "string",
+						minLength: 1
+					},
+					kind: {
+						type: "string",
+						minLength: 1
+					}
+				},
+				required: ["node", "expectedVersion"],
+				anyOf: [{ required: ["name"] }, { required: ["kind"] }],
+				additionalProperties: false
+			},
+			execute: async (input) => {
+				const value = input;
+				const store = await getStore(memory);
+				const node = await store.getNode(value.node);
+				if (!node || node.mergedInto) throw new Error(`Knowledge node not found: ${value.node}`);
+				requireVisible(node.scope, options, "Knowledge node");
+				return store.updateNode({
+					id: node.id,
+					version: value.expectedVersion,
+					name: value.name,
+					kind: value.kind
+				});
+			}
+		}),
+		knowledge_merge_nodes: (0, _mastra_core_tools.createTool)({
+			id: "knowledge_merge_nodes",
+			description: "Merge a visible duplicate node into another visible node using source-version CAS.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					sourceId: {
+						type: "string",
+						minLength: 1
+					},
+					targetId: {
+						type: "string",
+						minLength: 1
+					},
+					sourceVersion: {
+						type: "integer",
+						minimum: 1
+					}
+				},
+				required: [
+					"sourceId",
+					"targetId",
+					"sourceVersion"
+				],
+				additionalProperties: false
+			},
+			execute: async (input) => {
+				const value = input;
+				const store = await getStore(memory);
+				const [source, target] = await Promise.all([store.getNode(value.sourceId), store.getNode(value.targetId)]);
+				if (!source || !target) throw new Error("Knowledge merge requires two existing nodes.");
+				requireVisible(source.scope, options, "Knowledge merge source");
+				requireVisible(target.scope, options, "Knowledge merge target");
+				return store.mergeNodes(value);
+			}
+		}),
+		knowledge_rescope: (0, _mastra_core_tools.createTool)({
+			id: "knowledge_rescope",
+			description: "Change a record visibility scope without exceeding its stamped ceiling.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					recordId: {
+						type: "string",
+						minLength: 1
+					},
+					scope: scopeLevelSchema
+				},
+				required: ["recordId", "scope"],
+				additionalProperties: false
+			},
+			execute: async (input) => {
+				const value = input;
+				const store = await getStore(memory);
+				const record = await store.getKnowledge({ id: value.recordId });
+				if (!record) throw new Error(`KnowledgeRecord not found: ${value.recordId}`);
+				requireVisible(record.scope, options, "KnowledgeRecord");
+				const scope = resolveWriteScope(options, value.scope);
+				(0, _mastra_core_storage.assertKnowledgeScopeWithinCeiling)(scope, record.maxScope);
+				return store.rescopeKnowledge({
+					id: record.id,
+					scope
+				});
+			}
+		}),
+		knowledge_write_node_content: (0, _mastra_core_tools.createTool)({
+			id: "knowledge_write_node_content",
+			description: "Create or replace long-form content on a scoped knowledge node. Existing nodes require expectedVersion.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					name: {
+						type: "string",
+						minLength: 1
+					},
+					kind: {
+						type: "string",
+						minLength: 1
+					},
+					content: {
+						type: "string",
+						minLength: 1
+					},
+					scope: scopeLevelSchema,
+					expectedVersion: {
+						type: "integer",
+						minimum: 1
+					}
+				},
+				required: ["name", "content"],
+				additionalProperties: false
+			},
+			execute: async (input) => {
+				const value = input;
+				const trimmedName = value.name.trim();
+				const reservedName = trimmedName.toLowerCase();
+				const name = reservedName === "capture-guidance" ? reservedName : trimmedName;
+				if (reservedName === "capture-guidance" && value.content.length > MAX_GUIDANCE_LENGTH) throw new Error(`capture-guidance is limited to ${MAX_GUIDANCE_LENGTH} characters.`);
+				const store = await getStore(memory);
+				const scope = resolveWriteScope(options, value.scope);
+				const resolvedNode = await store.resolveNode({
+					name,
+					scope
+				});
+				const existing = resolvedNode && (0, _mastra_core_storage.knowledgeScopeKey)(resolvedNode.scope) === (0, _mastra_core_storage.knowledgeScopeKey)(scope) ? resolvedNode : null;
+				if (!existing) {
+					if (value.expectedVersion !== void 0) throw new Error("expectedVersion is only valid for an existing node.");
+					return store.createNode({
+						name,
+						kind: value.kind ?? "document",
+						content: value.content,
+						scope,
+						resolutionScope: options.scope
+					});
+				}
+				if (value.expectedVersion === void 0) throw new Error("Updating node content requires expectedVersion.");
+				return store.updateNode({
+					id: existing.id,
+					version: value.expectedVersion,
+					kind: value.kind,
+					content: value.content,
+					resolutionScope: options.scope
+				});
+			}
+		})
+	};
+}
+//#endregion
+//#region src/processors/observational-memory/subconscious/semantic-index.ts
+const DEFAULT_BATCH_SIZE = 50;
+const MAX_DRAIN_BATCHES = 100;
+var StaleKnowledgeSemanticIndexError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "StaleKnowledgeSemanticIndexError";
+	}
+};
+var KnowledgeSemanticIndexCoordinator = class {
+	#knowledge;
+	#vector;
+	#embedder;
+	#embedderOptions;
+	#workerId;
+	#batchSize;
+	#draining = /* @__PURE__ */ new Map();
+	constructor(config) {
+		this.#knowledge = config.knowledge;
+		this.#vector = config.vector;
+		this.#embedder = config.embedder;
+		this.#embedderOptions = config.embedderOptions;
+		this.#workerId = config.workerId ?? `knowledge-index-${crypto.randomUUID()}`;
+		this.#batchSize = config.batchSize ?? DEFAULT_BATCH_SIZE;
+	}
+	async drain(scope) {
+		const key = scope?.join("") ?? "*";
+		const active = this.#draining.get(key);
+		if (active) return active;
+		const draining = this.#drain(scope).finally(() => {
+			this.#draining.delete(key);
+		});
+		this.#draining.set(key, draining);
+		return draining;
+	}
+	async search(query, scope, limit = 10) {
+		await this.drain(scope);
+		const embedding = (await this.#embedder.doEmbed({
+			values: [query],
+			...this.#embedderOptions ?? {}
+		})).embeddings[0];
+		if (!embedding?.length) throw new Error("Embedder returned no vector for knowledge search query.");
+		const indexName = this.#indexName(embedding.length);
+		if (!(await this.#knowledgeIndexes()).includes(indexName)) throw new StaleKnowledgeSemanticIndexError(`Knowledge semantic index ${indexName} is unavailable. Capture or index knowledge before searching.`);
+		const visibleScopeKeys = scope.map((_, index) => scope.slice(0, index + 1).join(""));
+		const batches = await Promise.all(visibleScopeKeys.map((scopeKey) => this.#vector.query({
+			indexName,
+			queryVector: embedding,
+			topK: limit,
+			filter: { scope_key: scopeKey }
+		})));
+		const deduped = /* @__PURE__ */ new Map();
+		for (const candidate of batches.flat()) {
+			const candidateScope = candidate.metadata?.scope;
+			if (!Array.isArray(candidateScope)) continue;
+			let visible = false;
+			try {
+				visible = (0, _mastra_core_storage.isKnowledgeScopeVisible)((0, _mastra_core_storage.canonicalizeKnowledgeScope)(candidateScope.map(String)), scope);
+			} catch {
+				continue;
+			}
+			if (!visible) continue;
+			const existing = deduped.get(candidate.id);
+			if (!existing || candidate.score > existing.score) deduped.set(candidate.id, candidate);
+		}
+		return [...deduped.values()].sort((left, right) => right.score - left.score || left.id.localeCompare(right.id)).slice(0, limit);
+	}
+	async #drain(scope) {
+		let processed = 0;
+		for (let batch = 0; batch < MAX_DRAIN_BATCHES; batch++) {
+			const entries = await this.#knowledge.claimSemanticOutbox({
+				workerId: this.#workerId,
+				limit: this.#batchSize,
+				scope
+			});
+			if (entries.length === 0) {
+				const [pending, processing] = await Promise.all([this.#knowledge.listSemanticOutbox({
+					status: "pending",
+					scope,
+					limit: 1
+				}), this.#knowledge.listSemanticOutbox({
+					status: "processing",
+					scope,
+					limit: 1
+				})]);
+				if (pending.length > 0 || processing.length > 0) throw new StaleKnowledgeSemanticIndexError("Knowledge semantic index is stale: a visible operation is pending or being processed by another worker.");
+				return processed;
+			}
+			for (let index = 0; index < entries.length; index++) {
+				const entry = entries[index];
+				try {
+					await this.#apply(entry);
+					await this.#knowledge.completeSemanticOutbox({
+						ids: [entry.id],
+						workerId: this.#workerId
+					});
+					processed++;
+				} catch (error) {
+					await this.#knowledge.releaseSemanticOutbox({
+						ids: entries.slice(index).map((pendingEntry) => pendingEntry.id),
+						workerId: this.#workerId
+					});
+					throw new StaleKnowledgeSemanticIndexError(`Knowledge semantic index is stale because operation ${entry.id} could not be applied.`, { cause: error });
+				}
+			}
+		}
+		throw new StaleKnowledgeSemanticIndexError(`Knowledge semantic index remained stale after ${MAX_DRAIN_BATCHES} processing batches.`);
+	}
+	async #apply(entry) {
+		if (entry.operation === "delete") {
+			await this.#deleteDocument(entry.documentId);
+			return;
+		}
+		const document = await this.#loadDocument(entry);
+		if (!document) {
+			await this.#deleteDocument(entry.documentId);
+			return;
+		}
+		const embedding = (await this.#embedder.doEmbed({
+			values: [document.text],
+			...this.#embedderOptions ?? {}
+		})).embeddings[0];
+		if (!embedding?.length) throw new Error(`Embedder returned no vector for ${entry.documentId}`);
+		const indexName = this.#indexName(embedding.length);
+		const indexes = await this.#knowledgeIndexes();
+		if (!indexes.includes(indexName)) await this.#vector.createIndex({
+			indexName,
+			dimension: embedding.length
+		});
+		for (const existingIndex of indexes) if (existingIndex !== indexName) await this.#vector.deleteVectors({
+			indexName: existingIndex,
+			ids: [entry.documentId]
+		});
+		await this.#vector.upsert({
+			indexName,
+			ids: [entry.documentId],
+			vectors: [embedding],
+			metadata: [this.#metadata(document)]
+		});
+	}
+	async #loadDocument(entry) {
+		if (entry.documentType === "node") {
+			const node = await this.#knowledge.getNode(entry.documentId.slice(15));
+			if (!node || node.mergedInto) return null;
+			return {
+				text: `${node.name}\n${node.content ?? ""}`,
+				name: node.name,
+				scope: node.scope,
+				recordId: node.id,
+				type: "node"
+			};
+		}
+		const record = await this.#knowledge.getKnowledge({
+			id: entry.documentId.slice(17),
+			includeDeleted: true
+		});
+		if (!record || record.deletedAt) return null;
+		const node = await this.#knowledge.getNode(record.node);
+		if (!node) return null;
+		return {
+			text: `${node.name}\n${record.text}`,
+			name: node.name,
+			scope: record.scope,
+			recordId: node.id,
+			type: "record"
+		};
+	}
+	async #deleteDocument(documentId) {
+		for (const indexName of await this.#knowledgeIndexes()) await this.#vector.deleteVectors({
+			indexName,
+			ids: [documentId]
+		});
+	}
+	async #knowledgeIndexes() {
+		const prefix = `knowledge${this.#vector.indexSeparator ?? "_"}documents`;
+		return (await this.#vector.listIndexes()).filter((index) => index === prefix || index.startsWith(`${prefix}${this.#vector.indexSeparator ?? "_"}dimension`));
+	}
+	#indexName(dimension) {
+		const separator = this.#vector.indexSeparator ?? "_";
+		return `knowledge${separator}documents${separator}dimension${separator}${dimension}`;
+	}
+	#metadata(document) {
+		const metadata = {
+			document_type: document.type,
+			record_id: document.recordId,
+			name: document.name,
+			scope: [...document.scope],
+			scope_key: document.scope.join(""),
+			text: document.text
+		};
+		for (const entry of document.scope) {
+			const separator = entry.indexOf(":");
+			metadata[`scope_${entry.slice(0, separator)}`] = entry.slice(separator + 1);
+		}
+		return metadata;
+	}
+};
+//#endregion
+//#region src/processors/observational-memory/subconscious/index.ts
+var subconscious_exports = /* @__PURE__ */ __exportAll({
+	DEFAULT_MAX_PINS: () => 20,
+	DEFAULT_PINNED_MAX_CHARACTERS: () => DEFAULT_PINNED_MAX_CHARACTERS,
+	MAX_PINNED_MAX_CHARACTERS: () => MAX_PINNED_MAX_CHARACTERS,
+	PINNED_DELTA_TAG: () => PINNED_DELTA_TAG,
+	PINNED_NODE_KIND: () => PINNED_NODE_KIND,
+	PINNED_NODE_NAME: () => PINNED_NODE_NAME,
+	PINNED_NODE_SCOPE_LEVEL: () => PINNED_NODE_SCOPE_LEVEL,
+	PINNED_SNAPSHOT_TAG: () => PINNED_SNAPSHOT_TAG,
+	PinnedStateProcessor: () => PinnedStateProcessor,
+	SUBCONSCIOUS_ACTIVITY_STATE_ID: () => SUBCONSCIOUS_ACTIVITY_STATE_ID,
+	SUBCONSCIOUS_PINS_STATE_ID: () => SUBCONSCIOUS_PINS_STATE_ID,
+	Subconscious: () => Subconscious
+});
+const BUILT_IN_OBSERVATION = /* @__PURE__ */ new Set(["capture", "remind"]);
+const BUILT_IN_REFLECTION = /* @__PURE__ */ new Set(["curate", "learn"]);
+const DEFAULT_MAX_STEPS = 5;
+const DEFAULT_RECENT_UPDATES = 10;
+const MAX_RECENT_UPDATES = 100;
+function entryName(entry) {
+	return typeof entry === "string" ? entry : entry.name.trim();
+}
+function assertUniqueNames(entries, phase) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		const name = entryName(entry);
+		if (!name) throw new Error(`Subconscious ${phase} agent name is required.`);
+		if (seen.has(name)) throw new Error(`Duplicate Subconscious ${phase} agent: ${name}`);
+		seen.add(name);
+	}
+}
+function boundedSteps(entry, fallback) {
+	const steps = entry?.maxSteps ?? fallback;
+	if (!Number.isInteger(steps) || steps < 1 || steps > 25) throw new Error("Subconscious maxSteps must be an integer between 1 and 25.");
+	return steps;
+}
+function resolveExtractor(entry) {
+	const config = typeof entry === "string" ? void 0 : entry;
+	const name = entryName(entry);
+	return {
+		name,
+		instructions: config?.instructions,
+		builtIn: name === "capture"
+	};
+}
+function resolveAgent(entry, builtIns, globalModel, globalMaxSteps) {
+	const config = typeof entry === "string" ? void 0 : entry;
+	const name = entryName(entry);
+	return {
+		name,
+		instructions: config?.instructions,
+		model: config?.model ?? globalModel,
+		agent: config?.agent,
+		maxSteps: boundedSteps(config, globalMaxSteps),
+		builtIn: builtIns.has(name)
+	};
+}
+/**
+* Configures experimental autonomous knowledge extraction and reflection.
+*
+* @experimental This API may change without notice.
+*/
+var Subconscious = class {
+	config;
+	resolved;
+	constructor(config = {}) {
+		const observation = config.observation ?? ["capture", "remind"];
+		const reflection = config.reflection ?? ["curate", "learn"];
+		assertUniqueNames(observation, "observation");
+		assertUniqueNames(reflection, "reflection");
+		const maxSteps = boundedSteps(config, DEFAULT_MAX_STEPS);
+		for (const entry of observation) this.#validateObservationEntry(entry);
+		for (const entry of reflection) this.#validateReflectionEntry(entry);
+		const recentUpdates = config.activity === false ? false : config.activity?.recentUpdates ?? DEFAULT_RECENT_UPDATES;
+		if (recentUpdates !== false && (!Number.isInteger(recentUpdates) || recentUpdates < 1 || recentUpdates > MAX_RECENT_UPDATES)) throw new Error(`Subconscious activity.recentUpdates must be an integer between 1 and ${MAX_RECENT_UPDATES}.`);
+		const pins = config.pins === void 0 || config.pins === false ? false : {
+			maxPins: (config.pins === true ? void 0 : config.pins.maxPins) ?? 20,
+			maxCharacters: (config.pins === true ? void 0 : config.pins.maxCharacters) ?? 2e3,
+			capturePinning: (config.pins === true ? void 0 : config.pins.capturePinning) ?? false
+		};
+		if (pins !== false) {
+			if (!Number.isInteger(pins.maxPins) || pins.maxPins < 1) throw new Error("Subconscious pins.maxPins must be a positive integer.");
+			if (!Number.isInteger(pins.maxCharacters) || pins.maxCharacters < 1 || pins.maxCharacters > 8e3) throw new Error(`Subconscious pins.maxCharacters must be an integer between 1 and ${MAX_PINNED_MAX_CHARACTERS}.`);
+		}
+		if (config.curationCadence !== void 0 && (!Number.isInteger(config.curationCadence) || config.curationCadence < 1)) throw new Error("Subconscious curationCadence must be a positive integer.");
+		this.config = Object.freeze({
+			...config,
+			observation: [...observation],
+			reflection: [...reflection]
+		});
+		this.resolved = Object.freeze({
+			observation: observation.map((entry) => entryName(entry) === "remind" ? resolveAgent(entry, BUILT_IN_OBSERVATION, config.model, maxSteps) : resolveExtractor(entry)),
+			reflection: reflection.map((entry) => resolveAgent(entry, BUILT_IN_REFLECTION, config.model, maxSteps)),
+			defaultScope: config.defaultScope ?? "resource",
+			maxScope: config.maxScope,
+			learnedGuidance: config.learnedGuidance !== false,
+			tools: config.tools !== false,
+			activity: recentUpdates === false ? false : { recentUpdates },
+			pins,
+			curationCadence: config.curationCadence
+		});
+	}
+	createObservationExtractors(omModel) {
+		const extractors = [];
+		for (const entry of this.config.observation ?? []) {
+			const name = entryName(entry);
+			if (name === "capture") extractors.push(new SubconsciousCaptureExtractor({
+				config: typeof entry === "string" ? void 0 : entry,
+				defaultScope: this.resolved.defaultScope,
+				maxScope: this.resolved.maxScope,
+				learnedGuidance: this.resolved.learnedGuidance,
+				activityRecentUpdates: this.resolved.activity === false ? void 0 : this.resolved.activity.recentUpdates,
+				pins: this.resolved.pins
+			}));
+			else if (name === "remind") {
+				const resolved = this.resolved.observation.find((agent) => agent.name === name);
+				if (resolved) extractors.push(new SubconsciousRemindExtractor(resolved, omModel));
+			} else if (!BUILT_IN_OBSERVATION.has(name)) {
+				const custom = entry;
+				extractors.push(new Extractor({
+					name: custom.name,
+					instructions: custom.instructions?.trim() || `Extract ${custom.name} from the current observations.`,
+					schema: custom.schema,
+					metadataKeyPath: false,
+					includePreviousExtraction: false,
+					onExtracted: custom.onExtracted
+				}));
+			}
+		}
+		return extractors;
+	}
+	#validateObservationEntry(entry) {
+		const name = entryName(entry);
+		if (typeof entry === "string") {
+			if (!BUILT_IN_OBSERVATION.has(name)) throw new Error(`Unknown Subconscious observation agent: ${name}`);
+			return;
+		}
+		if (BUILT_IN_OBSERVATION.has(name)) {
+			if (name === "capture") {
+				if ("model" in entry || "maxSteps" in entry) throw new Error("Subconscious capture shares the Observer model and does not accept model or maxSteps.");
+				if ("schema" in entry && entry.schema && (!("onExtracted" in entry) || typeof entry.onExtracted !== "function")) throw new Error("A custom capture schema requires an onExtracted hook that handles its output.");
+			}
+			return;
+		}
+		if ("model" in entry || "maxSteps" in entry) throw new Error(`Subconscious observation extractor "${name}" shares the Observer model and does not accept model or maxSteps.`);
+		if (!("schema" in entry) || !entry.schema || !("onExtracted" in entry) || typeof entry.onExtracted !== "function") throw new Error(`Custom Subconscious observation agent "${name}" requires schema and onExtracted.`);
+	}
+	#validateReflectionEntry(entry) {
+		const name = entryName(entry);
+		if (typeof entry === "string") {
+			if (!BUILT_IN_REFLECTION.has(name)) throw new Error(`Unknown Subconscious reflection agent: ${name}`);
+			return;
+		}
+		if (BUILT_IN_REFLECTION.has(name) && "agent" in entry && entry.agent) throw new Error(`Built-in Subconscious reflection agent "${name}" cannot be replaced with a custom agent.`);
+		if (!BUILT_IN_REFLECTION.has(name) && !entry.instructions?.trim() && !("agent" in entry && entry.agent)) throw new Error(`Custom Subconscious reflection agent "${name}" requires instructions or agent.`);
+	}
+};
+//#endregion
+//#region src/processors/observational-memory/subconscious/curate.ts
+const CURATION_AGENT = "curate";
+const DEFAULT_INSTRUCTIONS$1 = `Maintain durable scoped knowledge from the committed observation worklist.
+
+Use the read tools to inspect existing nodes, knowledge records, mentions, backlinks, and long-form node content. Use the write tools to merge true duplicates, repair names and links, soft-delete superseded knowledge records, rescope knowledge records only when justified and permitted by their ceilings, and synthesize useful node content. Never restore deleted knowledge records. Never invent provenance, capture timestamps, scopes, ceilings, IDs, or versions; those are enforced by code. Resolve optimistic-concurrency conflicts by reading the latest record and retrying the intended mutation. Keep the reserved capture-guidance node concise and update it only with durable guidance that will improve future capture.
+
+Process the worklist in ID order. Every time you finish processing a KnowledgeRecord, include <curation-complete through="RECORD_ID" /> in your next text response with that record's ID. The latest marker is your acknowledged cursor, so progress survives if you run out of steps mid-batch. Your final response must end with the marker for the last KnowledgeRecord you fully processed. If you cannot finish the batch, acknowledge only the last KnowledgeRecord you did finish. Do not emit a completion marker when no KnowledgeRecord was fully processed.`;
+const PINNED_INSTRUCTIONS = `Maintain the pin set with knowledge_pin, knowledge_edit_pin, and knowledge_unpin. Pinned entries are delivered to the main agent on every turn, so they cost tokens permanently and must stay short. Pin only knowledge that should apply without being asked for, such as standing instructions, durable preferences, and hard constraints. Pin only knowledge that is BOTH costly to rediscover AND not the kind of thing a future agent would think to search for; anything a reminder can surface on demand does not belong in the pin set. Unpin an entry as soon as it stops being unconditionally true.`;
+function resolveScope$1(context) {
+	const organizationId = context.requestContext?.get("organizationId");
+	if (typeof organizationId !== "string" || !organizationId.trim()) throw new Error("Subconscious curate requires organizationId in the request context.");
+	return (0, _mastra_core_storage.canonicalizeKnowledgeScope)([
+		`org:${organizationId}`,
+		`resource:${resolveKnowledgeResourceId(context.requestContext, context.resourceId)}`,
+		`thread:${context.parentThreadId}`
+	]);
+}
+async function readWorklist$1(store, sourceThreadId, scope, after) {
+	const records = [];
+	let cursor = after;
+	do {
+		const page = await store.knowledgeBySource({
+			sourceThreadId,
+			scope,
+			after: cursor,
+			limit: 100,
+			includeDeleted: true
+		});
+		records.push(...page.records);
+		cursor = page.nextCursor;
+	} while (cursor && records.length < 500);
+	return {
+		records,
+		hasMore: Boolean(cursor)
+	};
+}
+function createCuratorHandler(memory, subconscious, curatorMemory = memory, options) {
+	const config = subconscious.reflection.find((agent) => agent.name === CURATION_AGENT);
+	if (!config) return async () => "no-op";
+	return async (context) => {
+		let store;
+		let scope;
+		try {
+			scope = resolveScope$1(context);
+			store = await memory.storage.getStore("knowledge");
+			if (!store) throw new Error("Subconscious curate requires a configured knowledge storage domain.");
+			const cursor = await store.getCurationCursor({
+				sourceThreadId: context.parentThreadId,
+				agent: CURATION_AGENT
+			});
+			const worklist = await readWorklist$1(store, context.parentThreadId, scope, cursor?.lastKnowledgeId);
+			if (!worklist.records.length && !context.observations.trim()) return "no-op";
+			const result = await (await createCuratorAgent(memory, curatorMemory, context, scope, config, subconscious, options?.omModel)).generate(`Parent thread: ${context.parentThreadId}\nCurrent time: ${(/* @__PURE__ */ new Date()).toISOString()}\nWorklist truncated: ${worklist.hasMore}\n\nCommitted pre-reflection observations:\n${context.observations}\n\nNew KnowledgeRecord worklist:\n${JSON.stringify(worklist.records)}`, {
+				requestContext: context.requestContext,
+				abortSignal: context.abortSignal,
+				maxSteps: config.maxSteps,
+				memory: {
+					thread: `subconscious:${context.parentThreadId}:curate`,
+					resource: context.resourceId
+				}
+			});
+			if (worklist.records.length) {
+				const acknowledgedId = [...result.text.matchAll(/<curation-complete\s+through=["']([^"']+)["']\s*\/>/gi)].at(-1)?.[1];
+				if (!acknowledgedId || !worklist.records.some((record) => record.id === acknowledgedId)) throw new Error("Curator did not acknowledge a valid processed KnowledgeRecord cursor.");
+				await store.advanceCurationCursor({
+					sourceThreadId: context.parentThreadId,
+					agent: CURATION_AGENT,
+					lastKnowledgeId: acknowledgedId
+				});
+			}
+			return "ran";
+		} catch (error) {
+			const message = `curate: ${error instanceof Error ? error.message : String(error)}`;
+			await context.writer?.custom({
+				type: "data-subconscious-error",
+				data: {
+					agent: "curate",
+					error: message
+				}
+			});
+			if (store && scope) await publishSubconsciousActivity({
+				store,
+				scope,
+				recentUpdates: subconscious.activity === false ? 10 : subconscious.activity.recentUpdates,
+				sendStateSignal: context.sendStateSignal,
+				errors: [message]
+			});
+			else await publishSubconsciousError({
+				error: message,
+				sendStateSignal: context.sendStateSignal
+			});
+			throw error;
+		}
+	};
+}
+async function createCuratorAgent(memory, curatorMemory, context, scope, config, subconscious, omModel) {
+	const model = await resolveSubconsciousAgentModel({
+		config,
+		omModel,
+		mainAgent: context.mainAgent,
+		requestContext: context.requestContext
+	});
+	if (!model) throw new Error("Subconscious curate requires the main agent to resolve its model.");
+	return new _mastra_core_agent.Agent({
+		id: `subconscious-curate-${context.parentThreadId}`,
+		name: "Subconscious Curate",
+		instructions: [
+			DEFAULT_INSTRUCTIONS$1,
+			subconscious.pins ? PINNED_INSTRUCTIONS : void 0,
+			config.instructions?.trim()
+		].filter(Boolean).join("\n\n"),
+		model,
+		memory: curatorMemory,
+		tools: {
+			...createKnowledgeTools(memory),
+			...createKnowledgeWriteTools(memory, {
+				scope,
+				sourceThreadId: context.parentThreadId,
+				defaultScope: subconscious.defaultScope,
+				maxScope: subconscious.maxScope
+			}),
+			...subconscious.pins ? createPinnedTools(memory, {
+				scope,
+				sourceThreadId: context.parentThreadId,
+				defaultScope: subconscious.defaultScope,
+				maxScope: subconscious.maxScope,
+				maxPins: subconscious.pins.maxPins,
+				maxCharacters: subconscious.pins.maxCharacters
+			}) : {}
+		}
+	});
+}
+//#endregion
+//#region src/processors/observational-memory/subconscious/learn.ts
+const LEARN_AGENT = "learn";
+const ULID_ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+const DEFAULT_INSTRUCTIONS = `Learn reusable skills from the full pre-reflection observations and pending knowledge records.
+
+A skill is a repeatable procedure with ordered actions, a trigger or context, and a success or recovery outcome. Do not learn one-off events, isolated preferences, knowledge records, or procedures supported by fewer than two distinct pending knowledge records. Search existing kind:skill nodes by exact name before writing so updates extend one skill rather than creating duplicates.
+
+Use knowledge_record_skill for every skill creation or evidence update. It validates the evidence frontier and writes retry-safe evidence. You may use the other scoped knowledge tools for research and maintenance, but never restore deleted records, invent provenance or versions, or write outside the source scope.
+
+Process pending records in ID order. End with <learning-complete through="RECORD_ID" /> naming the last pending record you reviewed, even when no reusable skill was found. Acknowledge only records you fully reviewed.`;
+function resolveScope(context) {
+	const organizationId = context.requestContext?.get("organizationId");
+	if (typeof organizationId !== "string" || !organizationId.trim()) throw new Error("Subconscious learn requires organizationId in the request context.");
+	return (0, _mastra_core_storage.canonicalizeKnowledgeScope)([
+		`org:${organizationId}`,
+		`resource:${resolveKnowledgeResourceId(context.requestContext, context.resourceId)}`,
+		`thread:${context.parentThreadId}`
+	]);
+}
+async function readWorklist(store, sourceThreadId, scope, after) {
+	const records = [];
+	let cursor = after;
+	do {
+		const page = await store.knowledgeBySource({
+			sourceThreadId,
+			scope,
+			after: cursor,
+			limit: 100
+		});
+		records.push(...page.records);
+		cursor = page.nextCursor;
+	} while (cursor && records.length < 500);
+	return {
+		records,
+		hasMore: Boolean(cursor)
+	};
+}
+function evidenceRecordId(sourceRecordId, skillName) {
+	const hash = (0, crypto$1.createHash)("sha256").update(`${skillName.trim().toLocaleLowerCase()}\0${sourceRecordId}`).digest();
+	let suffix = "";
+	for (let index = 0; index < 16; index++) suffix += ULID_ALPHABET[hash[index] & 31];
+	return `${sourceRecordId.slice(0, 10)}${suffix}`;
+}
+function createLearnerRecordSkillTool(input) {
+	return (0, _mastra_core_tools.createTool)({
+		id: "knowledge_record_skill",
+		description: "Create or update one reusable skill using at least two distinct pending knowledge records. Evidence writes are idempotent across retries.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				name: {
+					type: "string",
+					minLength: 1
+				},
+				procedure: {
+					type: "string",
+					minLength: 1
+				},
+				sourceRecordIds: {
+					type: "array",
+					items: {
+						type: "string",
+						minLength: 1
+					},
+					minItems: 2,
+					uniqueItems: true
+				}
+			},
+			required: [
+				"name",
+				"procedure",
+				"sourceRecordIds"
+			],
+			additionalProperties: false
+		},
+		execute: async (raw) => {
+			const value = raw;
+			const sourceIds = [...new Set(value.sourceRecordIds)];
+			const pending = new Map(input.pendingRecords.map((record) => [record.id, record]));
+			if (sourceIds.length < 2 || sourceIds.some((id) => !pending.has(id))) throw new Error("Skill evidence requires at least two distinct records from the pending learner worklist.");
+			const normalizedName = value.name.trim();
+			if (input.state.recordedName && input.state.recordedName.toLocaleLowerCase() !== normalizedName.toLocaleLowerCase()) throw new Error("The learner may record at most one skill per reflection.");
+			input.state.recordedName = normalizedName;
+			const nodeScope = (0, _mastra_core_storage.expandKnowledgeScope)(input.scope, input.defaultScope);
+			let node = await input.store.resolveNode({
+				name: normalizedName,
+				scope: input.scope
+			});
+			if (node && node.kind !== "skill") throw new Error(`Knowledge node is not a skill: ${normalizedName}`);
+			node ??= await input.store.createNode({
+				name: normalizedName,
+				kind: "skill",
+				scope: nodeScope
+			});
+			const evidence = [];
+			for (const sourceId of sourceIds) {
+				const id = evidenceRecordId(sourceId, normalizedName);
+				const existing = await input.store.getKnowledge({ id });
+				if (existing) {
+					evidence.push(existing);
+					continue;
+				}
+				const source = pending.get(sourceId);
+				try {
+					evidence.push(await input.store.appendKnowledge({
+						id,
+						node: node.id,
+						text: `Procedure: ${value.procedure.trim()} Evidence source: ${source.id}.`,
+						scope: source.scope,
+						sourceThreadId: `subconscious:${input.parentThreadId}:learn`,
+						maxScope: source.maxScope ?? input.maxScope,
+						resolutionScope: input.scope,
+						defaultScope: nodeScope
+					}));
+				} catch (error) {
+					const raced = await input.store.getKnowledge({ id });
+					if (!raced) throw error;
+					evidence.push(raced);
+				}
+			}
+			return {
+				node,
+				evidence
+			};
+		}
+	});
+}
+function composeReflectionAgentHandlers(handlers) {
+	return async (context) => {
+		for (const handler of handlers) try {
+			await handler(context);
+		} catch (error) {
+			if (context.abortSignal?.aborted) throw error;
+		}
+	};
+}
+function createLearnerHandler(memory, subconscious, learnerMemory = memory, options) {
+	const config = subconscious.reflection.find((agent) => agent.name === LEARN_AGENT);
+	if (!config) return async () => {};
+	return async (context) => {
+		let store;
+		let scope;
+		try {
+			scope = resolveScope(context);
+			store = await memory.storage.getStore("knowledge");
+			if (!store) throw new Error("Subconscious learn requires a configured knowledge storage domain.");
+			const cursor = await store.getCurationCursor({
+				sourceThreadId: context.parentThreadId,
+				agent: LEARN_AGENT
+			});
+			const worklist = await readWorklist(store, context.parentThreadId, scope, cursor?.lastKnowledgeId);
+			if (!worklist.records.length) return;
+			const acknowledgedId = (await (await createLearnerAgent(memory, learnerMemory, context, scope, worklist.records, config, subconscious, options?.omModel)).generate(`Parent thread: ${context.parentThreadId}\nCurrent time: ${(/* @__PURE__ */ new Date()).toISOString()}\nWorklist truncated: ${worklist.hasMore}\n\nFull pre-reflection observations:\n${context.observations}\n\nPending knowledge records:\n${JSON.stringify(worklist.records)}`, {
+				requestContext: context.requestContext,
+				abortSignal: context.abortSignal,
+				maxSteps: config.maxSteps,
+				memory: {
+					thread: `subconscious:${context.parentThreadId}:learn`,
+					resource: context.resourceId
+				}
+			})).text.match(/<learning-complete\s+through=["']([^"']+)["']\s*\/>/i)?.[1];
+			if (!acknowledgedId || !worklist.records.some((record) => record.id === acknowledgedId)) throw new Error("Learner did not acknowledge a valid reviewed record cursor.");
+			await store.advanceCurationCursor({
+				sourceThreadId: context.parentThreadId,
+				agent: LEARN_AGENT,
+				lastKnowledgeId: acknowledgedId
+			});
+		} catch (error) {
+			const message = `learn: ${error instanceof Error ? error.message : String(error)}`;
+			await context.writer?.custom({
+				type: "data-subconscious-error",
+				data: {
+					agent: "learn",
+					error: message
+				}
+			});
+			if (store && scope) await publishSubconsciousActivity({
+				store,
+				scope,
+				recentUpdates: subconscious.activity === false ? 10 : subconscious.activity.recentUpdates,
+				sendStateSignal: context.sendStateSignal,
+				errors: [message]
+			});
+			else await publishSubconsciousError({
+				error: message,
+				sendStateSignal: context.sendStateSignal
+			});
+			throw error;
+		}
+	};
+}
+async function createLearnerAgent(memory, learnerMemory, context, scope, pendingRecords, config, subconscious, omModel) {
+	const model = await resolveSubconsciousAgentModel({
+		config,
+		omModel,
+		mainAgent: context.mainAgent,
+		requestContext: context.requestContext
+	});
+	if (!model) throw new Error("Subconscious learn requires the main agent to resolve its model.");
+	const store = await memory.storage.getStore("knowledge");
+	if (!store) throw new Error("Subconscious learn requires a configured knowledge storage domain.");
+	const state = {};
+	return new _mastra_core_agent.Agent({
+		id: `subconscious-learn-${context.parentThreadId}`,
+		name: "Subconscious Learn",
+		instructions: [DEFAULT_INSTRUCTIONS, config.instructions?.trim()].filter(Boolean).join("\n\n"),
+		model,
+		memory: learnerMemory,
+		tools: {
+			...createKnowledgeTools(memory, scope),
+			...createKnowledgeWriteTools(memory, {
+				scope,
+				sourceThreadId: context.parentThreadId,
+				defaultScope: subconscious.defaultScope,
+				maxScope: subconscious.maxScope
+			}),
+			knowledge_record_skill: createLearnerRecordSkillTool({
+				store,
+				scope,
+				pendingRecords,
+				parentThreadId: context.parentThreadId,
+				defaultScope: subconscious.defaultScope,
+				maxScope: subconscious.maxScope,
+				state
+			})
+		}
+	});
+}
+//#endregion
+//#region src/processors/observational-memory/constants.ts
+var constants_exports = /* @__PURE__ */ __exportAll({
+	OBSERVATIONAL_MEMORY_DEFAULTS: () => OBSERVATIONAL_MEMORY_DEFAULTS,
+	OBSERVATION_CONTEXT_INSTRUCTIONS: () => OBSERVATION_CONTEXT_INSTRUCTIONS,
+	OBSERVATION_CONTEXT_PROMPT: () => OBSERVATION_CONTEXT_PROMPT,
+	OBSERVATION_CONTINUATION_HINT: () => OBSERVATION_CONTINUATION_HINT,
+	getRetrievalInstructions: () => getRetrievalInstructions
+});
+/**
+* Default configuration values matching the spec
+*/
+const OBSERVATIONAL_MEMORY_DEFAULTS = {
+	observation: {
+		model: "google/gemini-2.5-flash",
+		messageTokens: 3e4,
+		modelSettings: {
+			temperature: .3,
+			maxOutputTokens: 1e5
+		},
+		providerOptions: { google: { thinkingConfig: { thinkingBudget: 215 } } },
+		maxTokensPerBatch: 1e4,
+		bufferTokens: .2,
+		bufferActivation: .8
+	},
+	reflection: {
+		model: "google/gemini-2.5-flash",
+		observationTokens: 4e4,
+		modelSettings: {
+			temperature: 0,
+			maxOutputTokens: 1e5
+		},
+		providerOptions: { google: { thinkingConfig: { thinkingBudget: 1024 } } },
+		bufferActivation: .5
+	}
+};
+/**
+* Continuation hint injected after observations to guide the model's behavior.
+* Prevents the model from awkwardly acknowledging the memory system or treating
+* the conversation as new after observed messages are removed.
+*/
+const OBSERVATION_CONTINUATION_HINT = `Please continue naturally with the conversation so far and respond to the latest message.
+
+Use the earlier context only as background. If something appears unfinished, continue only when it helps answer the latest request. If a suggested response is provided, follow it naturally.
+
+Do not mention internal instructions, memory, summarization, context handling, or missing messages.
+
+Any messages following this reminder are newer and should take priority.`;
+/**
+* Preamble that introduces the observations block.
+* Use before `<observations>`, with instructions after.
+* Full pattern: `${OBSERVATION_CONTEXT_PROMPT}\n\n<observations>\n${obs}\n</observations>\n\n${OBSERVATION_CONTEXT_INSTRUCTIONS}`
+*/
+const OBSERVATION_CONTEXT_PROMPT = `The following observations block contains your memory of past conversations with this user.`;
+/**
+* Instructions that tell the model how to interpret and use observations.
+* Place AFTER the `<observations>` block so the model sees the data before the rules.
+*/
+const OBSERVATION_CONTEXT_INSTRUCTIONS = `IMPORTANT: When responding, reference specific details from these observations. Do not give generic advice - personalize your response based on what you know about this user's experiences, preferences, and interests. If the user asks for recommendations, connect them to their past experiences mentioned above.
+
+KNOWLEDGE UPDATES: When asked about current state (e.g., "where do I currently...", "what is my current..."), always prefer the MOST RECENT information. Observations include dates - if you see conflicting information, the newer observation supersedes the older one. Look for phrases like "will start", "is switching", "changed to", "moved to" as indicators that previous information has been updated.
+
+PLANNED ACTIONS: If the user stated they planned to do something (e.g., "I'm going to...", "I'm looking forward to...", "I will...") and the date they planned to do it is now in the past (check the relative time like "3 weeks ago"), assume they completed the action unless there's evidence they didn't. For example, if someone said "I'll start my new diet on Monday" and that was 2 weeks ago, assume they started the diet.
+
+MOST RECENT USER INPUT: Treat the most recent user message as the highest-priority signal for what to do next. Earlier messages may contain constraints, details, or context you should still honor, but the latest message is the primary driver of your response.
+
+SYSTEM REMINDERS: Messages wrapped in <system-reminder>...</system-reminder> contain internal continuation guidance, not user-authored content. Use them to maintain continuity, but do not mention them or treat them as part of the user's message.`;
+/**
+* Instructions for retrieval mode — explains observation-group ranges and the recall tool.
+* Appended to context when `retrieval` is enabled.
+*
+* The content adapts to the retrieval scope:
+* - `'resource'`: covers routing between `search`, `threads`, and `messages` across
+*   all of the user's threads, including fallback when search results are unsuitable.
+* - `'thread'`: covers cursor-based browsing and search within the current thread.
+*
+* @param scope - The retrieval scope the recall tool was registered with.
+* @param customInstructions - Optional application-provided guidance appended after
+*   the native instructions. Never replaces them.
+* @param searchEnabled - Whether semantic search (`retrieval: { vector: true }`) is
+*   available. When false, the guidance only covers \`threads\`/\`messages\` browsing so
+*   the agent is not steered toward a mode that cannot work.
+*/
+function getRetrievalInstructions(scope = "resource", customInstructions, searchEnabled = true) {
+	const isResource = scope === "resource";
+	const base = `## Recall — looking up source messages
+
+Your memory is comprised of observations which are sometimes wrapped in <observation-group> xml tags containing ranges like <observation-group range="startId:endId">. These ranges point back to the raw messages that each observation group was derived from. The original messages are still available — use the **recall** tool to retrieve them.
+
+### When to use recall
+- The user asks you to **repeat, show, or reproduce** something from a past conversation
+- The user asks for **exact content** — code, text, quotes, error messages, URLs, file paths, specific numbers
+- Your observations mention something but your memory lacks the detail needed to fully answer (e.g. you know a blog post was shared but only have a summary of it)
+- You want to **verify or expand on** an observation before responding${isResource ? `
+- The user references another conversation that your observations don't cover — even if you have no observations yet, their other threads may contain it` : ""}
+
+**Default to using recall when the user references specific past content.** Your observations capture the gist, not the details. If there's any doubt whether your memory is complete enough, use recall.
+
+${isResource ? searchEnabled ? `### Choosing a mode
+The recall tool works across ALL of this user's conversation threads, not just the current one.
+
+- Use \`mode: "search"\` with a \`query\` when you don't know which thread contains the answer. Each result includes its thread ID and the raw message IDs it came from, which you can use as a \`cursor\`.
+- Use \`mode: "messages"\` when you already know the thread — pass \`threadId\` to read another thread, or a \`cursor\` from an observation-group range or a search result.
+- Use \`mode: "threads"\` to list the user's threads (IDs, titles, dates) when you need to discover where something was discussed. Use \`before\`/\`after\` to narrow by date.
+
+**If search results look irrelevant, do not give up.** Search only covers content that has been indexed — a short or recent conversation may exist in raw message history before any observation of it was created. When search returns nothing suitable but the user is clearly referring to a past conversation, call \`mode: "threads"\` to find candidate threads (titles and dates are strong clues), then read them with \`mode: "messages"\`. If a search result already gives you a thread ID, go straight to \`mode: "messages"\`.` : `### Choosing a mode
+The recall tool works across ALL of this user's conversation threads, not just the current one.
+
+- Use \`mode: "threads"\` to list the user's threads (IDs, titles, dates) when you need to discover where something was discussed. Use \`before\`/\`after\` to narrow by date.
+- Use \`mode: "messages"\` when you know the thread — pass \`threadId\` to read another thread, or a \`cursor\` from an observation-group range.
+
+When the user refers to a past conversation you don't have a cursor for, call \`mode: "threads"\` to find candidate threads (titles and dates are strong clues), then read them with \`mode: "messages"\`. Raw history may exist for threads that have no observations yet.` : `### Choosing a mode
+The recall tool is limited to the current conversation thread.
+
+- Use \`mode: "messages"\` (default) to page through this thread's message history near a cursor.${searchEnabled ? `
+- Use \`mode: "search"\` with a \`query\` to find messages by content within this thread.` : ""}
+- Use \`mode: "threads"\` to get the current thread's ID, title, and dates.`}
+
+### How to use recall with a cursor
+Each range has the format \`startId:endId\` where both are message IDs separated by a colon.
+
+1. Find the observation group relevant to the user's question and extract the start or end ID from its range.
+2. Call \`recall\` with that ID as the \`cursor\`.
+3. Use \`page: 1\` (or omit) to read forward from the cursor, \`page: -1\` to read backward.
+4. If the first page doesn't have what you need, increment the page number to keep paginating.
+5. Check \`hasNextPage\`/\`hasPrevPage\` in the result to know if more pages exist in each direction.
+
+### Detail levels
+By default recall returns **low** detail: truncated text and tool names only. Each message shows its ID and each part has a positional index like \`[p0]\`, \`[p1]\`, etc.
+
+- Use \`detail: "high"\` to get full message content including tool arguments and results. This will only return the high detail version of a single message part at a time.
+- Use \`partIndex\` with a cursor to fetch a single part at full detail — for example, to read one specific tool result or code block without loading every part.
+
+If the result says \`truncated: true\`, the output was cut to fit the token budget. You can paginate or use \`partIndex\` to target specific content. If a single part is itself too large, follow the returned \`nextCharOffset\` as described below.
+
+### Following up on truncated parts
+Low-detail results may include truncation hints like:
+\`[truncated — call recall cursor="..." partIndex=N detail="high" for full content]\`
+
+**When you see these hints and need the full content, make the exact call described in the hint.** This is the normal workflow: first recall at low detail to scan, then drill into specific parts at high detail. Do not stop at the low-detail result if the user asked for exact content.
+
+If a single part is larger than the token budget, the \`partIndex\` result is \`truncated: true\` and includes \`nextCharOffset\`. Repeat the same call with \`charOffset\` set to that exact value to read the next chunk from where the previous one ended. Keep following \`nextCharOffset\` until the result no longer includes it — the chunks together contain the full part. Retrying without \`charOffset\` returns the same prefix again.
+
+### When recall is NOT needed
+- The user is asking for a high-level summary and your observations already cover it
+- The question is about general preferences or facts that don't require source text
+${isResource ? `- No relevant observation range exists AND ${searchEnabled ? "`search`/`threads`" : "`threads`"} turned up nothing — but remember that raw history may exist for threads that have no observations yet, so check before concluding the information is unavailable` : `- There is no relevant range in your observations for the topic`}
+
+Observation groups with range IDs and your recall tool allows you to think back and remember details you're fuzzy on.`;
+	const custom = customInstructions?.trim();
+	if (!custom) return base;
+	return `${base}
+
+### Additional recall guidance
+${custom}`;
+}
+//#endregion
+//#region src/processors/observational-memory/extracted-values.ts
+const BUILT_IN_METADATA_FIELDS = {
+	"current-task": {
+		metadataField: "currentTask",
+		builtInField: "currentTask"
+	},
+	"suggested-response": {
+		metadataField: "suggestedResponse",
+		builtInField: "suggestedContinuation"
+	},
+	"thread-title": {
+		metadataField: "threadTitle",
+		builtInField: "threadTitle"
+	}
+};
+function isPresentExtractedValue(value) {
+	return value !== void 0 && value !== null && value !== "";
+}
+function normalizeExtractedValues(values) {
+	if (!values) return;
+	const normalized = Object.fromEntries(Object.entries(values).filter(([, value]) => isPresentExtractedValue(value)));
+	return Object.keys(normalized).length > 0 ? normalized : void 0;
+}
+function mergeExtractedValues(...valueSets) {
+	const merged = {};
+	for (const values of valueSets) {
+		const normalized = normalizeExtractedValues(values);
+		if (normalized) Object.assign(merged, normalized);
+	}
+	return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function mergeExtractionFailures(...failureSets) {
+	const failures = failureSets.flatMap((set) => set ?? []);
+	return failures.length > 0 ? failures : void 0;
+}
+const UNSAFE_METADATA_PATH_SEGMENTS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+function getMetadataPathSegments(keyPath) {
+	if (keyPath === false) return;
+	const segments = keyPath.split(".").filter(Boolean);
+	if (segments.some((segment) => UNSAFE_METADATA_PATH_SEGMENTS.has(segment))) throw new Error(`Extractor metadataKeyPath "${keyPath}" contains an unsafe path segment.`);
+	return segments.length > 0 ? segments : void 0;
+}
+function getValueAtPath(metadata, keyPath) {
+	if (!metadata) return;
+	const segments = getMetadataPathSegments(keyPath);
+	if (!segments) return;
+	let current = metadata;
+	for (const segment of segments) {
+		if (!current || typeof current !== "object" || Array.isArray(current)) return;
+		current = current[segment];
+	}
+	return current;
+}
+function setValueAtPath(metadata, keyPath, value) {
+	if (!isPresentExtractedValue(value)) return;
+	const segments = getMetadataPathSegments(keyPath);
+	if (!segments) return;
+	let current = metadata;
+	for (const segment of segments.slice(0, -1)) {
+		const next = current[segment];
+		if (!next || typeof next !== "object" || Array.isArray(next)) current[segment] = {};
+		current = current[segment];
+	}
+	current[segments[segments.length - 1]] = value;
+}
+function readBuiltInMetadataValues(metadata) {
+	const values = {};
+	for (const slug of BUILT_IN_EXTRACTOR_SLUGS) {
+		const { metadataField } = BUILT_IN_METADATA_FIELDS[slug];
+		values[slug] = metadata[metadataField];
+	}
 	return values;
 }
 function getPriorExtractedValues(metadata, extractors) {
@@ -15143,9 +17327,11 @@ async function applyExtractorHooks(opts) {
 	const values = normalizeExtractedValues(opts.values) ?? {};
 	const failures = [...opts.failures ?? []];
 	for (const extractor of opts.extractors) {
-		if (!Object.prototype.hasOwnProperty.call(values, extractor.slug)) continue;
-		const current = values[extractor.slug];
-		if (!isPresentExtractedValue(current)) {
+		const isHook = extractor.mode === "hook";
+		const hasValue = Object.prototype.hasOwnProperty.call(values, extractor.slug);
+		if (!isHook && !hasValue) continue;
+		const current = isHook ? opts.rawObservations : values[extractor.slug];
+		if (!isHook && !isPresentExtractedValue(current)) {
 			delete values[extractor.slug];
 			continue;
 		}
@@ -15156,14 +17342,19 @@ async function applyExtractorHooks(opts) {
 				extractor,
 				threadId: opts.threadId,
 				resourceId: opts.resourceId,
-				previous: opts.previousValues?.[extractor.slug],
+				previous: isHook ? void 0 : opts.previousValues?.[extractor.slug],
 				current,
+				rawObservations: opts.rawObservations,
+				recentMessages: opts.recentMessages,
 				mainAgent: opts.mainAgent,
 				memory: opts.memory,
 				sendSignal: opts.sendSignal,
+				sendStateSignal: opts.sendStateSignal,
+				writer: opts.writer,
+				abortSignal: opts.abortSignal,
 				requestContext: opts.requestContext
 			});
-			if (hookValue === void 0) continue;
+			if (isHook || hookValue === void 0) continue;
 			const parsed = extractor.schema.safeParse(hookValue);
 			if (parsed.success) values[extractor.slug] = parsed.data;
 			else {
@@ -15174,7 +17365,8 @@ async function applyExtractorHooks(opts) {
 				});
 			}
 		} catch (error) {
-			delete values[extractor.slug];
+			if (opts.abortSignal?.aborted) throw error;
+			if (!isHook) delete values[extractor.slug];
 			failures.push({
 				slug: extractor.slug,
 				error: error instanceof Error ? error.message : String(error)
@@ -16239,11 +18431,11 @@ function formatObserverAttachmentPlaceholder(part, counter) {
 	const label = resolveObserverAttachmentLabel(part);
 	return label ? `[${attachmentType} #${attachmentId}: ${label}]` : `[${attachmentType} #${attachmentId}]`;
 }
-function isRecord$2(value) {
+function isRecord$3(value) {
 	return !!value && typeof value === "object";
 }
 function mapToolResultBlockToAttachment(block) {
-	if (!isRecord$2(block) || typeof block.type !== "string") return;
+	if (!isRecord$3(block) || typeof block.type !== "string") return;
 	const mediaType = typeof block.mediaType === "string" ? block.mediaType : void 0;
 	const filename = typeof block.filename === "string" ? block.filename : void 0;
 	switch (block.type) {
@@ -16304,7 +18496,7 @@ function mapToolResultBlockToAttachment(block) {
 	}
 }
 function extractToolResultAttachments(result, counter, attachmentFilter) {
-	if (!isRecord$2(result) || result.type !== "content" || !Array.isArray(result.value)) return {
+	if (!isRecord$3(result) || result.type !== "content" || !Array.isArray(result.value)) return {
 		resultWithoutAttachments: result,
 		attachments: []
 	};
@@ -16318,7 +18510,7 @@ function extractToolResultAttachments(result, counter, attachmentFilter) {
 		if (shouldIncludeObserverAttachment(attachment, attachmentFilter)) attachments.push(toObserverInputAttachmentPart(attachment));
 		const placeholder = formatObserverAttachmentPlaceholder(attachment, counter);
 		return {
-			type: isRecord$2(block) ? block.type : void 0,
+			type: isRecord$3(block) ? block.type : void 0,
 			placeholder
 		};
 	});
@@ -16861,17 +19053,17 @@ const TRANSIENT_MESSAGE_SUBSTRINGS = [
 	"connection reset",
 	"connection closed"
 ];
-function isRecord$1(value) {
+function isRecord$2(value) {
 	return typeof value === "object" && value !== null;
 }
 function isAbortError(error) {
-	if (!isRecord$1(error)) return false;
+	if (!isRecord$2(error)) return false;
 	if (error.name === "AbortError") return true;
 	if (typeof error.code === "string" && error.code === "ABORT_ERR") return true;
 	return false;
 }
 function hasTransientMessage(value) {
-	if (!isRecord$1(value)) return false;
+	if (!isRecord$2(value)) return false;
 	const message = typeof value.message === "string" ? value.message.toLowerCase() : "";
 	if (message && TRANSIENT_MESSAGE_SUBSTRINGS.some((sub) => message.includes(sub))) return true;
 	if (typeof value.code === "string" && value.code.toUpperCase().startsWith("UND_ERR_")) return true;
@@ -16882,13 +19074,13 @@ function isRetryableHttpStatus(status) {
 	return status >= 500 && status <= 599;
 }
 function hasRetryableHttpStatus(value) {
-	if (!isRecord$1(value)) return false;
+	if (!isRecord$2(value)) return false;
 	if (typeof value.statusCode === "number" && isRetryableHttpStatus(value.statusCode)) return true;
 	if (typeof value.code === "number" && isRetryableHttpStatus(value.code)) return true;
 	return false;
 }
 function hasIsRetryableFlag(value) {
-	if (!isRecord$1(value)) return false;
+	if (!isRecord$2(value)) return false;
 	return value.isRetryable === true;
 }
 /**
@@ -16906,14 +19098,14 @@ function isTransientLLMError(error) {
 	if (isAbortError(error)) return false;
 	const visited = /* @__PURE__ */ new WeakSet();
 	function visit(candidate) {
-		if (isRecord$1(candidate)) {
+		if (isRecord$2(candidate)) {
 			if (visited.has(candidate)) return false;
 			visited.add(candidate);
 		}
 		if (hasTransientMessage(candidate)) return true;
 		if (hasRetryableHttpStatus(candidate)) return true;
 		if (hasIsRetryableFlag(candidate)) return true;
-		if (isRecord$1(candidate)) {
+		if (isRecord$2(candidate)) {
 			if (visit(candidate.cause)) return true;
 			if (visit(candidate.error)) return true;
 		}
@@ -20152,40 +22344,6 @@ function createWorkingMemoryTool(config, options = {}) {
 	};
 }
 //#endregion
-//#region src/processors/observational-memory/model-by-input-tokens.ts
-function isTieredModelTarget(model) {
-	if (typeof model === "string") return true;
-	if (!model || typeof model !== "object") return false;
-	return "modelId" in model || "id" in model || "providerId" in model || "provider" in model || "doGenerate" in model && "doStream" in model;
-}
-function normalizeThresholds(config) {
-	const entries = Object.entries(config.upTo);
-	if (entries.length === 0) throw new Error("ModelByInputTokens requires at least one threshold in \"upTo\"");
-	for (const [limitStr, model] of entries) {
-		const limit = Number(limitStr);
-		if (!Number.isFinite(limit) || limit <= 0) throw new Error(`ModelByInputTokens threshold keys must be positive numbers. Got: ${limitStr}`);
-		if (!isTieredModelTarget(model)) throw new Error(`ModelByInputTokens requires a valid model target for threshold ${limitStr}`);
-	}
-	return entries.map(([limitStr, model]) => ({
-		limit: Number(limitStr),
-		model
-	})).sort((a, b) => a.limit - b.limit);
-}
-var ModelByInputTokens = class {
-	thresholds;
-	constructor(config) {
-		this.thresholds = normalizeThresholds(config);
-	}
-	resolve(inputTokens) {
-		for (const { limit, model } of this.thresholds) if (inputTokens <= limit) return model;
-		const maxLimit = this.thresholds[this.thresholds.length - 1].limit;
-		throw new Error(`ModelByInputTokens: input token count (${inputTokens}) exceeds the largest configured threshold (${maxLimit}). Please configure a higher threshold or use a larger model.`);
-	}
-	getThresholds() {
-		return this.thresholds.map((t) => t.limit);
-	}
-};
-//#endregion
 //#region src/processors/observational-memory/activation-ttl.ts
 const MINUTE = 6e4;
 const HOUR = 60 * MINUTE;
@@ -20993,6 +23151,39 @@ function reconcileObservationGroupsFromReflection(content, sourceObservations) {
 	if (derivedGroups.length > 0) return derivedGroups.map((group) => wrapInObservationGroup(group.content, group.range, group.id, void 0, group.kind)).join("\n\n");
 	return wrapInObservationGroup(normalizedContent, combineObservationGroupRanges(sourceGroups), generateAnchorId(), void 0, "reflection");
 }
+function isRecord$1(value) {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isSubconsciousSignalMessage(message) {
+	if (message.role !== "signal" || !isRecord$1(message.content)) return false;
+	const contentMetadata = message.content.metadata;
+	if (!isRecord$1(contentMetadata) || !isRecord$1(contentMetadata.signal)) return false;
+	const signal = contentMetadata.signal;
+	const metadata = signal.metadata;
+	const attributes = signal.attributes;
+	return signal.origin === "subconscious" || isRecord$1(metadata) && metadata.origin === "subconscious" || isRecord$1(attributes) && attributes.source === "subconscious";
+}
+function isSubconsciousSignalPart(part) {
+	if (!part || typeof part !== "object") return false;
+	const candidate = part;
+	return candidate.type === "data-signal" && (candidate.data?.metadata?.origin === "subconscious" || candidate.data?.attributes?.source === "subconscious");
+}
+function stripSubconsciousSignals(messages) {
+	return messages.flatMap((message) => {
+		if (isSubconsciousSignalMessage(message)) return [];
+		if (typeof message.content === "string") return [message];
+		const parts = message.content.parts.filter((part) => !isSubconsciousSignalPart(part));
+		if (parts.length === message.content.parts.length) return [message];
+		if (parts.length === 0) return [];
+		return [{
+			...message,
+			content: {
+				...message.content,
+				parts
+			}
+		}];
+	});
+}
 //#endregion
 //#region src/processors/observational-memory/thresholds.ts
 /**
@@ -21150,8 +23341,9 @@ var ObservationStrategy = class ObservationStrategy {
 				if (fresh?.lastObservedAt && record.lastObservedAt && fresh.lastObservedAt > record.lastObservedAt) return { observed: false };
 			}
 			const { messages, existingObservations } = await this.prepare();
+			const observationMessages = stripSubconsciousSignals(messages);
 			await this.emitStartMarkers(cycleId);
-			const output = await this.observe(existingObservations, messages);
+			const output = await this.observe(existingObservations, observationMessages);
 			const processed = await this.process(output, existingObservations);
 			await this.persist(processed);
 			await this.emitEndMarkers(cycleId, processed);
@@ -21166,6 +23358,7 @@ var ObservationStrategy = class ObservationStrategy {
 				abortSignal,
 				mainAgent: this.opts.agent,
 				sendSignal: this.opts.sendSignal,
+				sendStateSignal: this.opts.sendStateSignal,
 				reflectionHooks,
 				requestContext,
 				observabilityContext: this.opts.observabilityContext
@@ -21453,11 +23646,16 @@ var SyncObservationStrategy = class extends ObservationStrategy {
 			values: result.extractedValues,
 			failures: result.extractionFailures,
 			previousValues: this.priorExtractedValues,
+			rawObservations: result.observations,
+			recentMessages: formatMessagesForObserver(this.opts.messages, { maxPartLength: 500 }),
 			threadId: this.opts.threadId,
 			resourceId: this.opts.resourceId,
 			mainAgent: this.opts.agent,
 			memory: this.deps.memory,
 			sendSignal: this.opts.sendSignal,
+			sendStateSignal: this.opts.sendStateSignal,
+			writer: this.opts.writer,
+			abortSignal: this.opts.abortSignal,
 			requestContext: this.opts.requestContext
 		});
 		const output = {
@@ -21633,11 +23831,16 @@ var AsyncBufferObservationStrategy = class extends ObservationStrategy {
 			values: result.extractedValues,
 			failures: result.extractionFailures,
 			previousValues: this.priorExtractedValues,
+			rawObservations: result.observations,
+			recentMessages: formatMessagesForObserver(messages, { maxPartLength: 500 }),
 			threadId: this.opts.threadId,
 			resourceId: this.opts.resourceId,
 			mainAgent: this.opts.agent,
 			memory: this.deps.memory,
 			sendSignal: this.opts.sendSignal,
+			sendStateSignal: this.opts.sendStateSignal,
+			writer: this.opts.writer,
+			abortSignal: this.opts.abortSignal,
 			requestContext: this.opts.requestContext
 		});
 		return {
@@ -21972,11 +24175,25 @@ var ResourceScopedObservationStrategy = class extends ObservationStrategy {
 				values: result.extractedValues,
 				failures: result.extractionFailures,
 				previousValues,
+				rawObservations: result.observations,
+				recentMessages: formatMessagesForObserver(threadMessages, { maxPartLength: 500 }),
 				threadId,
 				resourceId: this.resourceId,
 				mainAgent: this.opts.agent,
 				memory: this.deps.memory,
-				sendSignal: this.opts.sendSignal,
+				sendSignal: this.opts.agent ? async (signal) => {
+					const delivery = this.opts.agent.sendSignal(signal, {
+						resourceId: this.resourceId,
+						threadId,
+						ifActive: { behavior: "deliver" },
+						ifIdle: { behavior: "persist" }
+					});
+					await delivery.accepted;
+					return delivery.signal;
+				} : void 0,
+				sendStateSignal: this.opts.sendStateSignal,
+				writer: this.opts.writer,
+				abortSignal: this.opts.abortSignal,
 				requestContext: this.opts.requestContext
 			});
 			this.observationResults.push({
@@ -22295,18 +24512,21 @@ var ObservationStep = class {
 				messageList.removeByIds(candidates.map((msg) => msg.id));
 				for (const msg of candidates) messageList.add(msg, "memory");
 			}
-			om.buffer({
+			om.trackBackgroundWork(om.buffer({
 				threadId,
 				resourceId,
 				messages: unobservedMessages,
 				pendingTokens: statusSnapshot.pendingTokens,
 				record: statusSnapshot.record,
 				writer: this.turn.writer,
+				agent: this.turn.agent,
+				sendSignal: this.turn.sendSignal,
+				sendStateSignal: this.turn.sendStateSignal,
 				requestContext: this.turn.requestContext,
 				observabilityContext: this.turn.observabilityContext
 			}).catch((err) => {
 				omDebug(`[OM:buffer] fire-and-forget buffer failed: ${err?.message}`);
-			});
+			}));
 			buffered = true;
 		}
 		const willObserveNow = statusSnapshot.shouldObserve && !hasIncompleteToolCalls;
@@ -22478,6 +24698,9 @@ var ObservationStep = class {
 			messages: observableMessages,
 			messageList,
 			trigger: "turn-sync",
+			agent: this.turn.agent,
+			sendSignal: this.turn.sendSignal,
+			sendStateSignal: this.turn.sendStateSignal,
 			requestContext: this.turn.requestContext,
 			writer: this.turn.writer,
 			observabilityContext: this.turn.observabilityContext
@@ -22557,6 +24780,8 @@ var ObservationTurn = class {
 	agent;
 	/** Optional signal sender for processor-originated notifications. */
 	sendSignal;
+	/** Optional state signal sender for processor-originated snapshots. */
+	sendStateSignal;
 	/** Current actor model for this step. Updated by the processor before prepare(). */
 	actorModelContext;
 	/** The active assistant response message ID for this step. Updated by the processor before prepare(). */
@@ -22570,6 +24795,7 @@ var ObservationTurn = class {
 		this.messageList = opts.messageList;
 		this.agent = opts.agent;
 		this.sendSignal = opts.sendSignal;
+		this.sendStateSignal = opts.sendStateSignal;
 		this.requestContext = opts.requestContext;
 		this.observabilityContext = opts.observabilityContext;
 		this.hooks = opts.hooks ?? {};
@@ -22674,7 +24900,7 @@ var ObservationTurn = class {
 			const allMessages = getObservableMessages(this.messageList);
 			const record = this._record;
 			const unobservedMessages = this.om.getUnobservedMessages(allMessages, record);
-			if (unobservedMessages.length > 0) this.om.buffer({
+			if (unobservedMessages.length > 0) this.om.trackBackgroundWork(this.om.buffer({
 				threadId: this.threadId,
 				resourceId: this.resourceId,
 				messages: unobservedMessages,
@@ -22682,13 +24908,14 @@ var ObservationTurn = class {
 				writer: this.writer,
 				agent: this.agent,
 				sendSignal: this.sendSignal,
+				sendStateSignal: this.sendStateSignal,
 				requestContext: this.requestContext,
 				currentModel: this.actorModelContext,
 				observabilityContext: this.observabilityContext,
 				skipMinimumTokenCheck: true
 			}).catch((err) => {
 				omDebug(`[OM:turn.end] idle buffer failed: ${err?.message}`);
-			});
+			}));
 		}
 		return { record: this._record };
 	}
@@ -23090,6 +25317,7 @@ var ReflectorRunner = class {
 	persistMarkerToMessage;
 	getCompressionStartLevel;
 	memory;
+	onReflectionCommitted;
 	mastra;
 	constructor(opts) {
 		this.reflectionConfig = opts.reflectionConfig;
@@ -23105,6 +25333,7 @@ var ReflectorRunner = class {
 		this.getCompressionStartLevel = opts.getCompressionStartLevel;
 		this.mastra = opts.mastra;
 		this.memory = opts.memory;
+		this.onReflectionCommitted = opts.onReflectionCommitted;
 	}
 	__registerMastra(mastra) {
 		this.mastra = mastra;
@@ -23172,6 +25401,8 @@ var ReflectorRunner = class {
 		};
 		let reflectedTokens = 0;
 		let attemptNumber = 0;
+		/** Observations from the previous attempt, used to detect a no-progress ladder. */
+		let previousObservations;
 		while (currentLevel <= maxLevel) {
 			attemptNumber++;
 			const isRetry = attemptNumber > 1;
@@ -23245,6 +25476,11 @@ var ReflectorRunner = class {
 				omDebug(`[OM:callReflector] degenerate output persists at maxLevel=${maxLevel}, breaking`);
 				break;
 			}
+			if (!parsed.degenerate && previousObservations !== void 0 && parsed.observations === previousObservations) {
+				omDebug(`[OM:callReflector] attempt #${attemptNumber} returned output identical to the previous attempt; escalating cannot help, stopping the ladder`);
+				break;
+			}
+			previousObservations = parsed.observations;
 			if (streamContext?.writer) {
 				const failedMarker = createObservationFailedMarker({
 					cycleId: streamContext.cycleId,
@@ -23301,6 +25537,8 @@ var ReflectorRunner = class {
 			mainAgent,
 			memory: this.memory,
 			sendSignal,
+			writer: streamContext?.writer,
+			abortSignal,
 			requestContext
 		});
 		const extractedValues = hookedValues.values;
@@ -23456,7 +25694,7 @@ var ReflectorRunner = class {
 	* "activated", "no buffer present", and "suppressed by overshoot guard"
 	* without re-deriving that state.
 	*/
-	async tryActivateBufferedReflection(record, lockKey, writer, messageList, activationMetadata) {
+	async tryActivateBufferedReflection(record, lockKey, writer, messageList, activationMetadata, committedContext) {
 		const bufferKey = this.buffering.getReflectionBufferKey(lockKey);
 		const asyncOp = BufferingCoordinator.asyncBufferingOps.get(bufferKey);
 		if (asyncOp) if (activationMetadata?.triggeredBy === "ttl" || activationMetadata?.triggeredBy === "provider_change") omDebug(`[OM:reflect] tryActivateBufferedReflection: async op in progress, not blocking for ${activationMetadata.triggeredBy} trigger`);
@@ -23475,7 +25713,8 @@ var ReflectorRunner = class {
 		}
 		const beforeTokens = freshRecord.observationTokenCount ?? 0;
 		const reflectedLineCount = freshRecord.reflectedObservationLineCount ?? 0;
-		const unreflectedLines = (freshRecord.activeObservations ?? "").split("\n").slice(reflectedLineCount);
+		const allLines = (freshRecord.activeObservations ?? "").split("\n");
+		const unreflectedLines = allLines.slice(reflectedLineCount);
 		const unreflectedContent = unreflectedLines.join("\n").trim();
 		const combinedObservations = unreflectedContent ? `${freshRecord.bufferedReflection}\n\n${unreflectedContent}` : freshRecord.bufferedReflection;
 		const combinedTokenCount = this.tokenCounter.countObservations(combinedObservations);
@@ -23506,6 +25745,11 @@ var ReflectorRunner = class {
 			currentRecord: freshRecord,
 			tokenCount: combinedTokenCount
 		});
+		if (committedContext) await this.notifyReflectionCommitted({
+			...committedContext,
+			observations: allLines.slice(0, reflectedLineCount).join("\n").trim(),
+			writer
+		});
 		BufferingCoordinator.lastBufferedBoundary.delete(bufferKey);
 		const afterRecord = await this.storage.getObservationalMemory(record.threadId, record.resourceId);
 		const afterTokens = afterRecord?.observationTokenCount ?? 0;
@@ -23541,13 +25785,21 @@ var ReflectorRunner = class {
 		BufferingCoordinator.reflectionBufferCycleIds.delete(bufferKey);
 		return { status: "activated" };
 	}
+	async notifyReflectionCommitted(context) {
+		if (!this.onReflectionCommitted || !context.parentThreadId || !context.resourceId) return;
+		try {
+			await this.onReflectionCommitted(context);
+		} catch (error) {
+			omDebug(`[OM:reflect] post-commit reflection agent failed: ${error}`);
+		}
+	}
 	/**
 	* Check if reflection needed and trigger if so.
 	* Supports both synchronous reflection and async buffered reflection.
 	* @internal Used by observation strategies. Do not call directly.
 	*/
 	async maybeReflect(opts) {
-		const { record, observationTokens, writer, abortSignal, mainAgent, sendSignal, messageList, currentModel, reflectionHooks, requestContext, observabilityContext, lastActivityAt, threadId: requestedThreadId } = opts;
+		const { record, observationTokens, writer, abortSignal, mainAgent, sendSignal, sendStateSignal, messageList, currentModel, reflectionHooks, requestContext, observabilityContext, lastActivityAt, threadId: requestedThreadId } = opts;
 		const lockKey = this.buffering.getLockKey(record.threadId, record.resourceId);
 		const reflectThreshold = getMaxThreshold(this.getEffectiveReflectionTokens(record));
 		const priorExtractedValues = await getThreadExtractedValues(this.storage, this.reflectionConfig.extractors, requestedThreadId ?? record.threadId);
@@ -23592,7 +25844,15 @@ var ReflectorRunner = class {
 			await this.storage.setReflectingFlag(record.id, false);
 		}
 		if (this.buffering.isAsyncReflectionEnabled()) {
-			const activationResult = await this.tryActivateBufferedReflection(record, lockKey, writer, messageList, activationMetadata);
+			const activationResult = await this.tryActivateBufferedReflection(record, lockKey, writer, messageList, activationMetadata, {
+				parentThreadId: requestedThreadId ?? record.threadId ?? "",
+				resourceId: record.resourceId ?? "",
+				requestContext,
+				mainAgent,
+				sendStateSignal,
+				abortSignal,
+				observabilityContext
+			});
 			if (activationResult.status === "activated") return;
 			if (activationResult.status === "suppressed") {
 				omDebug(`[OM:reflect] skipping sync fallback / re-buffer after suppressed early ${activationMetadata.triggeredBy} activation (reason=${activationResult.reason})`);
@@ -23663,6 +25923,17 @@ var ReflectorRunner = class {
 				reflection: reflectResult.observations,
 				tokenCount: reflectionTokenCount
 			});
+			await this.notifyReflectionCommitted({
+				parentThreadId: requestedThreadId ?? record.threadId ?? "",
+				resourceId: record.resourceId ?? "",
+				observations: record.activeObservations ?? "",
+				requestContext,
+				mainAgent,
+				sendStateSignal,
+				writer,
+				abortSignal,
+				observabilityContext
+			});
 			if (writer && streamContext) {
 				const endMarker = createObservationEndMarker({
 					cycleId: streamContext.cycleId,
@@ -24192,6 +26463,7 @@ var ObservationalMemory = class ObservationalMemory {
 	hasher = (0, xxhash_wasm.default)();
 	mastra;
 	memory;
+	curationCadence;
 	/**
 	* Track message IDs observed during this instance's lifetime.
 	* Prevents re-observing messages when per-thread lastObservedAt cursors
@@ -24223,6 +26495,39 @@ var ObservationalMemory = class ObservationalMemory {
 	*/
 	recordInitializations = /* @__PURE__ */ new Map();
 	/**
+	* In-flight fire-and-forget background cycles (buffered observation, reflection).
+	* Tracked so callers can join them via `settled()` before closing a storage
+	* connection they own — otherwise a background cycle's tail statements race the close.
+	*/
+	pendingBackgroundWork = /* @__PURE__ */ new Set();
+	/**
+	* Register fire-and-forget background work so `settled()` can join it.
+	* Returns the original promise so callers keep their own rejection handling.
+	*/
+	trackBackgroundWork(work) {
+		const tracked = work.catch(() => {}).finally(() => {
+			this.pendingBackgroundWork.delete(tracked);
+		});
+		this.pendingBackgroundWork.add(tracked);
+		return work;
+	}
+	/**
+	* Resolve once all background observational-memory work started so far has finished.
+	*
+	* Background cycles enqueue further background work (a buffered observation can
+	* trigger a reflection, which runs nested agent streams), so this drains repeatedly
+	* until nothing is left rather than joining a single snapshot.
+	*/
+	async settled() {
+		const maxDrainRounds = 100;
+		for (let round = 0; round < maxDrainRounds; round++) {
+			if (this.pendingBackgroundWork.size === 0) return;
+			await Promise.allSettled([...this.pendingBackgroundWork]);
+		}
+		if (this.pendingBackgroundWork.size === 0) return;
+		omError(`[OM:settled] background work still pending after ${maxDrainRounds} drain rounds; giving up waiting`);
+	}
+	/**
 	* Acquire a lock for the given key, execute the callback, then release.
 	* If a lock is already held, waits for it to be released before acquiring.
 	*/
@@ -24256,6 +26561,7 @@ var ObservationalMemory = class ObservationalMemory {
 		this.hooks = config.hooks;
 		this.mastra = config.mastra;
 		this.memory = config.memory;
+		this.curationCadence = config.curationCadence;
 		const resolveModel = (model, defaultModel) => model === "default" ? defaultModel : model;
 		const observationModel = resolveModel(config.model, OBSERVATIONAL_MEMORY_DEFAULTS.observation.model) ?? resolveModel(config.observation?.model, OBSERVATIONAL_MEMORY_DEFAULTS.observation.model) ?? resolveModel(config.reflection?.model, OBSERVATIONAL_MEMORY_DEFAULTS.observation.model) ?? OBSERVATIONAL_MEMORY_DEFAULTS.observation.model;
 		const reflectionModel = resolveModel(config.model, OBSERVATIONAL_MEMORY_DEFAULTS.reflection.model) ?? resolveModel(config.reflection?.model, OBSERVATIONAL_MEMORY_DEFAULTS.reflection.model) ?? resolveModel(config.observation?.model, OBSERVATIONAL_MEMORY_DEFAULTS.reflection.model) ?? OBSERVATIONAL_MEMORY_DEFAULTS.reflection.model;
@@ -24351,7 +26657,8 @@ var ObservationalMemory = class ObservationalMemory {
 			getCompressionStartLevel: (rc) => this.getCompressionStartLevel(rc),
 			resolveModel: (inputTokens) => this.resolveReflectionModel(inputTokens),
 			mastra: config.mastra,
-			memory: this.memory
+			memory: this.memory,
+			onReflectionCommitted: config.onReflectionCommitted
 		});
 		this.validateBufferConfig();
 		omDebug(`[OM:init] new ObservationalMemory instance created — scope=${this.scope}, messageTokens=${JSON.stringify(this.observationConfig.messageTokens)}, obsAsyncEnabled=${this.buffering.isAsyncObservationEnabled()}, bufferTokens=${this.observationConfig.bufferTokens}, bufferActivation=${this.observationConfig.bufferActivation}, blockAfter=${this.observationConfig.blockAfter}, reflectionTokens=${this.reflectionConfig.observationTokens}, refAsyncEnabled=${this.buffering.isAsyncReflectionEnabled()}, refAsyncActivation=${this.reflectionConfig.bufferActivation}, refBlockAfter=${this.reflectionConfig.blockAfter}`);
@@ -25223,7 +27530,7 @@ ${formattedMessages}
 		if (!this.buffering.isAsyncObservationEnabled()) return false;
 		const lockKey = this.buffering.getLockKey(opts.threadId, opts.resourceId);
 		const shouldTrigger = this.buffering.shouldTriggerAsyncObservation(opts.pendingTokens, lockKey, opts.record, this.storage, opts.threshold);
-		if (shouldTrigger) this.startAsyncBufferedObservation(opts.record, opts.threadId, opts.unobservedMessages, lockKey, opts.writer, opts.unbufferedPendingTokens, opts.requestContext);
+		if (shouldTrigger) this.trackBackgroundWork(this.startAsyncBufferedObservation(opts.record, opts.threadId, opts.unobservedMessages, lockKey, opts.writer, opts.unbufferedPendingTokens, opts.requestContext));
 		return shouldTrigger;
 	}
 	isMessageList(value) {
@@ -25825,6 +28132,7 @@ ${formattedMessages}
 				writer,
 				agent: opts.agent,
 				sendSignal: opts.sendSignal,
+				sendStateSignal: opts.sendStateSignal,
 				requestContext,
 				currentModel: opts.currentModel,
 				observabilityContext
@@ -26169,6 +28477,8 @@ ${formattedMessages}
 					messageList: opts.messageList,
 					reflectionHooks,
 					agent: opts.agent,
+					sendSignal: opts.sendSignal,
+					sendStateSignal: opts.sendStateSignal,
 					requestContext,
 					writer: opts.writer,
 					observabilityContext: opts.observabilityContext
@@ -26189,6 +28499,9 @@ ${formattedMessages}
 		});
 		const record = await this.getOrCreateRecord(threadId, resourceId);
 		const reflected = record.generationCount > generationBefore && generationBefore >= 0;
+		if (observed) this.maybeTriggerCadenceCuration(threadId, resourceId, record, requestContext).catch((error) => {
+			omDebug(`[OM:observe] cadence curation failed: ${error instanceof Error ? error.message : String(error)}`);
+		});
 		return {
 			observed,
 			reflected,
@@ -26196,6 +28509,31 @@ ${formattedMessages}
 		};
 	}
 	/**
+	* Count committed observation runs on the sync observe path and run the curator every
+	* `curationCadence` runs. The counter is persisted at `record.config.subconscious.observationRuns`
+	* (the OM record's config jsonb, deep-merged; threshold resolution only reads `_overrides`, so the
+	* sibling key is inert). Concurrent commits can miscount — the curator run is advisory, and the
+	* curation cursor is the real serializer. The async-buffer lane bypasses observe(); deployments
+	* that gate on this cadence (factory's resource scope) disable async buffering.
+	*/
+	async maybeTriggerCadenceCuration(threadId, resourceId, record, requestContext) {
+		const cadence = this.curationCadence;
+		const memory = this.memory;
+		if (!cadence || cadence < 1 || !memory) return;
+		const runs = ((record.config ?? {}).subconscious?.observationRuns ?? 0) + 1;
+		const fire = runs >= cadence;
+		await this.storage.updateObservationalMemoryConfig({
+			id: record.id,
+			config: { subconscious: { observationRuns: fire ? 0 : runs } }
+		});
+		if (!fire) return;
+		omDebug(`[OM:observe] cadence curation outcome=${(await memory.runCuration({
+			threadId,
+			resourceId: resourceId ?? threadId,
+			requestContext
+		})).outcome} thread=${threadId}`);
+	}
+	/**
 	* Manually trigger reflection with optional guidance prompt.
 	*
 	* @example
@@ -26213,6 +28551,18 @@ ${formattedMessages}
 			record,
 			usage: void 0
 		};
+		if (record.isReflecting) {
+			if (isOpActiveInProcess(record.id, "reflecting")) {
+				omDebug(`[OM:reflect] isReflecting=true and active in this process, skipping`);
+				return {
+					reflected: false,
+					record,
+					usage: void 0
+				};
+			}
+			omDebug(`[OM:reflect] isReflecting=true but NOT active in this process — stale flag from dead process, clearing`);
+			await this.storage.setReflectingFlag(record.id, false);
+		}
 		await this.storage.setReflectingFlag(record.id, true);
 		registerOp(record.id, "reflecting");
 		const hooks = this.composeHooks(void 0, {
@@ -26398,6 +28748,8 @@ ${formattedMessages}
 			resourceId: opts.resourceId,
 			messageList: opts.messageList,
 			agent: opts.agent,
+			sendSignal: opts.sendSignal,
+			sendStateSignal: opts.sendStateSignal,
 			observabilityContext: opts.observabilityContext,
 			hooks: opts.hooks
 		});
@@ -26624,6 +28976,7 @@ var ObservationalMemoryProcessor = class {
 				});
 				this.turn.writer = writer;
 				this.turn.sendSignal = args.sendSignal;
+				this.turn.sendStateSignal = args.sendStateSignal;
 				this.turn.agent = args.agent;
 				this.turn.requestContext = requestContext;
 				await this.turn.start(this.memory);
@@ -26768,6 +29121,7 @@ function getObservationsAsOf(activeObservations, asOf) {
 //#region src/processors/observational-memory/index.ts
 var observational_memory_exports = /* @__PURE__ */ __exportAll({
 	Extractor: () => Extractor,
+	KnowledgeSemanticIndexCoordinator: () => KnowledgeSemanticIndexCoordinator,
 	ModelByInputTokens: () => ModelByInputTokens,
 	OBSERVATIONAL_MEMORY_DEFAULTS: () => OBSERVATIONAL_MEMORY_DEFAULTS,
 	OBSERVATION_CONTEXT_INSTRUCTIONS: () => OBSERVATION_CONTEXT_INSTRUCTIONS,
@@ -26776,10 +29130,16 @@ var observational_memory_exports = /* @__PURE__ */ __exportAll({
 	OBSERVER_SYSTEM_PROMPT: () => OBSERVER_SYSTEM_PROMPT,
 	ObservationalMemory: () => ObservationalMemory,
 	ObservationalMemoryProcessor: () => ObservationalMemoryProcessor,
+	SUBCONSCIOUS_ACTIVITY_STATE_ID: () => SUBCONSCIOUS_ACTIVITY_STATE_ID,
+	StaleKnowledgeSemanticIndexError: () => StaleKnowledgeSemanticIndexError,
+	Subconscious: () => Subconscious,
+	SubconsciousCaptureExtractor: () => SubconsciousCaptureExtractor,
+	SubconsciousRemindExtractor: () => SubconsciousRemindExtractor,
 	TokenCounter: () => TokenCounter,
 	WorkingMemoryExtractor: () => WorkingMemoryExtractor,
 	buildObserverPrompt: () => buildObserverPrompt,
 	buildObserverSystemPrompt: () => buildObserverSystemPrompt,
+	buildSubconsciousActivitySnapshot: () => buildSubconsciousActivitySnapshot,
 	combineObservationGroupRanges: () => combineObservationGroupRanges,
 	deriveObservationGroupProvenance: () => deriveObservationGroupProvenance,
 	extractCurrentTask: () => extractCurrentTask,
@@ -26791,10 +29151,13 @@ var observational_memory_exports = /* @__PURE__ */ __exportAll({
 	parseAnchorId: () => parseAnchorId,
 	parseObservationGroups: () => parseObservationGroups,
 	parseObserverOutput: () => parseObserverOutput,
+	publishSubconsciousActivity: () => publishSubconsciousActivity,
 	reconcileObservationGroupsFromReflection: () => reconcileObservationGroupsFromReflection,
 	renderObservationGroupsForReflection: () => renderObservationGroupsForReflection,
+	renderSubconsciousActivity: () => renderSubconsciousActivity,
 	stripEphemeralAnchorIds: () => stripEphemeralAnchorIds,
 	stripObservationGroups: () => stripObservationGroups,
+	subconsciousCaptureSchema: () => subconsciousCaptureSchema,
 	summarizeConversation: () => summarizeConversation,
 	wrapInObservationGroup: () => wrapInObservationGroup
 });
@@ -27037,10 +29400,11 @@ const DEFAULT_EMBEDDING_CACHE_MAX_SIZE = 1e3;
 * Concrete implementation of MastraMemory that adds support for thread configuration
 * and message injection.
 */
-var Memory = class extends _mastra_core_memory.MastraMemory {
+var Memory = class Memory extends _mastra_core_memory.MastraMemory {
 	_omEngine;
 	_omEngineInstance;
 	_mastraInstance;
+	_knowledgeSemanticIndex;
 	/**
 	* Every vector cleanup that deleteThread or deleteMessages started in the background.
 	* Callers do not wait for the cleanup, so this handle is the only join point.
@@ -27053,6 +29417,25 @@ var Memory = class extends _mastra_core_memory.MastraMemory {
 	trackVectorCleanup(cleanup) {
 		this.pendingVectorCleanup = Promise.allSettled([this.pendingVectorCleanup, cleanup]).then(() => void 0);
 	}
+	/**
+	* Resolve once all background work this Memory started has finished: observational-memory
+	* cycles (buffered observation and reflection, including the nested agent runs they spawn)
+	* and vector cleanup from `deleteThread` / `deleteMessages`.
+	*
+	* Callers that own the storage connection should await this before closing it, otherwise
+	* background statements can race the close.
+	*
+	* ```ts
+	* await agent.generate('hello', { memory: { thread, resource } });
+	* await memory.settled();
+	* await store.close();
+	* ```
+	*/
+	async settled() {
+		await this.pendingVectorCleanup;
+		await (this._omEngine ? await this._omEngine : this._omEngineInstance)?.settled();
+		await this.pendingVectorCleanup;
+	}
 	/** The shared ObservationalMemory engine. Lazily created on first access. */
 	get omEngine() {
 		if (!this._omEngine) this._omEngine = this._initOMEngine().then((engine) => {
@@ -27069,7 +29452,60 @@ var Memory = class extends _mastra_core_memory.MastraMemory {
 		else this._omEngine?.then((engine) => engine?.__registerMastra(mastra));
 	}
 	getMergedThreadConfig(config) {
-		return this.applyManagedWorkingMemoryDefaults(super.getMergedThreadConfig(config));
+		const merged = super.getMergedThreadConfig(config);
+		return this.applyManagedWorkingMemoryDefaults(this.applySubconsciousDefaults(merged));
+	}
+	applySubconsciousDefaults(config) {
+		const omConfig = normalizeObservationalMemoryConfig(config.observationalMemory);
+		if (!omConfig?.experimental_subconscious) return config;
+		if (!(omConfig.experimental_subconscious instanceof Subconscious)) throw new Error("observationalMemory.experimental_subconscious must be a Subconscious instance.");
+		const observation = omConfig.observation ?? {};
+		const extract = observation.extract ?? [];
+		const existingSlugs = new Set(extract.map((extractor) => extractor.slug));
+		const subconsciousExtractors = omConfig.experimental_subconscious.createObservationExtractors(observation.model ?? omConfig.model).filter((extractor) => !existingSlugs.has(extractor.slug));
+		return {
+			...config,
+			observationalMemory: {
+				...omConfig,
+				observation: {
+					...observation,
+					extract: [...extract, ...subconsciousExtractors]
+				}
+			}
+		};
+	}
+	/** Threads with a curation currently in flight in this process; guards same-process double-fire only. */
+	_curationsInFlight = /* @__PURE__ */ new Set();
+	/**
+	* Run the subconscious curator directly over the pending fact worklist, without a reflection.
+	* Cross-process serialization is the curation cursor's job; a lost race wastes one advisory run.
+	*
+	* Outcomes: `ran` (curator executed), `no-op` (empty worklist and no prompt, or no curate agent
+	* configured), `skipped` (a curation for this thread is already in flight in this process), and
+	* `no-model` (no per-agent, observational memory, or main-agent model could be resolved).
+	*/
+	async runCuration(options) {
+		const omConfig = normalizeObservationalMemoryConfig(this.threadConfig.observationalMemory);
+		const subconscious = omConfig?.experimental_subconscious;
+		if (!omConfig || !(subconscious instanceof Subconscious)) return { outcome: "no-op" };
+		if (this._curationsInFlight.has(options.threadId)) return { outcome: "skipped" };
+		this._curationsInFlight.add(options.threadId);
+		try {
+			return { outcome: await createCuratorHandler(this, subconscious.resolved, new Memory({
+				storage: this.storage,
+				options: { observationalMemory: false }
+			}), { omModel: omConfig.observation?.model ?? omConfig.model })({
+				parentThreadId: options.threadId,
+				resourceId: options.resourceId,
+				observations: options.prompt ?? "",
+				requestContext: options.requestContext
+			}) === "ran" ? "ran" : "no-op" };
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("requires the main agent to resolve its model")) return { outcome: "no-model" };
+			throw error;
+		} finally {
+			this._curationsInFlight.delete(options.threadId);
+		}
 	}
 	applyManagedWorkingMemoryDefaults(config) {
 		const omConfig = normalizeObservationalMemoryConfig(config.observationalMemory);
@@ -27113,6 +29549,28 @@ var Memory = class extends _mastra_core_memory.MastraMemory {
 			if (!this.vector) throw new Error("`retrieval: { vector: true }` requires a vector store. Pass a `vector` option to your Memory instance.");
 			if (!this.embedder) throw new Error("`retrieval: { vector: true }` requires an embedder. Pass an `embedder` option to your Memory instance.");
 		}
+		if (omConfig?.experimental_subconscious) {
+			if (!this.vector) throw new Error("Subconscious semantic knowledge requires a vector store. Pass a `vector` option to Memory.");
+			if (!this.embedder) throw new Error("Subconscious semantic knowledge requires an embedder. Pass an `embedder` option to Memory.");
+		}
+	}
+	async getKnowledgeStore() {
+		const store = await this.storage.getStore("knowledge");
+		if (!store) throw new Error(`Knowledge storage domain is not available on ${this.storage.constructor.name}`);
+		return store;
+	}
+	async getKnowledgeSemanticIndex() {
+		if (!this.vector || !this.embedder) throw new Error("Subconscious semantic knowledge requires both a vector store and an embedder.");
+		this._knowledgeSemanticIndex ??= this.getKnowledgeStore().then((knowledge) => new KnowledgeSemanticIndexCoordinator({
+			knowledge,
+			vector: this.vector,
+			embedder: this.embedder,
+			embedderOptions: this.embedderOptions
+		}));
+		return this._knowledgeSemanticIndex;
+	}
+	async drainKnowledgeSemanticIndex(scope) {
+		return (await this.getKnowledgeSemanticIndex()).drain(scope);
 	}
 	/**
 	* Gets the memory storage domain, throwing if not available.
@@ -27881,6 +30339,7 @@ ${workingMemory}`;
 		if (!_mastra_core_features.coreFeatures.has("observationalMemory")) throw new Error("Observational memory is enabled but the installed version of @mastra/core does not support it. Please upgrade @mastra/core to a version that includes observational memory support.");
 		if (omConfig.observation?.bufferTokens !== false && !_mastra_core_features.coreFeatures.has("asyncBuffering")) throw new Error("Observational memory async buffering is enabled by default but the installed version of @mastra/core does not support it. Either upgrade @mastra/core, @mastra/memory, and your storage adapter (@mastra/libsql, @mastra/pg, @mastra/mongodb, or @mastra/convex) to the latest version, or explicitly disable async buffering by setting `observation: { bufferTokens: false }` in your observationalMemory config.");
 		if (!_mastra_core_features.coreFeatures.has("request-response-id-rotation")) throw new Error("Observational memory requires @mastra/core support for request-response-id-rotation. Please bump @mastra/core to a newer version.");
+		if (omConfig.experimental_subconscious) await this.getKnowledgeStore();
 		const { ObservationalMemory: OMClass } = await Promise.resolve().then(() => observational_memory_exports);
 		const onIndexObservations = this.hasRetrievalSearch(omConfig.retrieval) ? async (observation) => {
 			await this.indexObservation(observation);
@@ -27894,9 +30353,21 @@ ${workingMemory}`;
 			activateOnProviderChange: omConfig.activateOnProviderChange,
 			shareTokenBudget: omConfig.shareTokenBudget,
 			model: omConfig.model,
+			curationCadence: omConfig.experimental_subconscious instanceof Subconscious ? omConfig.experimental_subconscious.resolved.curationCadence : void 0,
 			mastra: this._mastraInstance,
 			onIndexObservations,
 			hooks: omConfig.hooks,
+			onReflectionCommitted: omConfig.experimental_subconscious instanceof Subconscious ? (() => {
+				const resolved = omConfig.experimental_subconscious.resolved;
+				const omModel = omConfig.observation?.model ?? omConfig.model;
+				return composeReflectionAgentHandlers([createCuratorHandler(this, resolved, new Memory({
+					storage: this.storage,
+					options: { observationalMemory: false }
+				}), { omModel }), createLearnerHandler(this, resolved, new Memory({
+					storage: this.storage,
+					options: { observationalMemory: false }
+				}), { omModel })]);
+			})() : void 0,
 			observation: omConfig.observation ? {
 				model: omConfig.observation.model,
 				messageTokens: omConfig.observation.messageTokens,
@@ -28286,6 +30757,7 @@ Notes:
 			retrievalScope: typeof omConfig.retrieval === "object" ? omConfig.retrieval.scope ?? "resource" : "resource",
 			searchEnabled: this.hasRetrievalSearch(omConfig.retrieval)
 		});
+		if (omConfig?.experimental_subconscious instanceof Subconscious && omConfig.experimental_subconscious.resolved.tools) Object.assign(tools, createKnowledgeTools(this));
 		return tools;
 	}
 	/**
@@ -28766,6 +31238,8 @@ Notes:
 		if (om) processors.push(om);
 		const wm = await this.createWorkingMemoryStateProcessor(configuredProcessors, context);
 		if (wm) processors.push(wm);
+		const pins = await this.createPinnedStateProcessor(configuredProcessors, context);
+		if (pins) processors.push(pins);
 		return processors;
 	}
 	/**
@@ -28813,6 +31287,21 @@ Notes:
 		if (configuredProcessors.some((p) => !("workflow" in p) && p.id === WORKING_MEMORY_STATE_PROCESSOR_ID)) return null;
 		return new WorkingMemoryStateProcessor(this, runtimeMemory?.memoryConfig);
 	}
+	/**
+	* Creates a PinnedStateProcessor when Subconscious pins are enabled on the
+	* merged thread config. The gate is the validated `resolved.pins` on the
+	* Subconscious instance, never the raw user object. Returns null when pins
+	* are off or the processor is already present in the user's configured
+	* processors.
+	*/
+	async createPinnedStateProcessor(configuredProcessors = [], context) {
+		const runtimeMemory = context?.get("MastraMemory");
+		const subconscious = normalizeObservationalMemoryConfig(this.getMergedThreadConfig(runtimeMemory?.memoryConfig).observationalMemory)?.experimental_subconscious;
+		if (!(subconscious instanceof Subconscious) || subconscious.resolved.pins === false) return null;
+		const { PinnedStateProcessor, SUBCONSCIOUS_PINS_STATE_ID } = await Promise.resolve().then(() => subconscious_exports);
+		if (configuredProcessors.some((p) => !("workflow" in p) && p.id === SUBCONSCIOUS_PINS_STATE_ID)) return null;
+		return new PinnedStateProcessor({ getKnowledgeStore: () => this.storage.getStore("knowledge") });
+	}
 };
 //#endregion
 Object.defineProperty(exports, "Extractor", {
@@ -28821,6 +31310,12 @@ Object.defineProperty(exports, "Extractor", {
 		return Extractor;
 	}
 });
+Object.defineProperty(exports, "KnowledgeSemanticIndexCoordinator", {
+	enumerable: true,
+	get: function() {
+		return KnowledgeSemanticIndexCoordinator;
+	}
+});
 Object.defineProperty(exports, "Memory", {
 	enumerable: true,
 	get: function() {
@@ -28875,12 +31370,42 @@ Object.defineProperty(exports, "ObservationalMemoryProcessor", {
 		return ObservationalMemoryProcessor;
 	}
 });
+Object.defineProperty(exports, "SUBCONSCIOUS_ACTIVITY_STATE_ID", {
+	enumerable: true,
+	get: function() {
+		return SUBCONSCIOUS_ACTIVITY_STATE_ID;
+	}
+});
 Object.defineProperty(exports, "SUMMARIZE_THREAD_DEFAULTS", {
 	enumerable: true,
 	get: function() {
 		return SUMMARIZE_THREAD_DEFAULTS;
 	}
 });
+Object.defineProperty(exports, "StaleKnowledgeSemanticIndexError", {
+	enumerable: true,
+	get: function() {
+		return StaleKnowledgeSemanticIndexError;
+	}
+});
+Object.defineProperty(exports, "Subconscious", {
+	enumerable: true,
+	get: function() {
+		return Subconscious;
+	}
+});
+Object.defineProperty(exports, "SubconsciousCaptureExtractor", {
+	enumerable: true,
+	get: function() {
+		return SubconsciousCaptureExtractor;
+	}
+});
+Object.defineProperty(exports, "SubconsciousRemindExtractor", {
+	enumerable: true,
+	get: function() {
+		return SubconsciousRemindExtractor;
+	}
+});
 Object.defineProperty(exports, "TokenCounter", {
 	enumerable: true,
 	get: function() {
@@ -28923,6 +31448,12 @@ Object.defineProperty(exports, "buildObserverSystemPrompt", {
 		return buildObserverSystemPrompt;
 	}
 });
+Object.defineProperty(exports, "buildSubconsciousActivitySnapshot", {
+	enumerable: true,
+	get: function() {
+		return buildSubconsciousActivitySnapshot;
+	}
+});
 Object.defineProperty(exports, "combineObservationGroupRanges", {
 	enumerable: true,
 	get: function() {
@@ -29007,6 +31538,12 @@ Object.defineProperty(exports, "parseObserverOutput", {
 		return parseObserverOutput;
 	}
 });
+Object.defineProperty(exports, "publishSubconsciousActivity", {
+	enumerable: true,
+	get: function() {
+		return publishSubconsciousActivity;
+	}
+});
 Object.defineProperty(exports, "reconcileObservationGroupsFromReflection", {
 	enumerable: true,
 	get: function() {
@@ -29025,6 +31562,12 @@ Object.defineProperty(exports, "renderObservationGroupsForReflection", {
 		return renderObservationGroupsForReflection;
 	}
 });
+Object.defineProperty(exports, "renderSubconsciousActivity", {
+	enumerable: true,
+	get: function() {
+		return renderSubconsciousActivity;
+	}
+});
 Object.defineProperty(exports, "stripEphemeralAnchorIds", {
 	enumerable: true,
 	get: function() {
@@ -29037,6 +31580,12 @@ Object.defineProperty(exports, "stripObservationGroups", {
 		return stripObservationGroups;
 	}
 });
+Object.defineProperty(exports, "subconsciousCaptureSchema", {
+	enumerable: true,
+	get: function() {
+		return subconsciousCaptureSchema;
+	}
+});
 Object.defineProperty(exports, "summarizeConversation", {
 	enumerable: true,
 	get: function() {
@@ -29050,4 +31599,4 @@ Object.defineProperty(exports, "wrapInObservationGroup", {
 	}
 });
 
-//# sourceMappingURL=src-_7ADtEwc.cjs.map
+//# sourceMappingURL=src-Ik0ksTOt.cjs.map