@mastra/server 1.60.0-alpha.8 → 1.60.0

package/dist/{dist-CpxQhZED.js → dist-Cw-T1gX6.js}

@@ -1,8 +1,8 @@
-import { i as __toESM$1, t as __commonJSMin$1 } from "./rolldown-runtime-DuvcJU0W.js";
+import { o as __toESM$1, t as __commonJSMin$1 } from "./rolldown-runtime-maW3aOIk.js";
 import { n as standardSchemaToJSONSchema, r as toStandardSchema$1, t as isStandardSchemaWithJSON$1 } from "./schema-Bv9OdW1f-DLSJSqQv.js";
 import "./schema-CGeYTFwm.js";
-import { t as require_sync } from "./sync-djJ8Lmds.js";
-import { openai } from "./dist-DyBO3IVt.js";
+import { t as require_sync } from "./sync-BG15Yae1.js";
+import { openai } from "./dist-bAFqx06T.js";
 import { createRequire } from "module";
 import * as z4 from "zod/v4";
 import { z } from "zod/v4";
@@ -17,19 +17,19 @@ import { createTool } from "@mastra/core/tools";
 import { inspect, promisify } from "util";
 import { createHash, randomBytes, randomUUID } from "crypto";
 import { generateEmptyFromSchema } from "@mastra/core/utils";
-import { InMemoryStore } from "@mastra/core/storage";
+import { InMemoryStore, assertKnowledgeScopeWithinCeiling, canonicalizeKnowledgeScope, createKnowledgeNodeCursor, expandKnowledgeScope, isKnowledgeScopeVisible, knowledgeScopeKey } from "@mastra/core/storage";
 import { coreFeatures } from "@mastra/core/features";
 import { EntityType, SpanType, createObservabilityContext, getOrCreateSpan } from "@mastra/core/observability";
 import { MASTRA_THREAD_ID_KEY, RequestContext } from "@mastra/core/request-context";
 import { MessageHistory } from "@mastra/core/processors";
 import { createStep, createWorkflow } from "@mastra/core/workflows";
 import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "path";
 import { channel, tracingChannel } from "diagnostics_channel";
 import { AsyncLocalStorage } from "async_hooks";
 import { exec, execFile, spawn } from "child_process";
 import { copyFile, mkdir, mkdtemp, readFile, readdir, rm, stat, writeFile } from "fs/promises";
-import { tmpdir } from "os";
 //#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/async-mutex/0.5.0/4b32f2ae13cd0d7acb694455f7c2810d59202098580506b1730c21c7ab02798f/node_modules/async-mutex/index.mjs
 const E_CANCELED = /* @__PURE__ */ new Error("request for lock canceled");
 var __awaiter$2 = function(thisArg, _arguments, P, generator) {
@@ -4693,7 +4693,7 @@ function splitLines(text) {
 	return result;
 }
 //#endregion
-//#region ../memory/dist/src-BKRU-0Fx.js
+//#region ../memory/dist/src-aTfbkxBl.js
 var __defProp$3 = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
 	let target = {};
@@ -19240,6 +19240,2388 @@ createIdGenerator$3({
 	prefix: "aiobj",
 	size: 24
 });
+const BUILT_IN_SLUGS = /* @__PURE__ */ new Set([
+	"current-task",
+	"suggested-response",
+	"thread-title"
+]);
+const EXTRACTED_VALUES_TAG = "extracted-values";
+const RESERVED_XML_TAGS = /* @__PURE__ */ new Set([
+	"observations",
+	"observation",
+	EXTRACTED_VALUES_TAG,
+	"thread",
+	"message",
+	"messages",
+	"conversation",
+	"history",
+	"system",
+	"user",
+	"assistant",
+	"tool",
+	...BUILT_IN_SLUGS
+]);
+const BUILT_IN_EXTRACTOR_SLUGS = [...BUILT_IN_SLUGS];
+function isBuiltInExtractorSlug(slug) {
+	return BUILT_IN_SLUGS.has(slug);
+}
+function slugifyExtractorName(name) {
+	let normalized = "";
+	let previousWasSeparator = false;
+	for (const char of name.trim().toLowerCase()) {
+		const code = char.charCodeAt(0);
+		if (code >= 97 && code <= 122 || code >= 48 && code <= 57) {
+			normalized += char;
+			previousWasSeparator = false;
+			continue;
+		}
+		if (char === "'" || char === "\"" || char === "`") continue;
+		if (!previousWasSeparator && normalized.length > 0) {
+			normalized += "-";
+			previousWasSeparator = true;
+		}
+	}
+	return normalized.endsWith("-") ? normalized.slice(0, -1) : normalized;
+}
+function assertValidSlug(slug, name) {
+	if (!slug) throw new Error(`Extractor name "${name}" must produce a non-empty slug.`);
+	const first = slug.charCodeAt(0);
+	const last = slug.charCodeAt(slug.length - 1);
+	const startsWithLetter = first >= 97 && first <= 122;
+	const endsWithLetterOrNumber = last >= 97 && last <= 122 || last >= 48 && last <= 57;
+	const hasOnlySlugCharacters = [...slug].every((char) => {
+		const code = char.charCodeAt(0);
+		return code >= 97 && code <= 122 || code >= 48 && code <= 57 || char === "-";
+	});
+	if (!startsWithLetter || !endsWithLetterOrNumber || !hasOnlySlugCharacters) throw new Error(`Extractor name "${name}" produced invalid slug "${slug}".`);
+}
+var Extractor = class Extractor {
+	name;
+	slug;
+	instructions;
+	schema;
+	mode;
+	includePreviousExtraction;
+	metadataKeyPath;
+	onExtracted;
+	retryStructuredExtractionOnEmptyObject;
+	/** @internal */
+	internal;
+	instructionsConfig;
+	schemaConfig;
+	constructor(config, internal = false) {
+		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.schemaConfig = config.schema;
+		this.instructions = instructions ?? "";
+		this.schema = isHook ? z$2.unknown() : typeof config.schema === "function" ? z$2.string() : config.schema ?? z$2.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;
+		return new Extractor({
+			name: this.name,
+			instructions,
+			...schema ? { schema } : {},
+			includePreviousExtraction: this.includePreviousExtraction,
+			metadataKeyPath: this.metadataKeyPath,
+			onExtracted: this.onExtracted,
+			retryStructuredExtractionOnEmptyObject: this.retryStructuredExtractionOnEmptyObject
+		}, this.internal);
+	}
+};
+async function resolveExtractors(extractors, context) {
+	return Promise.all(extractors.map((extractor) => extractor.resolve(context)));
+}
+function validateExtractorList(extractors) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const extractor of extractors) {
+		assertValidSlug(extractor.slug, extractor.name);
+		if (!extractor.internal && RESERVED_XML_TAGS.has(extractor.slug)) throw new Error(`Extractor slug "${extractor.slug}" is reserved by Observational Memory.`);
+		const previous = seen.get(extractor.slug);
+		if (previous) throw new Error(`Duplicate extractor slug "${extractor.slug}" from "${previous}" and "${extractor.name}".`);
+		seen.set(extractor.slug, extractor.name);
+	}
+	return [...extractors];
+}
+function isJsonLike(value) {
+	return /^(?:[\[{"-]|\d|true\b|false\b|null\b)/.test(value.trim());
+}
+function candidateValues(raw) {
+	const trimmed = raw.trim();
+	const candidates = [];
+	const add = (value) => {
+		if (!candidates.some((candidate) => Object.is(candidate, value))) candidates.push(value);
+	};
+	if (isJsonLike(trimmed)) try {
+		add(JSON.parse(trimmed));
+	} catch {}
+	add(trimmed);
+	if (!isJsonLike(trimmed)) try {
+		add(JSON.parse(trimmed));
+	} catch {}
+	return candidates;
+}
+function parseExtractorValue(extractor, raw) {
+	const failures = [];
+	for (const candidate of candidateValues(raw)) {
+		const parsed = extractor.schema.safeParse(candidate);
+		if (parsed.success) return parsed.data;
+		failures.push(parsed.error.message);
+	}
+	throw new Error(`Extractor "${extractor.slug}" output did not match its schema: ${failures[0] ?? "invalid value"}`);
+}
+function parseExtractedValuesObject(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed || trimmed.startsWith("Write only the extracted values JSON object here.")) return;
+	const parsed = JSON.parse(trimmed);
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`${EXTRACTED_VALUES_TAG} must contain a JSON object.`);
+	return parsed;
+}
+function parseExtractedValues(output, extractors) {
+	const values = {};
+	const failures = [];
+	const inlineExtractors = extractors.filter((extractor) => extractor.mode === "inline");
+	const regex = new RegExp(`<${EXTRACTED_VALUES_TAG}>([\\s\\S]*?)<\\/${EXTRACTED_VALUES_TAG}>`, "gi");
+	const matches = [...output.matchAll(regex)];
+	for (const match of matches) try {
+		const extractedValues = parseExtractedValuesObject(match[1] ?? "");
+		if (!extractedValues) continue;
+		for (const extractor of inlineExtractors) {
+			if (!Object.prototype.hasOwnProperty.call(extractedValues, extractor.slug)) continue;
+			const rawValue = extractedValues[extractor.slug];
+			if (rawValue === void 0 || rawValue === null || rawValue === "") continue;
+			const parsed = extractor.schema.safeParse(rawValue);
+			if (parsed.success) values[extractor.slug] = parsed.data;
+			else failures.push({
+				slug: extractor.slug,
+				error: parsed.error.message
+			});
+		}
+	} catch (error) {
+		failures.push({
+			slug: EXTRACTED_VALUES_TAG,
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+	for (const extractor of inlineExtractors) {
+		if (Object.prototype.hasOwnProperty.call(values, extractor.slug)) continue;
+		const tagRegex = new RegExp(`<${extractor.slug}>([\\s\\S]*?)<\\/${extractor.slug}>`, "gi");
+		const rawValue = [...output.matchAll(tagRegex)].at(-1)?.[1]?.trim();
+		if (!rawValue) continue;
+		try {
+			values[extractor.slug] = parseExtractorValue(extractor, rawValue);
+		} catch (error) {
+			failures.push({
+				slug: extractor.slug,
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	return {
+		values,
+		failures
+	};
+}
+function stripExtractorSections(output, extractors) {
+	const inlineExtractors = extractors.filter((extractor) => extractor.mode === "inline");
+	let stripped = output.replace(new RegExp(`[ \\t]*<${EXTRACTED_VALUES_TAG}>[\\s\\S]*?<\\/${EXTRACTED_VALUES_TAG}>\\s*`, "gi"), "");
+	for (const extractor of inlineExtractors) stripped = stripped.replace(new RegExp(`[ \\t]*<${extractor.slug}>[\\s\\S]*?<\\/${extractor.slug}>\\s*`, "gi"), "");
+	return stripped;
+}
+function buildExtractorOutputSections(extractors) {
+	const inlineExtractors = extractors.filter((extractor) => extractor.mode === "inline");
+	if (inlineExtractors.length === 0) return "";
+	return `Additional optional XML sections:\nIf the observations include information relevant to any of these tags, output that tag after <observations> and include the relevant information.\n${inlineExtractors.map((extractor) => `<${extractor.slug}>
+${extractor.instructions}
+Include this section when the observations contain relevant information for <${extractor.slug}>. Write only that information inside the tag.
+</${extractor.slug}>`).join("\n\n")}`;
+}
+function renderPriorValue(value) {
+	return typeof value === "string" ? value : JSON.stringify(value);
+}
+function buildExtractorPriorLines(extractors, priorExtractedValues) {
+	if (!priorExtractedValues) return [];
+	const lines = [];
+	for (const extractor of extractors) {
+		if (!extractor.includePreviousExtraction) continue;
+		const value = priorExtractedValues[extractor.slug];
+		if (value === void 0 || value === null || value === "") continue;
+		lines.push(`<${extractor.slug}>\n${renderPriorValue(value)}\n</${extractor.slug}>`);
+	}
+	return lines;
+}
+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 || !isKnowledgeScopeVisible(node.scope, scope)) return {
+			id: event.recordId,
+			type: "node"
+		};
+		return {
+			id: node.id,
+			name: node.name,
+			type: "node"
+		};
+	}
+	const record = await store.getKnowledge({
+		id: event.recordId,
+		includeDeleted: true
+	});
+	const node = record ? await store.getNode(record.node) : void 0;
+	if (!node || !isKnowledgeScopeVisible(node.scope, scope)) return {
+		id: event.recordId,
+		type: "node"
+	};
+	return {
+		id: node.id,
+		name: node.name,
+		type: "node"
+	};
+}
+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 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: createHash("sha256").update(contents).digest("hex"),
+		tagName: "state",
+		attributes: { id: SUBCONSCIOUS_ACTIVITY_STATE_ID },
+		metadata: { origin: "subconscious" },
+		contents,
+		value: snapshot
+	});
+}
+async function publishSubconsciousActivity(input) {
+	if (!input.sendStateSignal) return void 0;
+	const snapshot = await buildSubconsciousActivitySnapshot(input);
+	const contents = renderSubconsciousActivity(snapshot);
+	const cacheKey = 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;
+}
+/** 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 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;
+}
+/**
+* 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 totalCharacters(pins) {
+	return pins.reduce((sum, pin) => sum + pin.text.length, 0);
+}
+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 = expandKnowledgeScope(options.scope, effective);
+	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: 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 (!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: 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: 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: 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: expandKnowledgeScope(options.scope, options.defaultScope)
+				});
+			}
+		})
+	};
+}
+/**
+* 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;
+}
+const CAPTURE_GUIDANCE_PAGE = "capture-guidance";
+const MAX_CAPTURE_GUIDANCE_LENGTH = 4e3;
+const SCOPE_ORDER = {
+	org: 0,
+	resource: 1,
+	thread: 2
+};
+const subconsciousCaptureSchema = z$2.object({ nodes: z$2.array(z$2.object({
+	name: z$2.string().trim().min(1),
+	kind: z$2.string().trim().min(1),
+	scope: z$2.enum([
+		"org",
+		"resource",
+		"thread"
+	]).optional(),
+	records: z$2.array(z$2.object({
+		text: z$2.string().trim().min(1),
+		scope: z$2.enum([
+			"org",
+			"resource",
+			"thread"
+		]).optional(),
+		when: z$2.string().trim().min(1).optional(),
+		reason: z$2.string().trim().min(1)
+	}))
+})) });
+const subconsciousCapturePinningSchema = z$2.object({ nodes: z$2.array(z$2.object({
+	name: z$2.string().trim().min(1),
+	kind: z$2.string().trim().min(1),
+	scope: z$2.enum([
+		"org",
+		"resource",
+		"thread"
+	]).optional(),
+	records: z$2.array(z$2.object({
+		text: z$2.string().trim().min(1),
+		scope: z$2.enum([
+			"org",
+			"resource",
+			"thread"
+		]).optional(),
+		when: z$2.string().trim().min(1).optional(),
+		reason: z$2.string().trim().min(1),
+		pin: z$2.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 = 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: 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 = 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;
+				}
+			}
+		});
+	}
+};
+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 || !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 || !isKnowledgeScopeVisible(record.scope, scope)) return null;
+		const node = await store.getNode(record.node);
+		const parentVisible = Boolean(node && !node.mergedInto && 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: 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: 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 || !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: 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 || !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 ? createKnowledgeNodeCursor(visibleNodes.at(-1), {
+						namePrefix,
+						kind,
+						hasContent
+					}) : void 0
+				};
+			}
+		})
+	};
+}
+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);
+	}
+};
+/**
+* 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 });
+}
+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 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 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;
+				}
+			}
+		});
+	}
+};
+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 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 }
+			}
+		};
+	}
+};
+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 = expandKnowledgeScope(options.scope, level ?? options.defaultScope);
+	assertKnowledgeScopeWithinCeiling(scope, options.maxScope);
+	return scope;
+}
+function requireVisible(scope, options, label) {
+	if (!isKnowledgeScopeVisible(scope, options.scope)) throw new Error(`${label} is outside the curator's visible scope.`);
+}
+function createKnowledgeWriteTools(memory, options) {
+	return {
+		knowledge_append: 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: expandKnowledgeScope(options.scope, options.defaultScope)
+				});
+			}
+		}),
+		knowledge_remove: 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: 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: 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: 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);
+				assertKnowledgeScopeWithinCeiling(scope, record.maxScope);
+				return store.rescopeKnowledge({
+					id: record.id,
+					scope
+				});
+			}
+		}),
+		knowledge_write_node_content: 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 && knowledgeScopeKey(resolvedNode.scope) === 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
+				});
+			}
+		})
+	};
+}
+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 = isKnowledgeScopeVisible(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;
+	}
+};
+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.`);
+	}
+};
+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 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 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
+			}) : {}
+		}
+	});
+}
+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 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 = 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 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 = 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 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
+			})
+		}
+	});
+}
 var constants_exports = /* @__PURE__ */ __exportAll({
 	OBSERVATIONAL_MEMORY_DEFAULTS: () => OBSERVATIONAL_MEMORY_DEFAULTS,
 	OBSERVATION_CONTEXT_INSTRUCTIONS: () => OBSERVATION_CONTEXT_INSTRUCTIONS,
@@ -19394,232 +21776,6 @@ Observation groups with range IDs and your recall tool allows you to think back
 ### Additional recall guidance
 ${custom}`;
 }
-const BUILT_IN_SLUGS = /* @__PURE__ */ new Set([
-	"current-task",
-	"suggested-response",
-	"thread-title"
-]);
-const EXTRACTED_VALUES_TAG = "extracted-values";
-const RESERVED_XML_TAGS = /* @__PURE__ */ new Set([
-	"observations",
-	"observation",
-	EXTRACTED_VALUES_TAG,
-	"thread",
-	"message",
-	"messages",
-	"conversation",
-	"history",
-	"system",
-	"user",
-	"assistant",
-	"tool",
-	...BUILT_IN_SLUGS
-]);
-const BUILT_IN_EXTRACTOR_SLUGS = [...BUILT_IN_SLUGS];
-function isBuiltInExtractorSlug(slug) {
-	return BUILT_IN_SLUGS.has(slug);
-}
-function slugifyExtractorName(name) {
-	let normalized = "";
-	let previousWasSeparator = false;
-	for (const char of name.trim().toLowerCase()) {
-		const code = char.charCodeAt(0);
-		if (code >= 97 && code <= 122 || code >= 48 && code <= 57) {
-			normalized += char;
-			previousWasSeparator = false;
-			continue;
-		}
-		if (char === "'" || char === "\"" || char === "`") continue;
-		if (!previousWasSeparator && normalized.length > 0) {
-			normalized += "-";
-			previousWasSeparator = true;
-		}
-	}
-	return normalized.endsWith("-") ? normalized.slice(0, -1) : normalized;
-}
-function assertValidSlug(slug, name) {
-	if (!slug) throw new Error(`Extractor name "${name}" must produce a non-empty slug.`);
-	const first = slug.charCodeAt(0);
-	const last = slug.charCodeAt(slug.length - 1);
-	const startsWithLetter = first >= 97 && first <= 122;
-	const endsWithLetterOrNumber = last >= 97 && last <= 122 || last >= 48 && last <= 57;
-	const hasOnlySlugCharacters = [...slug].every((char) => {
-		const code = char.charCodeAt(0);
-		return code >= 97 && code <= 122 || code >= 48 && code <= 57 || char === "-";
-	});
-	if (!startsWithLetter || !endsWithLetterOrNumber || !hasOnlySlugCharacters) throw new Error(`Extractor name "${name}" produced invalid slug "${slug}".`);
-}
-var Extractor = class Extractor {
-	name;
-	slug;
-	instructions;
-	schema;
-	mode;
-	includePreviousExtraction;
-	metadataKeyPath;
-	onExtracted;
-	retryStructuredExtractionOnEmptyObject;
-	/** @internal */
-	internal;
-	instructionsConfig;
-	schemaConfig;
-	constructor(config, internal = false) {
-		const name = config.name.trim();
-		const instructions = typeof config.instructions === "string" ? config.instructions.trim() : void 0;
-		const slug = slugifyExtractorName(name);
-		if (!name) throw new Error("Extractor name is required.");
-		if (instructions !== void 0 && !instructions) throw new Error(`Extractor "${name}" must include instructions.`);
-		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.schemaConfig = config.schema;
-		this.instructions = instructions ?? "";
-		this.schema = typeof config.schema === "function" ? z$2.string() : config.schema ?? z$2.string();
-		this.mode = internal || !config.schema ? "inline" : "structured";
-		this.includePreviousExtraction = config.includePreviousExtraction ?? true;
-		this.metadataKeyPath = config.metadataKeyPath ?? `extracted.${slug}`;
-		this.onExtracted = config.onExtracted;
-		this.retryStructuredExtractionOnEmptyObject = config.retryStructuredExtractionOnEmptyObject ?? false;
-		this.internal = internal;
-	}
-	async resolve(context) {
-		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;
-		return new Extractor({
-			name: this.name,
-			instructions,
-			...schema ? { schema } : {},
-			includePreviousExtraction: this.includePreviousExtraction,
-			metadataKeyPath: this.metadataKeyPath,
-			onExtracted: this.onExtracted,
-			retryStructuredExtractionOnEmptyObject: this.retryStructuredExtractionOnEmptyObject
-		}, this.internal);
-	}
-};
-async function resolveExtractors(extractors, context) {
-	return Promise.all(extractors.map((extractor) => extractor.resolve(context)));
-}
-function validateExtractorList(extractors) {
-	const seen = /* @__PURE__ */ new Map();
-	for (const extractor of extractors) {
-		assertValidSlug(extractor.slug, extractor.name);
-		if (!extractor.internal && RESERVED_XML_TAGS.has(extractor.slug)) throw new Error(`Extractor slug "${extractor.slug}" is reserved by Observational Memory.`);
-		const previous = seen.get(extractor.slug);
-		if (previous) throw new Error(`Duplicate extractor slug "${extractor.slug}" from "${previous}" and "${extractor.name}".`);
-		seen.set(extractor.slug, extractor.name);
-	}
-	return [...extractors];
-}
-function isJsonLike(value) {
-	return /^(?:[\[{"-]|\d|true\b|false\b|null\b)/.test(value.trim());
-}
-function candidateValues(raw) {
-	const trimmed = raw.trim();
-	const candidates = [];
-	const add = (value) => {
-		if (!candidates.some((candidate) => Object.is(candidate, value))) candidates.push(value);
-	};
-	if (isJsonLike(trimmed)) try {
-		add(JSON.parse(trimmed));
-	} catch {}
-	add(trimmed);
-	if (!isJsonLike(trimmed)) try {
-		add(JSON.parse(trimmed));
-	} catch {}
-	return candidates;
-}
-function parseExtractorValue(extractor, raw) {
-	const failures = [];
-	for (const candidate of candidateValues(raw)) {
-		const parsed = extractor.schema.safeParse(candidate);
-		if (parsed.success) return parsed.data;
-		failures.push(parsed.error.message);
-	}
-	throw new Error(`Extractor "${extractor.slug}" output did not match its schema: ${failures[0] ?? "invalid value"}`);
-}
-function parseExtractedValuesObject(raw) {
-	const trimmed = raw.trim();
-	if (!trimmed || trimmed.startsWith("Write only the extracted values JSON object here.")) return;
-	const parsed = JSON.parse(trimmed);
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`${EXTRACTED_VALUES_TAG} must contain a JSON object.`);
-	return parsed;
-}
-function parseExtractedValues(output, extractors) {
-	const values = {};
-	const failures = [];
-	const inlineExtractors = extractors.filter((extractor) => extractor.mode === "inline");
-	const regex = new RegExp(`<${EXTRACTED_VALUES_TAG}>([\\s\\S]*?)<\\/${EXTRACTED_VALUES_TAG}>`, "gi");
-	const matches = [...output.matchAll(regex)];
-	for (const match of matches) try {
-		const extractedValues = parseExtractedValuesObject(match[1] ?? "");
-		if (!extractedValues) continue;
-		for (const extractor of inlineExtractors) {
-			if (!Object.prototype.hasOwnProperty.call(extractedValues, extractor.slug)) continue;
-			const rawValue = extractedValues[extractor.slug];
-			if (rawValue === void 0 || rawValue === null || rawValue === "") continue;
-			const parsed = extractor.schema.safeParse(rawValue);
-			if (parsed.success) values[extractor.slug] = parsed.data;
-			else failures.push({
-				slug: extractor.slug,
-				error: parsed.error.message
-			});
-		}
-	} catch (error) {
-		failures.push({
-			slug: EXTRACTED_VALUES_TAG,
-			error: error instanceof Error ? error.message : String(error)
-		});
-	}
-	for (const extractor of inlineExtractors) {
-		if (Object.prototype.hasOwnProperty.call(values, extractor.slug)) continue;
-		const tagRegex = new RegExp(`<${extractor.slug}>([\\s\\S]*?)<\\/${extractor.slug}>`, "gi");
-		const rawValue = [...output.matchAll(tagRegex)].at(-1)?.[1]?.trim();
-		if (!rawValue) continue;
-		try {
-			values[extractor.slug] = parseExtractorValue(extractor, rawValue);
-		} catch (error) {
-			failures.push({
-				slug: extractor.slug,
-				error: error instanceof Error ? error.message : String(error)
-			});
-		}
-	}
-	return {
-		values,
-		failures
-	};
-}
-function stripExtractorSections(output, extractors) {
-	const inlineExtractors = extractors.filter((extractor) => extractor.mode === "inline");
-	let stripped = output.replace(new RegExp(`[ \\t]*<${EXTRACTED_VALUES_TAG}>[\\s\\S]*?<\\/${EXTRACTED_VALUES_TAG}>\\s*`, "gi"), "");
-	for (const extractor of inlineExtractors) stripped = stripped.replace(new RegExp(`[ \\t]*<${extractor.slug}>[\\s\\S]*?<\\/${extractor.slug}>\\s*`, "gi"), "");
-	return stripped;
-}
-function buildExtractorOutputSections(extractors) {
-	const inlineExtractors = extractors.filter((extractor) => extractor.mode === "inline");
-	if (inlineExtractors.length === 0) return "";
-	return `Additional optional XML sections:\nIf the observations include information relevant to any of these tags, output that tag after <observations> and include the relevant information.\n${inlineExtractors.map((extractor) => `<${extractor.slug}>
-${extractor.instructions}
-Include this section when the observations contain relevant information for <${extractor.slug}>. Write only that information inside the tag.
-</${extractor.slug}>`).join("\n\n")}`;
-}
-function renderPriorValue(value) {
-	return typeof value === "string" ? value : JSON.stringify(value);
-}
-function buildExtractorPriorLines(extractors, priorExtractedValues) {
-	if (!priorExtractedValues) return [];
-	const lines = [];
-	for (const extractor of extractors) {
-		if (!extractor.includePreviousExtraction) continue;
-		const value = priorExtractedValues[extractor.slug];
-		if (value === void 0 || value === null || value === "") continue;
-		lines.push(`<${extractor.slug}>\n${renderPriorValue(value)}\n</${extractor.slug}>`);
-	}
-	return lines;
-}
 const BUILT_IN_METADATA_FIELDS = {
 	"current-task": {
 		metadataField: "currentTask",
@@ -19741,9 +21897,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;
 		}
@@ -19754,14 +21912,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 {
@@ -19772,7 +21935,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)
@@ -20821,11 +22985,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) {
@@ -20886,7 +23050,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: []
 	};
@@ -20900,7 +23064,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
 		};
 	});
@@ -21356,6 +23520,52 @@ function detectDegenerateRepetition(text) {
 	return false;
 }
 /**
+* Build a single-line diagnostic description of output flagged by
+* {@link detectDegenerateRepetition}. Used when logging or surfacing a
+* degenerate-output failure so the discarded model output can be inspected —
+* without it there is no way to tell a real repetition loop apart from a
+* detector false-positive on legitimately repetitive content.
+*
+* Reuses the detector's sampling parameters (200-char windows, ~50 samples)
+* so the reported duplicate ratio and most-repeated window match what
+* triggered the detection. Snippets are JSON-escaped so the result stays on
+* one line.
+*/
+function describeDegenerateOutput(text, snippetChars = 400) {
+	const windowSize = 200;
+	const step = Math.max(1, Math.floor(text.length / 50));
+	const seen = /* @__PURE__ */ new Map();
+	let duplicateWindows = 0;
+	let totalWindows = 0;
+	for (let i = 0; i + windowSize <= text.length; i += step) {
+		const window = text.slice(i, i + windowSize);
+		totalWindows++;
+		const count = (seen.get(window) ?? 0) + 1;
+		seen.set(window, count);
+		if (count > 1) duplicateWindows++;
+	}
+	let topWindow = "";
+	let topCount = 0;
+	for (const [window, count] of seen) if (count > topCount) {
+		topCount = count;
+		topWindow = window;
+	}
+	let longestLine = 0;
+	for (const line of text.split("\n")) if (line.length > longestLine) longestLine = line.length;
+	const duplicateRatio = totalWindows > 0 ? (duplicateWindows / totalWindows).toFixed(2) : "n/a";
+	const parts = [
+		`length=${text.length}`,
+		`sampledWindows=${totalWindows}`,
+		`duplicateRatio=${duplicateRatio}`,
+		`longestLine=${longestLine}`,
+		`topWindowCount=${topCount}`
+	];
+	if (topCount > 1) parts.push(`topWindow=${JSON.stringify(topWindow)}`);
+	parts.push(`head=${JSON.stringify(text.slice(0, snippetChars))}`);
+	if (text.length > snippetChars * 2) parts.push(`tail=${JSON.stringify(text.slice(-snippetChars))}`);
+	return parts.join(" ");
+}
+/**
 * Check if observations contain a Current Task section.
 * Supports both XML format and legacy markdown format.
 */
@@ -21441,17 +23651,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$5(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;
@@ -21462,13 +23672,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;
 }
 /**
@@ -21486,14 +23696,14 @@ function isTransientLLMError(error) {
 	if (isAbortError$5(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;
 		}
@@ -21750,13 +23960,13 @@ var ObserverRunner = class {
 		let parsed = parseObserverOutput(result.text, activeExtractors);
 		let retriedDueToDegenerate = false;
 		if (parsed.degenerate) {
-			omDebug(`[OM:callObserver] degenerate repetition detected, retrying once`);
+			omDebug(`[OM:callObserver] degenerate repetition detected, retrying once. ${describeDegenerateOutput(result.text, 2e3)}`);
 			result = await doGenerate();
 			parsed = parseObserverOutput(result.text, activeExtractors);
 			retriedDueToDegenerate = true;
 			if (parsed.degenerate) {
-				omDebug(`[OM:callObserver] degenerate repetition on retry, failing`);
-				throw new Error("Observer produced degenerate output after retry");
+				omDebug(`[OM:callObserver] degenerate repetition on retry, failing. ${describeDegenerateOutput(result.text, 2e3)}`);
+				throw new Error(`Observer produced degenerate output after retry. ${describeDegenerateOutput(result.text)}`);
 			}
 		}
 		const structuredExtraction = await extractStructuredValues({
@@ -21900,13 +24110,13 @@ var ObserverRunner = class {
 		let parsed = parseMultiThreadObserverOutput(result.text, activeExtractors);
 		let retriedDueToDegenerate = false;
 		if (parsed.degenerate) {
-			omDebug(`[OM:callMultiThreadObserver] degenerate repetition detected, retrying once`);
+			omDebug(`[OM:callMultiThreadObserver] degenerate repetition detected, retrying once. ${describeDegenerateOutput(result.text, 2e3)}`);
 			result = await doGenerate();
 			parsed = parseMultiThreadObserverOutput(result.text, activeExtractors);
 			retriedDueToDegenerate = true;
 			if (parsed.degenerate) {
-				omDebug(`[OM:callMultiThreadObserver] degenerate repetition on retry, failing`);
-				throw new Error("Multi-thread observer produced degenerate output after retry");
+				omDebug(`[OM:callMultiThreadObserver] degenerate repetition on retry, failing. ${describeDegenerateOutput(result.text, 2e3)}`);
+				throw new Error(`Multi-thread observer produced degenerate output after retry. ${describeDegenerateOutput(result.text)}`);
 			}
 		}
 		const structuredExtractionByThread = /* @__PURE__ */ new Map();
@@ -22267,7 +24477,7 @@ async function resolveImageDimensionsAsync(part) {
 	const url = resolveHttpAssetUrl(getObjectValue(part, "image") ?? getObjectValue(part, "data"));
 	if (!url) return existing;
 	try {
-		const probeImageSize = (await import("./probe-image-size-mXCWYNrz.js").then((m) => /* @__PURE__ */ __toESM$1(m.default, 1))).default;
+		const probeImageSize = (await import("./probe-image-size-Tf8sNZhU.js").then((m) => /* @__PURE__ */ __toESM$1(m.default, 1))).default;
 		const probed = await probeImageSize(url, {
 			open_timeout: REMOTE_IMAGE_PROBE_TIMEOUT_MS,
 			response_timeout: REMOTE_IMAGE_PROBE_TIMEOUT_MS,
@@ -24713,38 +26923,6 @@ function createWorkingMemoryTool(config, options = {}) {
 		tool
 	};
 }
-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);
-	}
-};
 const MINUTE = 6e4;
 const HOUR = 60 * MINUTE;
 const SHORT_TTL = 5 * MINUTE;
@@ -25537,6 +27715,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
+			}
+		}];
+	});
+}
 /**
 * Get the maximum value from a threshold (simple number or range).
 */
@@ -25690,8 +27901,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);
@@ -25706,6 +27918,7 @@ var ObservationStrategy = class ObservationStrategy {
 				abortSignal,
 				mainAgent: this.opts.agent,
 				sendSignal: this.opts.sendSignal,
+				sendStateSignal: this.opts.sendStateSignal,
 				reflectionHooks,
 				requestContext,
 				observabilityContext: this.opts.observabilityContext
@@ -25991,11 +28204,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 = {
@@ -26169,11 +28387,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 {
@@ -26506,11 +28729,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({
@@ -26823,18 +29060,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;
@@ -27006,6 +29246,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
@@ -27083,6 +29326,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(). */
@@ -27096,6 +29341,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 ?? {};
@@ -27200,7 +29446,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,
@@ -27208,13 +29454,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 };
 	}
@@ -27612,6 +29859,7 @@ var ReflectorRunner = class {
 	persistMarkerToMessage;
 	getCompressionStartLevel;
 	memory;
+	onReflectionCommitted;
 	mastra;
 	constructor(opts) {
 		this.reflectionConfig = opts.reflectionConfig;
@@ -27627,6 +29875,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;
@@ -27694,6 +29943,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;
@@ -27758,7 +30009,7 @@ var ReflectorRunner = class {
 			finalProviderMetadata = result.providerMetadata ?? finalProviderMetadata;
 			parsed = parseReflectorOutput(result.text, observations, activeExtractors);
 			if (parsed.degenerate) {
-				omDebug(`[OM:callReflector] attempt #${attemptNumber}: degenerate repetition detected, treating as compression failure`);
+				omDebug(`[OM:callReflector] attempt #${attemptNumber}: degenerate repetition detected, treating as compression failure. ${describeDegenerateOutput(result.text, 2e3)}`);
 				reflectedTokens = originalTokens;
 			} else reflectedTokens = this.tokenCounter.countObservations(parsed.observations);
 			omDebug(`[OM:callReflector] attempt #${attemptNumber} parsed: reflectedTokens=${reflectedTokens}, targetThreshold=${targetThreshold}, compressionValid=${validateCompression(reflectedTokens, targetThreshold)}, parsedObsLen=${parsed.observations?.length}, degenerate=${parsed.degenerate ?? false}`);
@@ -27767,6 +30018,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,
@@ -27823,6 +30079,8 @@ var ReflectorRunner = class {
 			mainAgent,
 			memory: this.memory,
 			sendSignal,
+			writer: streamContext?.writer,
+			abortSignal,
 			requestContext
 		});
 		const extractedValues = hookedValues.values;
@@ -27978,7 +30236,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`);
@@ -27997,7 +30255,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);
@@ -28028,6 +30287,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;
@@ -28063,13 +30327,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);
@@ -28114,7 +30386,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})`);
@@ -28185,6 +30465,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,
@@ -28710,6 +31001,7 @@ var ObservationalMemory = class ObservationalMemory {
 	hasher = e();
 	mastra;
 	memory;
+	curationCadence;
 	/**
 	* Track message IDs observed during this instance's lifetime.
 	* Prevents re-observing messages when per-thread lastObservedAt cursors
@@ -28741,6 +31033,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.
 	*/
@@ -28774,6 +31099,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;
@@ -28869,7 +31195,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}`);
@@ -29741,7 +32068,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) {
@@ -30343,6 +32670,7 @@ ${formattedMessages}
 				writer,
 				agent: opts.agent,
 				sendSignal: opts.sendSignal,
+				sendStateSignal: opts.sendStateSignal,
 				requestContext,
 				currentModel: opts.currentModel,
 				observabilityContext
@@ -30687,6 +33015,8 @@ ${formattedMessages}
 					messageList: opts.messageList,
 					reflectionHooks,
 					agent: opts.agent,
+					sendSignal: opts.sendSignal,
+					sendStateSignal: opts.sendStateSignal,
 					requestContext,
 					writer: opts.writer,
 					observabilityContext: opts.observabilityContext
@@ -30707,6 +33037,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,
@@ -30714,6 +33047,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
@@ -30731,6 +33089,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, {
@@ -30916,6 +33286,8 @@ ${formattedMessages}
 			resourceId: opts.resourceId,
 			messageList: opts.messageList,
 			agent: opts.agent,
+			sendSignal: opts.sendSignal,
+			sendStateSignal: opts.sendStateSignal,
 			observabilityContext: opts.observabilityContext,
 			hooks: opts.hooks
 		});
@@ -31138,6 +33510,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);
@@ -31278,6 +33651,7 @@ function getObservationsAsOf(activeObservations, asOf) {
 }
 var observational_memory_exports = /* @__PURE__ */ __exportAll({
 	Extractor: () => Extractor,
+	KnowledgeSemanticIndexCoordinator: () => KnowledgeSemanticIndexCoordinator,
 	ModelByInputTokens: () => ModelByInputTokens,
 	OBSERVATIONAL_MEMORY_DEFAULTS: () => OBSERVATIONAL_MEMORY_DEFAULTS,
 	OBSERVATION_CONTEXT_INSTRUCTIONS: () => OBSERVATION_CONTEXT_INSTRUCTIONS,
@@ -31286,10 +33660,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,
@@ -31301,10 +33681,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
 });
@@ -31528,10 +33911,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 MastraMemory {
+var Memory = class Memory extends 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.
@@ -31544,6 +33928,25 @@ var Memory = class extends 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) => {
@@ -31560,7 +33963,60 @@ var Memory = class extends 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);
@@ -31604,6 +34060,28 @@ var Memory = class extends 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.
@@ -32372,6 +34850,7 @@ ${workingMemory}`;
 		if (!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 && !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 (!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);
@@ -32385,9 +34864,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,
@@ -32777,6 +35268,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;
 	}
 	/**
@@ -33257,6 +35749,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;
 	}
 	/**
@@ -33304,6 +35798,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
 //#region ../agent-builder/dist/index.js
@@ -34093,23 +36602,23 @@ const createModelInstance = async (provider, modelId, version = "v2") => {
 	try {
 		const providerFn = version === `v1` ? { v1: {
 			openai: async () => {
-				const { openai } = await import("./dist-DyBO3IVt.js");
+				const { openai } = await import("./dist-bAFqx06T.js");
 				return openai(modelId);
 			},
 			anthropic: async () => {
-				const { anthropic } = await import("./dist-JdnTASYe.js");
+				const { anthropic } = await import("./dist-CscF1cF8.js");
 				return anthropic(modelId);
 			},
 			groq: async () => {
-				const { groq } = await import("./dist-BD0I5lxM.js");
+				const { groq } = await import("./dist-CHJcZQdS.js");
 				return groq(modelId);
 			},
 			xai: async () => {
-				const { xai } = await import("./dist-C-9xUY65.js");
+				const { xai } = await import("./dist-Jn3uXsoB.js");
 				return xai(modelId);
 			},
 			google: async () => {
-				const { google } = await import("./dist-sUhxlnJz.js");
+				const { google } = await import("./dist-CRgxcDTg.js");
 				return google(modelId);
 			}
 		} }[version][provider] : () => new ModelRouterLanguageModel(`${provider}/${modelId}`);
@@ -43687,4 +46196,4 @@ const agentBuilderWorkflows = {
 //#endregion
 export { agentBuilderWorkflows };
 
-//# sourceMappingURL=dist-CpxQhZED.js.map
+//# sourceMappingURL=dist-Cw-T1gX6.js.map