@mastra/libsql 1.28.0 → 1.29.0-alpha.1

package/dist/index.cjs

@@ -9,7 +9,6 @@ let async_hooks = require("async_hooks");
 let _mastra_core_vector_filter = require("@mastra/core/vector/filter");
 let fs_promises = require("fs/promises");
 let _mastra_core_base = require("@mastra/core/base");
-let crypto$1 = require("crypto");
 let _mastra_core_features = require("@mastra/core/features");
 let _mastra_core_agent = require("@mastra/core/agent");
 let _mastra_core_evals = require("@mastra/core/evals");
@@ -693,7 +692,7 @@ const FILTER_OPERATORS = {
 			transformValue: () => {
 				if (Array.isArray(value)) return [JSON.stringify(value)];
 				if (typeof value === "object" && value !== null) return [JSON.stringify(value)];
-				if (typeof value === "string") return [escapeLikePattern$1(value)];
+				if (typeof value === "string") return [escapeLikePattern(value)];
 				return [value];
 			}
 		};
@@ -710,7 +709,7 @@ const parseJsonPathKey = (key) => {
 const getJsonPath = (key) => {
 	return `'$.${parseJsonPathKey(key)}'`;
 };
-function escapeLikePattern$1(str) {
+function escapeLikePattern(str) {
 	return str.replace(/([%_\\])/g, "\\$1");
 }
 function buildFilterQuery(filter) {
@@ -2645,7 +2644,8 @@ var AgentsLibSQL = class extends _mastra_core_storage.AgentsStorage {
 				"skillsFormat",
 				"durable",
 				"browser",
-				"toolProviders"
+				"toolProviders",
+				"modelList"
 			]
 		});
 		await this.#migrateToolsToJsonbFormat();
@@ -3062,8 +3062,9 @@ var AgentsLibSQL = class extends _mastra_core_storage.AgentsStorage {
 					versionNumber: input.versionNumber,
 					name: input.name ?? null,
 					description: input.description ?? null,
-					instructions: this.serializeInstructions(input.instructions),
-					model: input.model,
+					instructions: this.serializeInstructions(input.instructions ?? ""),
+					model: input.model ?? {},
+					modelList: input.modelList ?? null,
 					tools: input.tools ?? null,
 					defaultOptions: input.defaultOptions ?? null,
 					workflows: input.workflows ?? null,
@@ -3320,6 +3321,7 @@ var AgentsLibSQL = class extends _mastra_core_storage.AgentsStorage {
 			description: row.description,
 			instructions: this.deserializeInstructions(row.instructions),
 			model: this.parseJson(row.model, "model"),
+			modelList: this.parseJson(row.modelList, "modelList"),
 			tools: this.parseJson(row.tools, "tools"),
 			defaultOptions: this.parseJson(row.defaultOptions, "defaultOptions"),
 			workflows: this.parseJson(row.workflows, "workflows"),
@@ -3395,7 +3397,7 @@ function serializeJson(v) {
 	if (serialized === void 0) throw new Error("Failed to serialize background task value as JSON");
 	return serialized;
 }
-function parseJson$4(val) {
+function parseJson$3(val) {
 	if (val == null) return void 0;
 	if (typeof val === "string") try {
 		return JSON.parse(val);
@@ -3410,14 +3412,14 @@ function rowToTask(row) {
 		status: String(row.status),
 		toolName: String(row.tool_name),
 		toolCallId: String(row.tool_call_id),
-		args: parseJson$4(row.args) ?? {},
+		args: parseJson$3(row.args) ?? {},
 		agentId: String(row.agent_id),
 		threadId: row.thread_id != null ? String(row.thread_id) : void 0,
 		resourceId: row.resource_id != null ? String(row.resource_id) : void 0,
 		runId: String(row.run_id),
-		result: parseJson$4(row.result),
-		error: parseJson$4(row.error),
-		suspendPayload: parseJson$4(row.suspend_payload),
+		result: parseJson$3(row.result),
+		error: parseJson$3(row.error),
+		suspendPayload: parseJson$3(row.suspend_payload),
 		retryCount: Number(row.retry_count),
 		maxRetries: Number(row.max_retries),
 		timeoutMs: Number(row.timeout_ms),
@@ -3428,7 +3430,7 @@ function rowToTask(row) {
 		ownerId: row.ownerId != null ? String(row.ownerId) : void 0,
 		leaseExpiresAt: row.leaseExpiresAt ? new Date(String(row.leaseExpiresAt)) : void 0,
 		expiresAt: row.expiresAt ? new Date(String(row.expiresAt)) : void 0,
-		metadata: parseJson$4(row.metadata)
+		metadata: parseJson$3(row.metadata)
 	};
 }
 var BackgroundTasksLibSQL = class BackgroundTasksLibSQL extends _mastra_core_storage.BackgroundTasksStorage {
@@ -6395,10 +6397,10 @@ var FavoritesLibSQL = class extends _mastra_core_storage.FavoritesStorage {
 	}
 };
 // src/storage/domains/harness/index.ts
-const toDate$1 = (value) => new Date(value);
+const toDate = (value) => new Date(value);
 const toOptionalDate = (value) => {
 	if (value == null) return void 0;
-	return toDate$1(value);
+	return toDate(value);
 };
 function cloneJson(value) {
 	return value === void 0 ? void 0 : structuredClone(value);
@@ -6409,8 +6411,8 @@ function hydratePendingItem(item) {
 		kind: item.kind,
 		status: item.status,
 		sessionId: item.sessionId,
-		createdAt: toDate$1(item.createdAt),
-		updatedAt: toDate$1(item.updatedAt)
+		createdAt: toDate(item.createdAt),
+		updatedAt: toDate(item.updatedAt)
 	};
 	if (item.runId !== void 0) record.runId = item.runId;
 	if (item.traceId !== void 0) record.traceId = item.traceId;
@@ -6428,8 +6430,8 @@ function rowToSession(row) {
 		origin: row.origin,
 		modeId: row.modeId,
 		modelId: row.modelId,
-		createdAt: toDate$1(row.createdAt),
-		lastActivityAt: toDate$1(row.lastActivityAt)
+		createdAt: toDate(row.createdAt),
+		lastActivityAt: toDate(row.lastActivityAt)
 	};
 	if (row.parentSessionId != null) record.parentSessionId = row.parentSessionId;
 	if (row.subagentDepth != null) record.subagentDepth = row.subagentDepth;
@@ -6538,1973 +6540,1612 @@ var HarnessLibSQL = class HarnessLibSQL extends _mastra_core_storage.HarnessStor
 		})).map(rowToSession);
 	}
 };
-// ../../packages/_internal-core/dist/knowledge-compat/index.js
-const KNOWLEDGE_V2_CORE_FEATURE = "knowledge-v2";
-/** Hard cap on scope nodes returned by one `listScopeNodes` read. */
-const MAX_KNOWLEDGE_SCOPE_NODES = 1e3;
-function knowledgeScopeNodeFilterKey(input) {
-	return JSON.stringify([
-		input.withinAddress ?? null,
-		input.addresses ? [...input.addresses].sort() : null,
-		input.ids ? [...input.ids].sort() : null
-	]);
-}
-function createKnowledgeScopeNodeCursor(scope, input) {
-	return encodeURIComponent(JSON.stringify({
-		version: 1,
-		type: "scope",
-		name: scope.name,
-		id: scope.id,
-		filter: knowledgeScopeNodeFilterKey(input)
-	}));
-}
-/** Validates the page size and cursor of a `listScopeNodes` query; throws on a cursor from a different query. */
-function parseListKnowledgeScopeNodesInput(input = {}) {
-	const requested = Number.isFinite(input.limit) ? Math.trunc(input.limit) : MAX_KNOWLEDGE_SCOPE_NODES;
-	const limit = Math.min(Math.max(requested, 1), MAX_KNOWLEDGE_SCOPE_NODES);
-	if (!input.cursor) return {
-		limit,
-		after: null
-	};
-	let value;
-	try {
-		value = JSON.parse(decodeURIComponent(input.cursor));
-	} catch {
-		throw new Error("Invalid Knowledge scope node cursor.");
-	}
-	const parsed = value && typeof value === "object" ? value : {};
-	if (parsed.version !== 1 || parsed.type !== "scope" || typeof parsed.name !== "string" || typeof parsed.id !== "string" || parsed.filter !== knowledgeScopeNodeFilterKey(input)) throw new Error("Knowledge scope node cursor does not match this query.");
-	return {
-		limit,
-		after: {
-			name: parsed.name,
-			id: parsed.id
-		}
-	};
-}
-/** Builds a page from up to `limit + 1` name/id-ordered scope nodes. */
-function pageKnowledgeScopeNodes(rows, limit, input) {
-	const scopes = rows.slice(0, limit);
-	const last = scopes.at(-1);
-	return {
-		scopes,
-		nextCursor: rows.length > limit && last ? createKnowledgeScopeNodeCursor(last, input) : null
-	};
-}
-/** Clamps a requested member limit to 1–{@link MAX_KNOWLEDGE_SCOPE_MEMBERS_LIMIT}. */
-function knowledgeScopeMembersLimit(limit) {
-	if (limit === void 0 || !Number.isFinite(limit)) return 500;
-	return Math.min(Math.max(Math.trunc(limit), 1), 500);
-}
-/** Validates the page size and cursor of a `listScopeMembers` query; throws on a cursor from another scope. */
-function parseListKnowledgeScopeMembersInput(input) {
-	const limit = knowledgeScopeMembersLimit(input.limit);
-	if (!input.cursor) return {
-		limit,
-		after: null
-	};
-	let value;
-	try {
-		value = JSON.parse(decodeURIComponent(input.cursor));
-	} catch {
-		throw new Error("Invalid Knowledge scope member cursor.");
-	}
-	const parsed = value && typeof value === "object" ? value : {};
-	const updatedAt = typeof parsed.updatedAt === "string" ? new Date(parsed.updatedAt) : /* @__PURE__ */ new Date(NaN);
-	if (parsed.version !== 1 || parsed.type !== "scope-member" || parsed.scopeNodeId !== input.scopeNodeId || typeof parsed.name !== "string" || typeof parsed.id !== "string" || Number.isNaN(updatedAt.getTime())) throw new Error("Knowledge scope member cursor does not match this query.");
-	return {
-		limit,
-		after: {
-			updatedAt,
-			name: parsed.name,
-			id: parsed.id
-		}
-	};
-}
-/** Builds a page from up to `limit + 1` members in `listScopeMembers` order. */
-function pageKnowledgeScopeMembers(rows, limit, input) {
-	const members = rows.slice(0, limit);
-	const last = members.at(-1);
-	const hasMore = rows.length > limit;
-	return {
-		members,
-		hasMore,
-		nextCursor: hasMore && last ? encodeURIComponent(JSON.stringify({
-			version: 1,
-			type: "scope-member",
-			scopeNodeId: input.scopeNodeId,
-			updatedAt: last.updatedAt.toISOString(),
-			name: last.name,
-			id: last.id
-		})) : null
-	};
-}
-const TABLE_KNOWLEDGE_NODES$1 = "mastra_knowledge_nodes";
-const TABLE_KNOWLEDGE_RECORDS$1 = "mastra_knowledge_records";
-const TABLE_KNOWLEDGE_MENTIONS$1 = "mastra_knowledge_mentions";
-const TABLE_KNOWLEDGE_ACTIVITY$1 = "mastra_knowledge_activity";
-const TABLE_KNOWLEDGE_SEMANTIC_OUTBOX$1 = "mastra_knowledge_semantic_outbox";
-const TABLE_KNOWLEDGE_NODE_SCOPES = "mastra_knowledge_node_scopes";
-const TABLE_KNOWLEDGE_RECORD_SCOPES = "mastra_knowledge_record_scopes";
-const TABLE_KNOWLEDGE_SCOPE_GRANTS = "mastra_knowledge_scope_grants";
-const TABLE_KNOWLEDGE_ACCESS_STATE = "mastra_knowledge_access_state";
-const TABLE_KNOWLEDGE_SCOPE_ADDRESSES = "mastra_knowledge_scope_addresses";
-const TABLE_KNOWLEDGE_NODE_ADDRESSES = "mastra_knowledge_node_addresses";
-const TABLE_KNOWLEDGE_IMPORT_STATE = "mastra_knowledge_import_state";
-const TABLE_KNOWLEDGE_IMPORT_RUNS = "mastra_knowledge_import_runs";
-const TABLE_KNOWLEDGE_PROPOSALS = "mastra_knowledge_proposals";
 const KNOWLEDGE_TABLE_NAMES = [
-	TABLE_KNOWLEDGE_NODES$1,
-	TABLE_KNOWLEDGE_RECORDS$1,
-	TABLE_KNOWLEDGE_MENTIONS$1,
-	TABLE_KNOWLEDGE_ACTIVITY$1,
-	TABLE_KNOWLEDGE_SEMANTIC_OUTBOX$1,
-	TABLE_KNOWLEDGE_NODE_SCOPES,
-	TABLE_KNOWLEDGE_RECORD_SCOPES,
-	TABLE_KNOWLEDGE_SCOPE_GRANTS,
-	TABLE_KNOWLEDGE_ACCESS_STATE,
-	TABLE_KNOWLEDGE_SCOPE_ADDRESSES,
-	TABLE_KNOWLEDGE_NODE_ADDRESSES,
-	TABLE_KNOWLEDGE_IMPORT_STATE,
-	TABLE_KNOWLEDGE_IMPORT_RUNS,
-	TABLE_KNOWLEDGE_PROPOSALS
+	"mastra_knowledge_nodes",
+	"mastra_knowledge_records",
+	"mastra_knowledge_mentions",
+	"mastra_knowledge_activity",
+	"mastra_knowledge_semantic_outbox",
+	"mastra_knowledge_node_scopes",
+	"mastra_knowledge_record_scopes",
+	"mastra_knowledge_scope_grants",
+	"mastra_knowledge_access_state",
+	"mastra_knowledge_scope_addresses",
+	"mastra_knowledge_node_addresses",
+	"mastra_knowledge_import_state",
+	"mastra_knowledge_import_runs",
+	"mastra_knowledge_proposals"
 ];
 /** Knowledge v1 tables with no v2 equivalent; an explicit schema reset drops them. */
 const RETIRED_KNOWLEDGE_TABLE_NAMES = ["mastra_knowledge_cursors"];
-/** Tables and indexes published v1 adapters created for every app, whether or not it used Knowledge. */
-const PUBLISHED_KNOWLEDGE_V1_TABLE_NAMES = /* @__PURE__ */ new Set([
-	TABLE_KNOWLEDGE_NODES$1,
-	TABLE_KNOWLEDGE_RECORDS$1,
-	TABLE_KNOWLEDGE_MENTIONS$1,
-	TABLE_KNOWLEDGE_ACTIVITY$1,
-	TABLE_KNOWLEDGE_SEMANTIC_OUTBOX$1,
+const KNOWLEDGE_PAGES_CORE_FEATURE = "knowledge-pages";
+const TABLE_KNOWLEDGE_PAGES = "mastra_knowledge_pages";
+const TABLE_KNOWLEDGE_NOTES = "mastra_knowledge_notes";
+const TABLE_KNOWLEDGE_NOTE_STAMPS = "mastra_knowledge_note_stamps";
+/** Same name as the schema-2 table; schema 4 re-keys it to note → page. */
+const TABLE_KNOWLEDGE_PAGE_MENTIONS = "mastra_knowledge_mentions";
+const TABLE_KNOWLEDGE_PINS = "mastra_knowledge_pins";
+/** Same name as schema 2; schema 4 re-keys it to scope/page/note. */
+const TABLE_KNOWLEDGE_PAGE_ACTIVITY = "mastra_knowledge_activity";
+/** Holds `{ id: 'knowledge', schemaVersion: 4 }`, written when the schema-4 tables are created. */
+const TABLE_KNOWLEDGE_PAGES_STATE = "mastra_knowledge_access_state";
+const KNOWLEDGE_PAGES_TABLE_NAMES = [
+	TABLE_KNOWLEDGE_PAGES,
+	TABLE_KNOWLEDGE_NOTES,
+	TABLE_KNOWLEDGE_NOTE_STAMPS,
+	TABLE_KNOWLEDGE_PAGE_MENTIONS,
+	TABLE_KNOWLEDGE_PINS,
+	TABLE_KNOWLEDGE_PAGE_ACTIVITY,
+	TABLE_KNOWLEDGE_PAGES_STATE
+];
+/** Every Knowledge table any schema version created. Reset drops these and nothing else. */
+const KNOWLEDGE_RESETTABLE_TABLE_NAMES = [.../* @__PURE__ */ new Set([
+	...KNOWLEDGE_PAGES_TABLE_NAMES,
+	...KNOWLEDGE_TABLE_NAMES,
 	...RETIRED_KNOWLEDGE_TABLE_NAMES
-]);
-const PUBLISHED_KNOWLEDGE_V1_INDEX_NAMES = /* @__PURE__ */ new Set([
-	"idx_knowledge_nodes_identity",
-	"idx_knowledge_nodes_scope",
-	"idx_knowledge_records_node_latest",
-	"idx_knowledge_records_thread_latest",
-	"idx_knowledge_mentions_record",
-	"idx_knowledge_activity_latest",
-	"idx_knowledge_outbox_idempotency",
-	"idx_knowledge_outbox_claim"
-]);
-const KNOWLEDGE_V2_NODES_SCHEMA = {
-	id: {
-		type: "text",
-		nullable: false,
-		primaryKey: true
-	},
-	name: {
-		type: "text",
-		nullable: false
-	},
-	kind: {
-		type: "text",
-		nullable: true
-	},
-	isScope: {
-		type: "boolean",
-		nullable: false
-	},
-	metadata: {
-		type: "jsonb",
-		nullable: true
-	},
-	version: {
-		type: "integer",
-		nullable: false
-	},
-	createdAt: {
-		type: "timestamp",
-		nullable: false
-	},
-	updatedAt: {
-		type: "timestamp",
-		nullable: false
-	},
-	deletedAt: {
-		type: "timestamp",
-		nullable: true
-	},
-	deletedBy: {
-		type: "text",
-		nullable: true
-	},
-	type: {
-		type: "text",
-		nullable: true
-	},
-	canonicalName: {
-		type: "text",
-		nullable: true
-	},
-	content: {
-		type: "text",
-		nullable: true
-	},
-	description: {
-		type: "text",
-		nullable: true
-	},
-	scope: {
-		type: "jsonb",
-		nullable: true
-	},
-	scopeKey: {
-		type: "text",
-		nullable: true
-	},
-	mergedInto: {
-		type: "text",
-		nullable: true
-	}
-};
-const KNOWLEDGE_V2_RECORDS_SCHEMA = {
-	id: {
-		type: "text",
-		nullable: false,
-		primaryKey: true
-	},
-	node: {
-		type: "text",
-		nullable: false,
-		references: {
-			table: TABLE_KNOWLEDGE_NODES$1,
-			column: "id"
-		}
-	},
-	text: {
-		type: "text",
-		nullable: false
-	},
-	metadata: {
-		type: "jsonb",
-		nullable: true
-	},
-	version: {
-		type: "integer",
-		nullable: false
-	},
-	capturedAt: {
-		type: "timestamp",
-		nullable: false
-	},
-	updatedAt: {
-		type: "timestamp",
-		nullable: false
-	},
-	deletedAt: {
-		type: "timestamp",
-		nullable: true
-	},
-	deletedBy: {
-		type: "text",
-		nullable: true
-	},
-	scope: {
-		type: "jsonb",
-		nullable: true
-	},
-	scopeKey: {
-		type: "text",
-		nullable: true
-	},
-	sourceThreadId: {
-		type: "text",
-		nullable: true
-	},
-	when: {
-		type: "timestamp",
-		nullable: true
-	}
-};
-const KNOWLEDGE_V2_MENTIONS_SCHEMA = {
-	recordId: {
-		type: "text",
-		nullable: false,
-		references: {
-			table: TABLE_KNOWLEDGE_RECORDS$1,
-			column: "id"
-		}
-	},
-	targetNodeId: {
-		type: "text",
-		nullable: true,
-		references: {
-			table: TABLE_KNOWLEDGE_NODES$1,
-			column: "id"
-		}
-	},
-	sourceType: {
-		type: "text",
-		nullable: true
-	},
-	sourceId: {
-		type: "text",
-		nullable: true
-	}
-};
-const KNOWLEDGE_NODE_SCOPES_SCHEMA = {
-	nodeId: {
-		type: "text",
-		nullable: false,
-		references: {
-			table: TABLE_KNOWLEDGE_NODES$1,
-			column: "id"
-		}
-	},
-	scopeNodeId: {
-		type: "text",
-		nullable: false,
-		references: {
-			table: TABLE_KNOWLEDGE_NODES$1,
-			column: "id"
-		}
-	},
-	addedAt: {
-		type: "timestamp",
-		nullable: false
-	}
-};
-const KNOWLEDGE_RECORD_SCOPES_SCHEMA = {
-	recordId: {
-		type: "text",
-		nullable: false,
-		references: {
-			table: TABLE_KNOWLEDGE_RECORDS$1,
-			column: "id"
-		}
-	},
-	scopeNodeId: {
-		type: "text",
-		nullable: false,
-		references: {
-			table: TABLE_KNOWLEDGE_NODES$1,
-			column: "id"
-		}
-	},
-	addedAt: {
-		type: "timestamp",
-		nullable: false
-	}
-};
-const KNOWLEDGE_SCOPE_GRANTS_SCHEMA = {
-	scopeNodeId: {
-		type: "text",
-		nullable: false,
-		references: {
-			table: TABLE_KNOWLEDGE_NODES$1,
-			column: "id"
-		}
-	},
-	scopeRefId: {
-		type: "text",
-		nullable: false,
-		references: {
-			table: TABLE_KNOWLEDGE_NODES$1,
-			column: "id"
-		}
-	},
-	role: {
-		type: "text",
-		nullable: false
-	},
-	canSuggest: {
-		type: "boolean",
-		nullable: true
-	}
-};
-const KNOWLEDGE_ACCESS_STATE_SCHEMA = {
-	id: {
-		type: "text",
-		nullable: false,
-		primaryKey: true
-	},
-	epoch: {
-		type: "integer",
-		nullable: false
-	},
-	schemaVersion: {
-		type: "integer",
-		nullable: false
-	}
-};
-const KNOWLEDGE_SCOPE_ADDRESSES_SCHEMA = {
-	address: {
-		type: "text",
-		nullable: false,
-		primaryKey: true
-	},
-	scopeNodeId: {
-		type: "text",
-		nullable: false,
-		references: {
-			table: TABLE_KNOWLEDGE_NODES$1,
-			column: "id"
-		}
-	}
-};
-const KNOWLEDGE_NODE_ADDRESSES_SCHEMA = {
-	source: {
-		type: "text",
-		nullable: false
-	},
-	address: {
-		type: "text",
-		nullable: false
-	},
-	nodeId: {
-		type: "text",
-		nullable: false,
-		references: {
-			table: TABLE_KNOWLEDGE_NODES$1,
-			column: "id"
-		}
-	}
-};
-const KNOWLEDGE_IMPORT_STATE_SCHEMA = {
-	importerId: {
-		type: "text",
-		nullable: false
-	},
-	binding: {
-		type: "text",
-		nullable: false
-	},
-	key: {
-		type: "text",
-		nullable: false
-	},
-	value: {
-		type: "text",
-		nullable: false
-	}
-};
-const KNOWLEDGE_IMPORT_RUNS_SCHEMA = {
-	id: {
-		type: "text",
-		nullable: false,
-		primaryKey: true
-	},
-	importerId: {
-		type: "text",
-		nullable: false
-	},
-	binding: {
-		type: "text",
-		nullable: false
-	},
-	importKind: {
-		type: "text",
-		nullable: false
-	},
-	triggerKind: {
-		type: "text",
-		nullable: false
-	},
-	status: {
-		type: "text",
-		nullable: false
-	},
-	error: {
-		type: "text",
-		nullable: true
-	},
-	transcriptThreadId: {
-		type: "text",
-		nullable: true
-	},
-	traceId: {
-		type: "text",
-		nullable: true
-	},
-	queuedAt: {
-		type: "timestamp",
-		nullable: false
-	},
-	startedAt: {
-		type: "timestamp",
-		nullable: true
-	},
-	completedAt: {
-		type: "timestamp",
-		nullable: true
-	}
-};
-const KNOWLEDGE_V2_ACTIVITY_SCHEMA = {
-	id: {
-		type: "text",
-		nullable: false,
-		primaryKey: true
-	},
-	action: {
-		type: "text",
-		nullable: false
-	},
-	targetType: {
-		type: "text",
-		nullable: true
-	},
-	targetId: {
-		type: "text",
-		nullable: true
-	},
-	contextScopeId: {
-		type: "text",
-		nullable: true,
-		references: {
-			table: TABLE_KNOWLEDGE_NODES$1,
-			column: "id"
-		}
-	},
-	importRunId: {
-		type: "text",
-		nullable: true,
-		references: {
-			table: TABLE_KNOWLEDGE_IMPORT_RUNS,
-			column: "id"
-		}
-	},
-	details: {
-		type: "jsonb",
-		nullable: true
-	},
-	createdAt: {
-		type: "timestamp",
-		nullable: false
-	},
-	recordType: {
-		type: "text",
-		nullable: true
-	},
-	recordId: {
-		type: "text",
-		nullable: true
-	},
-	scope: {
-		type: "jsonb",
-		nullable: true
-	},
-	scopeKey: {
-		type: "text",
-		nullable: true
-	},
-	sourceThreadId: {
-		type: "text",
-		nullable: true
-	}
-};
-const KNOWLEDGE_PROPOSALS_SCHEMA = {
-	id: {
-		type: "text",
-		nullable: false,
-		primaryKey: true
-	},
-	targetType: {
-		type: "text",
-		nullable: false
-	},
-	targetId: {
-		type: "text",
-		nullable: false
-	},
-	action: {
-		type: "text",
-		nullable: false
-	},
-	changes: {
-		type: "jsonb",
-		nullable: false
-	},
-	reason: {
-		type: "text",
-		nullable: true
-	},
-	proposerContextScopeId: {
-		type: "text",
-		nullable: false
-	},
-	expectedVersion: {
-		type: "integer",
-		nullable: false
-	},
-	status: {
-		type: "text",
-		nullable: false
-	},
-	reviewerContextScopeId: {
-		type: "text",
-		nullable: true
-	},
-	reviewedAt: {
-		type: "timestamp",
-		nullable: true
-	},
-	createdAt: {
-		type: "timestamp",
-		nullable: false
+])];
+/** Schema-1/2 tables whose presence means the store needs a reset before schema 4 can run. */
+const LEGACY_KNOWLEDGE_TABLE_NAMES = new Set([...KNOWLEDGE_TABLE_NAMES, ...RETIRED_KNOWLEDGE_TABLE_NAMES].filter((name) => !KNOWLEDGE_PAGES_TABLE_NAMES.includes(name)));
+/**
+* Classifies what an adapter found before creating schema-4 tables. `tableNames` is every
+* `mastra_knowledge_*` table present; `schemaVersion` is the state row's version, if any.
+*/
+function inspectKnowledgePagesSchema(snapshot) {
+	const legacy = snapshot.tableNames.filter((name) => LEGACY_KNOWLEDGE_TABLE_NAMES.has(name));
+	if (legacy.length > 0) return {
+		status: "incompatible-reset-required",
+		schemaVersion: snapshot.schemaVersion ?? null,
+		reason: `found Knowledge tables from an earlier schema (${legacy.join(", ")})`
+	};
+	if (snapshot.schemaVersion === 4) return {
+		status: "compatible",
+		schemaVersion: 4
+	};
+	if (snapshot.schemaVersion === void 0) {
+		const present = snapshot.tableNames.filter((name) => KNOWLEDGE_PAGES_TABLE_NAMES.includes(name));
+		if (present.length === 0) return {
+			status: "uninitialized",
+			schemaVersion: null
+		};
+		return {
+			status: "incompatible-reset-required",
+			schemaVersion: null,
+			reason: `found Knowledge tables (${present.join(", ")}) without a schema version`
+		};
 	}
-};
-function assertKnowledgeV2CoreSupport(features) {
-	if (!features.has("knowledge-v2")) throw new Error(`Knowledge v2 requires a @mastra/core release with the "${KNOWLEDGE_V2_CORE_FEATURE}" feature. Upgrade @mastra/core to use Knowledge; other storage domains keep working on this version.`);
-}
-function resolveKnowledgeV2Core(storageModule) {
-	if (typeof storageModule !== "object" || storageModule === null) throw new Error("@mastra/core advertises Knowledge v2 without the required storage API");
-	const { assertKnowledgeDescriptionWithinBound: assertDescription, assertKnowledgeRecordTextWithinBound: assertRecordText, assertKnowledgeSchemaCompatible: assertCompatible, inspectKnowledgeSchema: inspectSchema } = storageModule;
-	if (typeof assertDescription !== "function" || typeof assertRecordText !== "function" || typeof assertCompatible !== "function" || typeof inspectSchema !== "function") throw new Error("@mastra/core advertises Knowledge v2 without the required storage API");
 	return {
-		assertKnowledgeDescriptionWithinBound: (description) => assertDescription(description),
-		assertKnowledgeRecordTextWithinBound: (text) => assertRecordText(text),
-		assertKnowledgeSchemaCompatible: (inspection) => assertCompatible(inspection),
-		inspectKnowledgeSchema: (snapshot) => inspectSchema(snapshot)
+		status: "incompatible-reset-required",
+		schemaVersion: snapshot.schemaVersion,
+		reason: `Knowledge schema version ${snapshot.schemaVersion} is not 4`
 	};
 }
-function createKnowledgeV2CoreLoader(features, loadStorageModule) {
-	let knowledgeV2Core;
+/** Schema-2 table names schema 4 reuses with a different shape. */
+const REUSED_KNOWLEDGE_TABLE_NAMES = KNOWLEDGE_TABLE_NAMES.filter((name) => KNOWLEDGE_PAGES_TABLE_NAMES.includes(name));
+/**
+* The old Knowledge tables an adapter drops on init, rows included: Knowledge before schema 4 was an
+* experimental store with no migration. Every schema-1/2-only table present is dropped. The table
+* names schema 4 reuses (mentions, activity, the state table) are dropped too, but only when an old
+* table is present and no schema-4 state row exists, so they are old-shaped. Schema-4-only tables
+* are never listed. On a schema-4 store this lists only tables an older process recreated during a
+* rolling deploy. Drop order is safe for adapters that enforce references.
+*/
+function legacyKnowledgeTablesToDrop(snapshot) {
+	const present = new Set(snapshot.tableNames);
+	const legacy = [...LEGACY_KNOWLEDGE_TABLE_NAMES].filter((name) => present.has(name));
+	if (legacy.length === 0) return [];
+	const reused = snapshot.schemaVersion === 4 ? [] : REUSED_KNOWLEDGE_TABLE_NAMES.filter((name) => present.has(name));
+	const drop = /* @__PURE__ */ new Set([...legacy, ...reused]);
+	return [...RETIRED_KNOWLEDGE_TABLE_NAMES, ...[...KNOWLEDGE_TABLE_NAMES].reverse()].filter((name) => drop.has(name));
+}
+const KNOWLEDGE_PAGES_CORE_FUNCTIONS = [
+	"assertKnowledgePageDescriptionWithinBound",
+	"assertKnowledgeNoteTextWithinBound",
+	"canonicalKnowledgeName",
+	"knowledgePositionBetween",
+	"KnowledgeMoveTooLargeError",
+	"KnowledgePageDepthError",
+	"KnowledgePageHasChildrenError",
+	"KnowledgePageKeyConflictError"
+];
+const KNOWLEDGE_PAGES_CORE_NUMBERS = [
+	"MAX_KNOWLEDGE_MOVE_PAGES",
+	"MAX_KNOWLEDGE_PAGE_DEPTH",
+	"MAX_KNOWLEDGE_PAGE_LIST_LIMIT"
+];
+function resolveKnowledgePagesCore(storageModule) {
+	const module = typeof storageModule === "object" && storageModule !== null ? storageModule : {};
+	const missing = [...KNOWLEDGE_PAGES_CORE_FUNCTIONS.filter((name) => typeof module[name] !== "function"), ...KNOWLEDGE_PAGES_CORE_NUMBERS.filter((name) => typeof module[name] !== "number")];
+	if (missing.length > 0) throw new Error(`@mastra/core advertises Knowledge pages without the required storage API (missing ${missing.join(", ")})`);
+	return module;
+}
+/** Loads core's page-store runtime once, after checking core advertises `knowledge-pages`. */
+function createKnowledgePagesCoreLoader(features, loadStorageModule) {
+	let core;
 	return async () => {
-		assertKnowledgeV2CoreSupport(features);
-		knowledgeV2Core ??= loadStorageModule().then(resolveKnowledgeV2Core).catch((error) => {
-			knowledgeV2Core = void 0;
+		if (!features.has("knowledge-pages")) throw new Error(`Knowledge requires a @mastra/core release with the "${KNOWLEDGE_PAGES_CORE_FEATURE}" feature. Upgrade @mastra/core to use Knowledge; other storage domains keep working on this version.`);
+		core ??= loadStorageModule().then(resolveKnowledgePagesCore).catch((error) => {
+			core = void 0;
 			throw error;
 		});
-		return knowledgeV2Core;
+		return core;
 	};
 }
-// src/storage/domains/knowledge/index.ts
-const loadKnowledgeV2Core = createKnowledgeV2CoreLoader(_mastra_core_features.coreFeatures, () => import("@mastra/core/storage"));
-async function assertKnowledgeDescriptionWithinBoundCompat(description) {
-	const { assertKnowledgeDescriptionWithinBound } = await loadKnowledgeV2Core();
-	assertKnowledgeDescriptionWithinBound(description);
-}
-async function assertKnowledgeRecordTextWithinBoundCompat(text) {
-	const { assertKnowledgeRecordTextWithinBound } = await loadKnowledgeV2Core();
-	assertKnowledgeRecordTextWithinBound(text);
-}
-const reconcileChains = /* @__PURE__ */ new Map();
-const unidentifiedClientReconcileKey = {};
-function withReconcileLock(key, operation) {
-	const lockKey = typeof key === "string" ? key : unidentifiedClientReconcileKey;
-	const result = (reconcileChains.get(lockKey) ?? Promise.resolve()).then(operation, operation);
-	const tail = result.then(() => void 0, () => void 0);
-	reconcileChains.set(lockKey, tail);
-	tail.finally(() => {
-		if (reconcileChains.get(lockKey) === tail) reconcileChains.delete(lockKey);
-	});
-	return result;
-}
 /**
-* Scope keys visible to a caller holding `scope`: a row is visible when its scope is a subset of the
-* caller's (companion entries such as `resource:x:uncurated` make this more than a prefix match).
-* Matching rows by `scopeKey` keeps visibility filters on an index; a caller scope has only a few
-* entries, so the list stays small.
+* Keyword-search words: the query split on whitespace, lowercased, deduplicated. A hit needs at
+* least one of them (as a case-insensitive substring); an empty list means the search returns nothing.
 */
-function visibleScopeKeys(scope) {
-	const canonical = (0, _mastra_core_storage.canonicalizeKnowledgeScope)(scope);
-	const keys = /* @__PURE__ */ new Set();
-	for (let mask = 1; mask < 1 << canonical.length; mask++) try {
-		keys.add((0, _mastra_core_storage.knowledgeScopeKey)(canonical.filter((_, index) => mask & 1 << index)));
-	} catch {}
-	return [...keys];
+function knowledgeSearchWords(query) {
+	return [...new Set(query.toLowerCase().split(/\s+/).filter(Boolean))];
 }
-const visibleSql = (keys, scopeKeyColumn = "scopeKey") => `${scopeKeyColumn} IN (${keys.map(() => "?").join(",")})`;
-function parseJson$3(value) {
-	if (typeof value === "string") return JSON.parse(value);
-	if (value instanceof Uint8Array) return JSON.parse(new TextDecoder().decode(value));
-	if (value instanceof ArrayBuffer) return JSON.parse(new TextDecoder().decode(value));
-	return value;
-}
-function toDate(value) {
-	return new Date(String(value));
-}
-function optionalDate(value) {
-	return value == null ? void 0 : toDate(value);
+/**
+* Points one matched search word earns on a page, by the best field it appears in: name, then
+* description, then body. Pages rank by how many query words they match first; these points only
+* break ties between pages that match the same number of words.
+*/
+const KNOWLEDGE_SEARCH_WEIGHTS = {
+	name: 3,
+	description: 2,
+	body: 1
+};
+/**
+* Why `key` can't be a Knowledge page key, or undefined when it can. Keys are one path segment:
+* non-empty, with no `/` (path separator), `#` (scope/path separator) or `%` (escape character).
+*/
+function knowledgePageKeyProblem(key) {
+	if (!key) return "Knowledge page key must not be empty";
+	if (/[/#%]/.test(key)) return `Knowledge page key "${key}" must not contain "/", "#" or "%"`;
 }
-function canonicalName(name) {
-	return name.trim().toLocaleLowerCase();
+// src/storage/domains/knowledge/pages.ts
+const loadPagesCore = createKnowledgePagesCoreLoader(_mastra_core_features.coreFeatures, () => import("@mastra/core/storage"));
+const assertKnowledgePageDescriptionWithinBound = async (description) => (await loadPagesCore()).assertKnowledgePageDescriptionWithinBound(description);
+const assertKnowledgeNoteTextWithinBound = async (text) => (await loadPagesCore()).assertKnowledgeNoteTextWithinBound(text);
+const KNOWLEDGE_PAGE_TABLES = {
+	pages: "mastra_knowledge_pages",
+	notes: "mastra_knowledge_notes",
+	stamps: "mastra_knowledge_note_stamps",
+	mentions: "mastra_knowledge_mentions",
+	pins: "mastra_knowledge_pins",
+	pinAudiences: "mastra_knowledge_pin_audiences",
+	activity: "mastra_knowledge_activity"
+};
+const T = KNOWLEDGE_PAGE_TABLES;
+/** DDL for the schema-4 page tables, in creation order. Every statement is idempotent. */
+const KNOWLEDGE_PAGE_DDL = [
+	`CREATE TABLE IF NOT EXISTS "mastra_knowledge_access_state" (
+    id TEXT PRIMARY KEY,
+    schemaVersion INTEGER NOT NULL
+  )`,
+	`CREATE TABLE IF NOT EXISTS "${T.pages}" (
+    id TEXT PRIMARY KEY,
+    scopeId TEXT NOT NULL,
+    isScope INTEGER NOT NULL,
+    address TEXT,
+    declaration TEXT,
+    key TEXT,
+    parentId TEXT,
+    position TEXT NOT NULL,
+    path TEXT NOT NULL,
+    depth INTEGER NOT NULL,
+    name TEXT NOT NULL,
+    canonicalName TEXT NOT NULL,
+    description TEXT,
+    body TEXT,
+    version INTEGER NOT NULL,
+    mergedInto TEXT,
+    createdBy TEXT NOT NULL,
+    updatedBy TEXT NOT NULL,
+    createdAt TEXT NOT NULL,
+    updatedAt TEXT NOT NULL,
+    deletedAt TEXT,
+    deletedBy TEXT
+  )`,
+	`CREATE UNIQUE INDEX IF NOT EXISTS idx_kpages_address ON "${T.pages}" (address) WHERE isScope = 1`,
+	`DROP INDEX IF EXISTS idx_kpages_key`,
+	`CREATE UNIQUE INDEX IF NOT EXISTS idx_kpages_parent_key ON "${T.pages}" (parentId, key) WHERE key IS NOT NULL AND deletedAt IS NULL`,
+	`CREATE INDEX IF NOT EXISTS idx_kpages_scope ON "${T.pages}" (scopeId)`,
+	`CREATE INDEX IF NOT EXISTS idx_kpages_parent ON "${T.pages}" (parentId, position, id)`,
+	`CREATE INDEX IF NOT EXISTS idx_kpages_path ON "${T.pages}" (path)`,
+	`CREATE INDEX IF NOT EXISTS idx_kpages_declaration_parent ON "${T.pages}" (declaration, parentId) WHERE isScope = 1`,
+	`CREATE INDEX IF NOT EXISTS idx_kpages_canonical ON "${T.pages}" (canonicalName)`,
+	`CREATE TABLE IF NOT EXISTS "${T.notes}" (
+    id TEXT PRIMARY KEY,
+    pageId TEXT NOT NULL,
+    text TEXT NOT NULL,
+    "when" TEXT,
+    provenance TEXT NOT NULL,
+    version INTEGER NOT NULL,
+    createdAt TEXT NOT NULL,
+    updatedAt TEXT NOT NULL,
+    deletedAt TEXT,
+    deletedBy TEXT
+  )`,
+	`CREATE INDEX IF NOT EXISTS idx_knotes_page ON "${T.notes}" (pageId, createdAt, id)`,
+	`CREATE TABLE IF NOT EXISTS "${T.stamps}" (
+    noteId TEXT NOT NULL,
+    scopeId TEXT NOT NULL,
+    PRIMARY KEY (noteId, scopeId)
+  )`,
+	`CREATE INDEX IF NOT EXISTS idx_kstamps_scope ON "${T.stamps}" (scopeId)`,
+	`CREATE TABLE IF NOT EXISTS "${T.mentions}" (
+    noteId TEXT NOT NULL,
+    pageId TEXT NOT NULL,
+    PRIMARY KEY (noteId, pageId)
+  )`,
+	`CREATE INDEX IF NOT EXISTS idx_kmentions_page ON "${T.mentions}" (pageId)`,
+	`CREATE TABLE IF NOT EXISTS "${T.pins}" (
+    id TEXT PRIMARY KEY,
+    pageId TEXT NOT NULL UNIQUE,
+    audience TEXT NOT NULL,
+    createdBy TEXT NOT NULL,
+    createdAt TEXT NOT NULL,
+    updatedAt TEXT NOT NULL
+  )`,
+	`CREATE TABLE IF NOT EXISTS "${T.pinAudiences}" (
+    pinId TEXT NOT NULL,
+    audience TEXT NOT NULL,
+    PRIMARY KEY (audience, pinId)
+  ) WITHOUT ROWID`,
+	`CREATE INDEX IF NOT EXISTS idx_kpin_audiences_pin ON "${T.pinAudiences}" (pinId)`,
+	`INSERT OR IGNORE INTO "${T.pinAudiences}" (audience, pinId) SELECT j.value, pin.id FROM "${T.pins}" pin, json_each(pin.audience) j`,
+	`CREATE TABLE IF NOT EXISTS "${T.activity}" (
+    id TEXT PRIMARY KEY,
+    action TEXT NOT NULL,
+    scopeId TEXT NOT NULL,
+    pageId TEXT NOT NULL,
+    noteId TEXT,
+    provenance TEXT NOT NULL,
+    createdAt TEXT NOT NULL
+  )`,
+	`CREATE INDEX IF NOT EXISTS idx_kactivity_page ON "${T.activity}" (pageId, id DESC)`
+];
+function str(value) {
+	return value === null || value === void 0 ? void 0 : String(value);
 }
-function escapeLikePattern(value) {
-	return value.replaceAll("=", "==").replaceAll("%", "=%").replaceAll("_", "=_");
+function date(value) {
+	return value === null || value === void 0 ? void 0 : new Date(String(value));
 }
-function nodeReferenceId(node) {
-	return typeof node === "string" ? node : node.id;
+function provenance(raw) {
+	return JSON.parse(String(raw));
 }
-function parseNode(row) {
+function toPage(row) {
 	return {
 		id: String(row.id),
-		type: "node",
+		scopeId: String(row.scopeId),
+		parentId: str(row.parentId) ?? null,
+		isScope: Number(row.isScope) === 1,
+		...row.address !== null && row.address !== void 0 ? { address: String(row.address) } : {},
+		...row.declaration !== null && row.declaration !== void 0 ? { declaration: String(row.declaration) } : {},
+		...row.key !== null && row.key !== void 0 ? { key: String(row.key) } : {},
+		position: String(row.position),
 		name: String(row.name),
-		kind: row.kind == null ? "" : String(row.kind),
-		content: row.content == null ? void 0 : String(row.content),
-		description: row.description == null ? void 0 : String(row.description),
-		isScope: row.isScope === true || row.isScope === 1 ? true : void 0,
-		scope: parseJson$3(row.scopeJson ?? row.scope),
+		...row.description !== null && row.description !== void 0 ? { description: String(row.description) } : {},
+		...row.body !== null && row.body !== void 0 ? { body: String(row.body) } : {},
 		version: Number(row.version),
-		mergedInto: row.mergedInto == null ? void 0 : String(row.mergedInto),
-		createdAt: toDate(row.createdAt),
-		updatedAt: toDate(row.updatedAt)
+		...row.mergedInto !== null && row.mergedInto !== void 0 ? { mergedInto: String(row.mergedInto) } : {},
+		createdBy: provenance(row.createdBy),
+		updatedBy: provenance(row.updatedBy),
+		createdAt: new Date(String(row.createdAt)),
+		updatedAt: new Date(String(row.updatedAt)),
+		...row.deletedAt ? { deletedAt: new Date(String(row.deletedAt)) } : {},
+		...row.deletedBy ? { deletedBy: String(row.deletedBy) } : {}
 	};
 }
-function parseKnowledge(row) {
+function toNote(row, stamps, mentions) {
+	const when = date(row.when);
 	return {
 		id: String(row.id),
-		node: String(row.node),
+		pageId: String(row.pageId),
 		text: String(row.text),
-		scope: parseJson$3(row.scopeJson ?? row.scope),
-		sourceThreadId: String(row.sourceThreadId),
-		capturedAt: toDate(row.capturedAt),
-		when: optionalDate(row.when),
-		metadata: (row.metadataJson ?? row.metadata) == null ? void 0 : parseJson$3(row.metadataJson ?? row.metadata),
-		deletedAt: optionalDate(row.deletedAt),
-		deletedBy: row.deletedBy == null ? void 0 : String(row.deletedBy)
+		...when ? { when } : {},
+		stampScopeIds: stamps,
+		mentions,
+		provenance: provenance(row.provenance),
+		version: Number(row.version),
+		createdAt: new Date(String(row.createdAt)),
+		updatedAt: new Date(String(row.updatedAt)),
+		...row.deletedAt ? { deletedAt: new Date(String(row.deletedAt)) } : {},
+		...row.deletedBy ? { deletedBy: String(row.deletedBy) } : {}
 	};
 }
-function parseOutbox(row) {
+function toPin(row) {
 	return {
 		id: String(row.id),
-		idempotencyKey: String(row.idempotencyKey),
-		documentId: String(row.documentId),
-		documentType: String(row.documentType),
-		operation: String(row.operation),
-		scope: parseJson$3(row.scopeJson ?? row.scope),
-		status: String(row.status),
-		attempts: Number(row.attempts),
-		availableAt: toDate(row.availableAt),
-		claimedAt: optionalDate(row.claimedAt),
-		claimedBy: row.claimedBy == null ? void 0 : String(row.claimedBy),
-		createdAt: toDate(row.createdAt),
-		completedAt: optionalDate(row.completedAt)
+		pageId: String(row.pageId),
+		audience: JSON.parse(String(row.audience)),
+		createdBy: String(row.createdBy),
+		createdAt: new Date(String(row.createdAt)),
+		updatedAt: new Date(String(row.updatedAt))
 	};
 }
-const KNOWLEDGE_CURATION_CURSOR_REMOVED_MESSAGE = "Knowledge curation cursors were removed: observation-time curate is the only Knowledge writer and needs no cursor.";
-const knowledgeV2TableSchemas = /* @__PURE__ */ new Map([
-	[_mastra_core_storage.TABLE_KNOWLEDGE_NODES, KNOWLEDGE_V2_NODES_SCHEMA],
-	[_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS, KNOWLEDGE_V2_RECORDS_SCHEMA],
-	[_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS, KNOWLEDGE_V2_MENTIONS_SCHEMA],
-	[_mastra_core_storage.TABLE_KNOWLEDGE_ACTIVITY, KNOWLEDGE_V2_ACTIVITY_SCHEMA],
-	[_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX, _mastra_core_storage.KNOWLEDGE_SEMANTIC_OUTBOX_SCHEMA],
-	[TABLE_KNOWLEDGE_NODE_SCOPES, KNOWLEDGE_NODE_SCOPES_SCHEMA],
-	[TABLE_KNOWLEDGE_RECORD_SCOPES, KNOWLEDGE_RECORD_SCOPES_SCHEMA],
-	[TABLE_KNOWLEDGE_SCOPE_GRANTS, KNOWLEDGE_SCOPE_GRANTS_SCHEMA],
-	[TABLE_KNOWLEDGE_ACCESS_STATE, KNOWLEDGE_ACCESS_STATE_SCHEMA],
-	[TABLE_KNOWLEDGE_SCOPE_ADDRESSES, KNOWLEDGE_SCOPE_ADDRESSES_SCHEMA],
-	[TABLE_KNOWLEDGE_NODE_ADDRESSES, KNOWLEDGE_NODE_ADDRESSES_SCHEMA],
-	[TABLE_KNOWLEDGE_IMPORT_STATE, KNOWLEDGE_IMPORT_STATE_SCHEMA],
-	[TABLE_KNOWLEDGE_IMPORT_RUNS, KNOWLEDGE_IMPORT_RUNS_SCHEMA],
-	[TABLE_KNOWLEDGE_PROPOSALS, KNOWLEDGE_PROPOSALS_SCHEMA]
-]);
-function canonicalizeLibSQLUrl(url) {
-	if (url.includes(":memory:")) return /[?&]cache=shared(?:&|$)/.test(url) ? "file::memory:?cache=shared" : void 0;
-	if (url.startsWith("file:")) {
-		const [path$1] = url.slice(5).split("?");
-		if (url.startsWith("file://")) {
-			const parsed = new URL(url);
-			const host = parsed.hostname.toLocaleLowerCase();
-			const filePath = host && host !== "localhost" ? `//${host}${parsed.pathname}` : parsed.pathname;
-			return `file:${(0, path.resolve)(decodeURIComponent(filePath))}`;
-		}
-		return `file:${(0, path.resolve)(decodeURIComponent(path$1))}`;
-	}
+function toListedPin(row) {
+	return {
+		...toPin(row),
+		pageName: String(row.pageName)
+	};
+}
+function limitOf(limit, max) {
+	return Math.max(1, Math.min(limit ?? max, max));
+}
+function encodeCursor(value) {
+	return Buffer.from(JSON.stringify(value)).toString("base64url");
+}
+function decodeCursor(cursor, length) {
+	if (cursor === void 0) return void 0;
 	try {
-		const parsed = new URL(url);
-		const port = parsed.port || (parsed.protocol === "libsql:" || parsed.protocol === "https:" ? "443" : "80");
-		return `${parsed.protocol}//${parsed.hostname.toLocaleLowerCase()}:${port}${parsed.pathname}`;
-	} catch {
-		return url;
+		const parsed = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
+		if (Array.isArray(parsed) && parsed.length === length && parsed.every((item) => typeof item === "string")) return parsed;
+	} catch {}
+	throw new Error("Invalid Knowledge cursor");
+}
+function escapeLike(value) {
+	return value.replace(/[=%_]/g, (match) => `=${match}`);
+}
+/**
+* A string above every string that starts with `prefix`, comparing by code point (which is also
+* UTF-8 byte order, so it matches SQLite's BINARY collation). `column >= prefix AND column < bound`
+* is an exact, case-sensitive prefix match that an index range scan can serve, where
+* `substr(column, 1, length(prefix)) = prefix` cannot. When the last code point cannot be raised
+* (an empty prefix, or one made only of U+10FFFF), the bound is the prefix plus more U+10FFFF than
+* any stored column can hold.
+*/
+function prefixUpperBound(prefix) {
+	const points = Array.from(prefix);
+	while (points.length > 0) {
+		const last = points.pop().codePointAt(0);
+		if (last < 1114111) {
+			const next = last === 55295 ? 57344 : last + 1;
+			return points.join("") + String.fromCodePoint(next);
+		}
 	}
+	return prefix + "􏿿".repeat(4096);
 }
-const unidentifiedClientIsolationKey = {};
-function getLibSQLKnowledgeIsolationKey(config, client) {
-	if (config.storageIsolationKey !== void 0) return config.storageIsolationKey;
-	if (!config.url) return unidentifiedClientIsolationKey;
-	const urlKey = canonicalizeLibSQLUrl(config.url);
-	return urlKey ? `libsql:${urlKey}` : client ?? config.client ?? config;
+/** `column` starts with `prefix`, as an index-friendly range. */
+function prefixRange(column, prefix) {
+	return {
+		sql: `(${column} >= ? AND ${column} < ?)`,
+		args: [prefix, prefixUpperBound(prefix)]
+	};
 }
-var KnowledgeLibSQL = class extends _mastra_core_storage.KnowledgeStorage {
-	#client;
-	#db;
+/**
+* The readable scope page ids as a subquery. The caller's addresses, prefixes and children go in as
+* JSON arrays so a large read scope never hits a bind-parameter limit. Each kind is its own index
+* lookup (address equality, address range for a prefix, `(declaration, parentId)` for children),
+* unioned, so the cost follows the caller's reach rather than the number of scopes in the store.
+*/
+function readableScopes(read) {
+	if (read === "all") return {
+		sql: `SELECT id FROM "${T.pages}" WHERE isScope = 1`,
+		args: []
+	};
+	const parts = [];
+	const args = [];
+	if (read.addresses.length > 0) {
+		parts.push(`SELECT id FROM "${T.pages}" WHERE isScope = 1 AND address IN (SELECT value FROM json_each(?))`);
+		args.push(JSON.stringify(read.addresses));
+	}
+	if (read.prefixes.length > 0) {
+		parts.push(`SELECT sp.id FROM json_each(?) j CROSS JOIN "${T.pages}" sp ON sp.isScope = 1 AND sp.address >= json_extract(j.value, '$.lo') AND sp.address < json_extract(j.value, '$.hi') AND +sp.declaration = json_extract(j.value, '$.declaration')`);
+		args.push(JSON.stringify(read.prefixes.map((entry) => ({
+			declaration: entry.declaration,
+			lo: entry.prefix,
+			hi: prefixUpperBound(entry.prefix)
+		}))));
+	}
+	if (read.children.length > 0) {
+		parts.push(`SELECT sp.id FROM json_each(?) j CROSS JOIN "${T.pages}" sp ON sp.isScope = 1 AND sp.declaration = json_extract(j.value, '$.declaration') AND sp.parentId IS json_extract(j.value, '$.parentId')`);
+		args.push(JSON.stringify(read.children));
+	}
+	if (parts.length === 0) return {
+		sql: `SELECT id FROM "${T.pages}" WHERE 0`,
+		args: []
+	};
+	return {
+		sql: parts.join(" UNION "),
+		args
+	};
+}
+/** `alias.scopeId` is readable. */
+function pageReadable(alias, read) {
+	const scopes = readableScopes(read);
+	return {
+		sql: `${alias}.scopeId IN (${scopes.sql})`,
+		args: scopes.args
+	};
+}
+/**
+* Note `alias` is visible: its page's scope is readable, a stamp is readable, and every resolved
+* mention's page sits in a readable scope.
+*/
+function noteReadable(alias, read) {
+	const scopes = readableScopes(read);
+	return {
+		sql: `EXISTS (SELECT 1 FROM "${T.pages}" vp WHERE vp.id = ${alias}.pageId AND vp.scopeId IN (${scopes.sql}))
+      AND EXISTS (SELECT 1 FROM "${T.stamps}" vs WHERE vs.noteId = ${alias}.id AND vs.scopeId IN (${scopes.sql}))
+      AND NOT EXISTS (SELECT 1 FROM "${T.mentions}" vm JOIN "${T.pages}" vmp ON vmp.id = vm.pageId WHERE vm.noteId = ${alias}.id AND vmp.scopeId NOT IN (${scopes.sql}))`,
+		args: [
+			...scopes.args,
+			...scopes.args,
+			...scopes.args
+		]
+	};
+}
+function jsonList(values) {
+	return JSON.stringify(values);
+}
+var LibSQLKnowledgePages = class {
+	#read;
+	#transaction;
 	constructor(config) {
-		const client = resolveClient(config);
-		const storageIsolationKey = config.storageIsolationKey ?? getLibSQLKnowledgeIsolationKey(config, client);
-		super({ storageIsolationKey });
-		this.#client = client;
-		this.#db = new LibSQLDB({
-			client: this.#client,
-			maxRetries: config.maxRetries,
-			initialBackoffMs: config.initialBackoffMs
+		this.#read = config.read;
+		this.#transaction = config.transaction;
+	}
+	/** Deletes every row from the page tables (scopes, pages, notes, pins, activity). */
+	async clearAll() {
+		await this.#transaction(async (tx) => {
+			for (const table of [
+				T.activity,
+				T.pinAudiences,
+				T.pins,
+				T.mentions,
+				T.stamps,
+				T.notes,
+				T.pages
+			]) await tx.execute({
+				sql: `DELETE FROM ${table}`,
+				args: []
+			});
 		});
 	}
-	getCapabilities() {
-		return {
-			contractVersion: 2,
-			schemaVersion: 2,
-			supportsV2: true,
-			supportsSchemaInspection: true,
-			supportsExplicitReset: true
-		};
+	async #query(executor, sql, args = []) {
+		return (await executor.execute({
+			sql,
+			args
+		})).rows;
 	}
-	async inspectSchema() {
-		return this.#inspectSchema(this.#client);
+	async #pageRow(executor, id) {
+		return (await this.#query(executor, `SELECT * FROM "${T.pages}" WHERE id = ?`, [id]))[0];
 	}
-	async #inspectSchema(executor) {
-		const { inspectKnowledgeSchema } = await loadKnowledgeV2Core();
-		try {
-			const placeholders = KNOWLEDGE_TABLE_NAMES.map(() => "?").join(",");
-			const tableNames = (await executor.execute({
-				sql: `SELECT name FROM sqlite_master WHERE type = 'table' AND name IN (${placeholders})`,
-				args: [...KNOWLEDGE_TABLE_NAMES]
-			})).rows.map((row) => String(row.name));
-			if (tableNames.length === 0) return inspectKnowledgeSchema({
-				available: true,
-				tableNames
-			});
-			const missingTables = KNOWLEDGE_TABLE_NAMES.filter((table) => !tableNames.includes(table));
-			if (missingTables.length > 0) return inspectKnowledgeSchema({
-				available: true,
-				tableNames,
-				reason: `Missing Knowledge v2 tables: ${missingTables.join(", ")}`
-			});
-			for (const [table, schema] of knowledgeV2TableSchemas) {
-				const columns = await executor.execute(`PRAGMA table_info("${table}")`);
-				const actual = new Set(columns.rows.map((row) => String(row.name)));
-				const missing = Object.keys(schema).filter((column) => !actual.has(column));
-				if (missing.length > 0) return inspectKnowledgeSchema({
-					available: true,
-					tableNames,
-					reason: `Knowledge table ${table} is missing v2 columns: ${missing.join(", ")}`
-				});
-			}
-			const accessState = await executor.execute(`SELECT schemaVersion FROM "${TABLE_KNOWLEDGE_ACCESS_STATE}" WHERE id='global'`);
-			if (Number(accessState.rows[0]?.schemaVersion) !== 2) return inspectKnowledgeSchema({
-				available: true,
-				tableNames,
-				reason: "Knowledge schema version marker is missing or incompatible"
-			});
-			return inspectKnowledgeSchema({
-				available: true,
-				tableNames,
-				schemaVersion: 2
-			});
-		} catch (error) {
-			return inspectKnowledgeSchema({
-				available: false,
-				tableNames: [],
-				reason: error instanceof Error ? error.message : String(error)
-			});
-		}
+	async #livePage(executor, id) {
+		const row = await this.#pageRow(executor, id);
+		if (!row || row.deletedAt) throw new _mastra_core_storage.KnowledgeNotFoundError("page", id);
+		return row;
 	}
-	async init() {
-		await this.#transaction((tx) => this.#initializeSchema(tx));
-	}
-	async #initializeSchema(tx) {
-		const { assertKnowledgeSchemaCompatible } = await loadKnowledgeV2Core();
-		let inspection = await this.#inspectSchema(tx);
-		if (inspection.status === "incompatible-reset-required" && await this.#isPublishedV1Layout(tx)) {
-			for (const table of [...RETIRED_KNOWLEDGE_TABLE_NAMES, ...[...KNOWLEDGE_TABLE_NAMES].reverse()]) await tx.execute(`DROP TABLE IF EXISTS "${table}"`);
-			inspection = await this.#inspectSchema(tx);
-		}
-		assertKnowledgeSchemaCompatible(inspection);
-		const createTable = (input) => this.#db.createTable({
-			...input,
-			executor: tx
-		});
-		await createTable({
-			tableName: _mastra_core_storage.TABLE_KNOWLEDGE_NODES,
-			schema: KNOWLEDGE_V2_NODES_SCHEMA
-		});
-		await createTable({
-			tableName: _mastra_core_storage.TABLE_KNOWLEDGE_RECORDS,
-			schema: KNOWLEDGE_V2_RECORDS_SCHEMA
-		});
-		await createTable({
-			tableName: _mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS,
-			schema: KNOWLEDGE_V2_MENTIONS_SCHEMA,
-			compositePrimaryKey: ["recordId", "sourceId"]
-		});
-		await createTable({
-			tableName: TABLE_KNOWLEDGE_NODE_SCOPES,
-			schema: KNOWLEDGE_NODE_SCOPES_SCHEMA,
-			compositePrimaryKey: ["nodeId", "scopeNodeId"]
-		});
-		await createTable({
-			tableName: TABLE_KNOWLEDGE_RECORD_SCOPES,
-			schema: KNOWLEDGE_RECORD_SCOPES_SCHEMA,
-			compositePrimaryKey: ["recordId", "scopeNodeId"]
-		});
-		await createTable({
-			tableName: TABLE_KNOWLEDGE_SCOPE_GRANTS,
-			schema: KNOWLEDGE_SCOPE_GRANTS_SCHEMA,
-			compositePrimaryKey: ["scopeNodeId", "scopeRefId"]
-		});
-		await createTable({
-			tableName: TABLE_KNOWLEDGE_ACCESS_STATE,
-			schema: KNOWLEDGE_ACCESS_STATE_SCHEMA
-		});
-		await createTable({
-			tableName: TABLE_KNOWLEDGE_SCOPE_ADDRESSES,
-			schema: KNOWLEDGE_SCOPE_ADDRESSES_SCHEMA
-		});
-		await createTable({
-			tableName: TABLE_KNOWLEDGE_NODE_ADDRESSES,
-			schema: KNOWLEDGE_NODE_ADDRESSES_SCHEMA,
-			compositePrimaryKey: ["source", "address"]
-		});
-		await createTable({
-			tableName: TABLE_KNOWLEDGE_IMPORT_STATE,
-			schema: KNOWLEDGE_IMPORT_STATE_SCHEMA,
-			compositePrimaryKey: [
-				"importerId",
-				"binding",
-				"key"
-			]
-		});
-		await createTable({
-			tableName: TABLE_KNOWLEDGE_IMPORT_RUNS,
-			schema: KNOWLEDGE_IMPORT_RUNS_SCHEMA
-		});
-		await createTable({
-			tableName: TABLE_KNOWLEDGE_PROPOSALS,
-			schema: KNOWLEDGE_PROPOSALS_SCHEMA
-		});
-		await createTable({
-			tableName: _mastra_core_storage.TABLE_KNOWLEDGE_ACTIVITY,
-			schema: KNOWLEDGE_V2_ACTIVITY_SCHEMA
-		});
-		await createTable({
-			tableName: _mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX,
-			schema: _mastra_core_storage.KNOWLEDGE_SEMANTIC_OUTBOX_SCHEMA
-		});
-		for (const statement of [
-			`CREATE UNIQUE INDEX IF NOT EXISTS idx_knowledge_nodes_identity ON "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" (type, scopeKey, canonicalName)`,
-			`CREATE INDEX IF NOT EXISTS idx_knowledge_nodes_scope ON "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" (scopeKey, type)`,
-			`CREATE INDEX IF NOT EXISTS idx_knowledge_nodes_name ON "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" (type, canonicalName)`,
-			`CREATE INDEX IF NOT EXISTS idx_knowledge_records_node_latest ON "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" (node, id DESC)`,
-			`CREATE INDEX IF NOT EXISTS idx_knowledge_records_thread_latest ON "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" (sourceThreadId, id DESC)`,
-			`CREATE INDEX IF NOT EXISTS idx_knowledge_mentions_record ON "${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}" (recordId, sourceType, sourceId)`,
-			`CREATE INDEX IF NOT EXISTS idx_knowledge_activity_latest ON "${_mastra_core_storage.TABLE_KNOWLEDGE_ACTIVITY}" (id DESC)`,
-			`CREATE INDEX IF NOT EXISTS idx_knowledge_records_scope ON "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" (scopeKey, id)`,
-			`CREATE INDEX IF NOT EXISTS idx_knowledge_activity_scope ON "${_mastra_core_storage.TABLE_KNOWLEDGE_ACTIVITY}" (scopeKey, id DESC)`,
-			`CREATE UNIQUE INDEX IF NOT EXISTS idx_knowledge_outbox_idempotency ON "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" (idempotencyKey)`,
-			`CREATE INDEX IF NOT EXISTS idx_knowledge_outbox_claim ON "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" (status, availableAt, createdAt)`,
-			`CREATE INDEX IF NOT EXISTS idx_knowledge_node_scopes_scope ON "${TABLE_KNOWLEDGE_NODE_SCOPES}" (scopeNodeId, nodeId)`,
-			`CREATE INDEX IF NOT EXISTS idx_knowledge_record_scopes_scope ON "${TABLE_KNOWLEDGE_RECORD_SCOPES}" (scopeNodeId, recordId)`,
-			`CREATE INDEX IF NOT EXISTS idx_knowledge_scope_grants_ref ON "${TABLE_KNOWLEDGE_SCOPE_GRANTS}" (scopeRefId, scopeNodeId)`,
-			`CREATE INDEX IF NOT EXISTS idx_knowledge_node_addresses_node ON "${TABLE_KNOWLEDGE_NODE_ADDRESSES}" (nodeId)`,
-			`CREATE INDEX IF NOT EXISTS idx_knowledge_import_runs_lookup ON "${TABLE_KNOWLEDGE_IMPORT_RUNS}" (importerId, binding, queuedAt DESC)`,
-			`CREATE INDEX IF NOT EXISTS idx_knowledge_activity_import_run ON "${_mastra_core_storage.TABLE_KNOWLEDGE_ACTIVITY}" (importRunId, id DESC)`
-		]) await tx.execute(statement);
+	async #logActivity(tx, action, event, now) {
 		await tx.execute({
-			sql: `INSERT OR IGNORE INTO "${TABLE_KNOWLEDGE_ACCESS_STATE}" (id, epoch, schemaVersion) VALUES ('global', 0, ?)`,
-			args: [2]
-		});
-	}
-	/**
-	* True when the only Knowledge objects are the tables and indexes published v1 adapters created,
-	* with or without rows. Anything else (v2 tables, unknown tables, views, triggers) needs an
-	* explicit reset.
-	*/
-	async #isPublishedV1Layout(executor) {
-		const objects = await executor.execute("SELECT type, name FROM sqlite_master WHERE name LIKE 'mastra\\_knowledge\\_%' ESCAPE '\\' OR tbl_name LIKE 'mastra\\_knowledge\\_%' ESCAPE '\\' OR sql LIKE '%mastra\\_knowledge\\_%' ESCAPE '\\'");
-		for (const row of objects.rows) {
-			const type = String(row.type);
-			const name = String(row.name);
-			if (type === "table" && PUBLISHED_KNOWLEDGE_V1_TABLE_NAMES.has(name)) continue;
-			const knownIndex = PUBLISHED_KNOWLEDGE_V1_INDEX_NAMES.has(name) || name.startsWith("sqlite_autoindex_");
-			if (type !== "index" || !knownIndex) return false;
-		}
-		return true;
-	}
-	async dangerouslyClearAll() {
-		await this.#transaction(async (tx) => {
-			for (const table of [
-				TABLE_KNOWLEDGE_RECORD_SCOPES,
-				TABLE_KNOWLEDGE_NODE_SCOPES,
-				TABLE_KNOWLEDGE_SCOPE_GRANTS,
-				TABLE_KNOWLEDGE_SCOPE_ADDRESSES,
-				TABLE_KNOWLEDGE_NODE_ADDRESSES,
-				_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS,
-				TABLE_KNOWLEDGE_PROPOSALS,
-				_mastra_core_storage.TABLE_KNOWLEDGE_ACTIVITY,
-				TABLE_KNOWLEDGE_IMPORT_STATE,
-				TABLE_KNOWLEDGE_IMPORT_RUNS,
-				_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX,
-				_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS,
-				_mastra_core_storage.TABLE_KNOWLEDGE_NODES
-			]) await tx.execute(`DELETE FROM "${table}"`);
-			await tx.execute(`UPDATE "${TABLE_KNOWLEDGE_ACCESS_STATE}" SET epoch = 0 WHERE id = 'global'`);
+			sql: `INSERT INTO "${T.activity}" (id, action, scopeId, pageId, noteId, provenance, createdAt) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+			args: [
+				(0, _mastra_core_storage.createKnowledgeUlid)(),
+				action,
+				event.scopeId,
+				event.pageId,
+				event.noteId ?? null,
+				JSON.stringify(event.provenance),
+				now
+			]
 		});
 	}
-	async dangerouslyReset() {
-		await withClientWriteLock(this.#client, async () => {
-			await this.#client.batch([...RETIRED_KNOWLEDGE_TABLE_NAMES, ...[...KNOWLEDGE_TABLE_NAMES].reverse()].map((table) => ({
-				sql: `DROP TABLE IF EXISTS "${table}"`,
-				args: []
-			})), "write");
-		});
-		await this.init();
+	async #lastPosition(tx, parentId, scopesOnly) {
+		const rows = await this.#query(tx, `SELECT position FROM "${T.pages}" WHERE parentId IS ? AND isScope = ? AND deletedAt IS NULL ORDER BY position DESC, id DESC LIMIT 1`, [parentId, scopesOnly ? 1 : 0]);
+		return rows[0] ? String(rows[0].position) : void 0;
 	}
-	async reconcileStructure(plan) {
-		return withReconcileLock(this.getStorageIsolationKey(), () => this.#transaction(async (tx) => {
-			await tx.execute(`UPDATE "${TABLE_KNOWLEDGE_ACCESS_STATE}" SET epoch=epoch WHERE id='global'`);
-			const scopes = {};
-			const createdScopeIds = [];
-			const createdAddresses = /* @__PURE__ */ new Set();
-			const retrofit = plan.retrofit ?? true;
-			let structureChanged = false;
-			const deletedScopeAddresses = /* @__PURE__ */ new Set();
-			const resolveAddress = async (address) => {
-				if (scopes[address]) return scopes[address];
-				const row = (await tx.execute({
-					sql: `SELECT a.scopeNodeId,n.isScope,n.deletedAt FROM "${TABLE_KNOWLEDGE_SCOPE_ADDRESSES}" a JOIN "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" n ON n.id=a.scopeNodeId WHERE a.address=?`,
-					args: [address]
-				})).rows[0];
-				if (!row) return void 0;
-				if (!row.isScope) throw new Error(`Knowledge address ${address} does not reference a scope`);
-				if (row.deletedAt) deletedScopeAddresses.add(address);
-				scopes[address] = String(row.scopeNodeId);
-				return scopes[address];
-			};
-			for (const scope of plan.scopes) {
-				if (await resolveAddress(scope.address)) continue;
-				const id = (0, crypto$1.randomUUID)();
-				const now = (/* @__PURE__ */ new Date()).toISOString();
+	async materializeScope(input) {
+		const core = await loadPagesCore();
+		await assertKnowledgePageDescriptionWithinBound(input.description);
+		return this.#transaction(async (tx) => {
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const ensureScope = async (spec, parentId) => {
+				await assertKnowledgePageDescriptionWithinBound(spec.description);
+				const existing = (await this.#query(tx, `SELECT * FROM "${T.pages}" WHERE isScope = 1 AND address = ?`, [spec.address]))[0];
+				if (existing) return {
+					row: existing,
+					created: false
+				};
+				if (parentId !== null) await this.#livePage(tx, parentId);
+				const id = (0, _mastra_core_storage.createKnowledgeUlid)();
+				const position = core.knowledgePositionBetween(await this.#lastPosition(tx, parentId, true));
+				const who = JSON.stringify(input.provenance);
 				await tx.execute({
-					sql: `INSERT INTO "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" (id,type,name,canonicalName,kind,description,isScope,metadata,version,createdAt,updatedAt) VALUES (?,'node',?,?,?,?,TRUE,jsonb(?),1,?,?)`,
+					sql: `INSERT INTO "${T.pages}" (id, scopeId, isScope, address, declaration, parentId, position, path, depth, name, canonicalName, description, version, createdBy, updatedBy, createdAt, updatedAt) VALUES (?, ?, 1, ?, ?, ?, ?, ?, 0, ?, ?, ?, 1, ?, ?, ?, ?)`,
 					args: [
 						id,
-						scope.name,
-						canonicalName(scope.name),
-						scope.kind ?? null,
-						scope.description ?? null,
-						scope.metadata ? JSON.stringify(scope.metadata) : null,
+						id,
+						spec.address,
+						spec.declaration,
+						parentId,
+						position,
+						`/${id}/`,
+						spec.name,
+						core.canonicalKnowledgeName(spec.name),
+						spec.description ?? null,
+						who,
+						who,
 						now,
 						now
 					]
 				});
+				await this.#logActivity(tx, "scope-created", {
+					scopeId: id,
+					pageId: id,
+					provenance: input.provenance
+				}, now);
+				return {
+					row: await this.#pageRow(tx, id),
+					created: true
+				};
+			};
+			const ensured = await ensureScope(input, input.parentId ?? null);
+			let row = ensured.row;
+			const created = ensured.created;
+			const scopeId = String(row.id);
+			if (!created && input.parentId != null && str(row.parentId) === void 0) {
+				await this.#livePage(tx, input.parentId);
+				if (input.parentId === scopeId) throw new Error(`Scope ${scopeId} cannot be its own parent`);
+				let ancestor = input.parentId;
+				while (ancestor) {
+					const up = await this.#pageRow(tx, ancestor);
+					if (String(up.id) === scopeId) throw new Error(`Scope ${scopeId} cannot be linked under its own descendant`);
+					ancestor = str(up.parentId);
+				}
 				await tx.execute({
-					sql: `INSERT INTO "${TABLE_KNOWLEDGE_SCOPE_ADDRESSES}" (address,scopeNodeId) VALUES (?,?)`,
-					args: [scope.address, id]
+					sql: `UPDATE "${T.pages}" SET parentId = ?, position = ?, version = version + 1, updatedAt = ? WHERE id = ? AND parentId IS NULL`,
+					args: [
+						input.parentId,
+						core.knowledgePositionBetween(await this.#lastPosition(tx, input.parentId, true)),
+						now,
+						scopeId
+					]
 				});
-				scopes[scope.address] = id;
-				createdAddresses.add(scope.address);
-				createdScopeIds.push(id);
-				structureChanged = true;
+				row = await this.#pageRow(tx, scopeId);
 			}
-			for (const scope of plan.scopes) {
-				if (!createdAddresses.has(scope.address) && (!retrofit || deletedScopeAddresses.has(scope.address))) continue;
-				const scopeNodeId = scopes[scope.address];
-				for (const parentAddress of scope.parentAddresses ?? []) {
-					const parentId = await resolveAddress(parentAddress);
-					if (!parentId || deletedScopeAddresses.has(parentAddress)) {
-						const deletedParentId = scopes[parentAddress];
-						if ((deletedParentId ? await tx.execute({
-							sql: `SELECT 1 FROM "mastra_knowledge_node_scopes" WHERE nodeId=? AND scopeNodeId=?`,
-							args: [scopeNodeId, deletedParentId]
-						}) : void 0)?.rows.length) continue;
-						throw new Error(`Knowledge parent scope does not exist: ${parentAddress}`);
-					}
-					if ((await tx.execute({
-						sql: `SELECT 1 FROM "mastra_knowledge_node_scopes" WHERE nodeId=? AND scopeNodeId=?`,
-						args: [scopeNodeId, parentId]
-					})).rows.length) continue;
-					if ((await tx.execute({
-						sql: `SELECT n.id FROM "mastra_knowledge_node_scopes" ns JOIN "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" n ON n.id=ns.nodeId WHERE ns.scopeNodeId=? AND n.isScope AND n.canonicalName=? AND n.deletedAt IS NULL AND n.id<>? LIMIT 1`,
-						args: [
-							parentId,
-							canonicalName(scope.name),
-							scopeNodeId
-						]
-					})).rows.length) throw new Error(`Knowledge scope name ${scope.name} already exists under ${parentAddress}`);
-					const inserted = await tx.execute({
-						sql: `INSERT OR IGNORE INTO "${TABLE_KNOWLEDGE_NODE_SCOPES}" (nodeId,scopeNodeId,addedAt) VALUES (?,?,?)`,
-						args: [
-							scopeNodeId,
-							parentId,
-							(/* @__PURE__ */ new Date()).toISOString()
-						]
-					});
-					structureChanged ||= inserted.rowsAffected > 0;
-				}
-				for (const grant of scope.grants ?? []) {
-					const scopeRefId = await resolveAddress(grant.scopeRefAddress);
-					if (!scopeRefId || deletedScopeAddresses.has(grant.scopeRefAddress)) {
-						const deletedScopeRefId = scopes[grant.scopeRefAddress];
-						if ((deletedScopeRefId ? await tx.execute({
-							sql: `SELECT 1 FROM "mastra_knowledge_scope_grants" WHERE scopeNodeId=? AND scopeRefId=?`,
-							args: [scopeNodeId, deletedScopeRefId]
-						}) : void 0)?.rows.length) continue;
-						throw new Error(`Knowledge grant scope does not exist: ${grant.scopeRefAddress}`);
-					}
-					const inserted = await tx.execute({
-						sql: `INSERT OR IGNORE INTO "${TABLE_KNOWLEDGE_SCOPE_GRANTS}" (scopeNodeId,scopeRefId,role,canSuggest) VALUES (?,?,?,?)`,
-						args: [
-							scopeNodeId,
-							scopeRefId,
-							grant.role,
-							grant.canSuggest ?? null
-						]
-					});
-					structureChanged ||= inserted.rowsAffected > 0;
+			let parentConflict;
+			if (!created && input.parentId !== void 0 && (str(row.parentId) ?? null) !== input.parentId) parentConflict = {
+				existingParentId: str(row.parentId) ?? null,
+				requestedParentId: input.parentId
+			};
+			for (const child of input.children ?? []) await ensureScope(child, scopeId);
+			const ensureTemplates = async (templates, parentId) => {
+				for (const template of templates) {
+					const problem = knowledgePageKeyProblem(template.key);
+					if (problem) throw new Error(problem);
+					const existing = (await this.#query(tx, `SELECT id FROM "${T.pages}" WHERE parentId = ? AND isScope = 0 AND key = ? AND deletedAt IS NULL`, [parentId, template.key]))[0];
+					const id = existing ? String(existing.id) : (await this.#insertPage(tx, {
+						parentId,
+						key: template.key,
+						name: template.name,
+						description: template.description,
+						provenance: input.provenance
+					})).id;
+					if (template.pages?.length) await ensureTemplates(template.pages, id);
 				}
-			}
-			if (structureChanged) await tx.execute(`UPDATE "${TABLE_KNOWLEDGE_ACCESS_STATE}" SET epoch=epoch+1 WHERE id='global'`);
-			const state = await tx.execute(`SELECT epoch FROM "${TABLE_KNOWLEDGE_ACCESS_STATE}" WHERE id='global'`);
+			};
+			await ensureTemplates(input.pages ?? [], scopeId);
 			return {
-				scopes,
-				createdScopeIds,
-				deletedScopeAddresses: [...deletedScopeAddresses],
-				changed: structureChanged,
-				accessEpoch: Number(state.rows[0]?.epoch ?? 0)
+				scope: toPage(await this.#pageRow(tx, scopeId)),
+				created,
+				...parentConflict ? { parentConflict } : {}
 			};
+		});
+	}
+	async listScopeDeclarations() {
+		return (await this.#query(this.#read, `SELECT declaration, COUNT(*) AS scopes FROM "${T.pages}" WHERE isScope = 1 AND declaration IS NOT NULL GROUP BY declaration ORDER BY declaration`)).map((row) => ({
+			declaration: String(row.declaration),
+			scopes: Number(row.scopes)
 		}));
 	}
-	async listScopeNodes(input = {}) {
-		const { limit, after } = parseListKnowledgeScopeNodesInput(input);
-		if (input.addresses?.length === 0 || input.ids?.length === 0) return {
-			scopes: [],
-			nextCursor: null
+	async renameScopeDeclaration(input) {
+		return this.#transaction(async (tx) => {
+			const within = prefixRange("declaration", `${input.from}/`);
+			const affected = (await this.#query(tx, `SELECT id, address, declaration FROM "${T.pages}" WHERE isScope = 1 AND (declaration = ? OR ${within.sql})`, [input.from, ...within.args])).map((row) => ({
+				id: String(row.id),
+				address: String(row.address),
+				from: String(row.declaration)
+			})).filter((row) => row.from === input.from || row.from.startsWith(`${input.from}/`)).map((row) => ({
+				...row,
+				to: input.to + row.from.slice(input.from.length)
+			}));
+			input.check(affected.map(({ address, from, to }) => ({
+				address,
+				from,
+				to
+			})));
+			for (const row of affected) await tx.execute({
+				sql: `UPDATE "${T.pages}" SET declaration = ? WHERE id = ?`,
+				args: [row.to, row.id]
+			});
+			return affected.length;
+		});
+	}
+	async getScopesByAddress(addresses) {
+		if (addresses.length === 0) return [];
+		return (await this.#query(this.#read, `SELECT * FROM "${T.pages}" WHERE isScope = 1 AND address IN (SELECT value FROM json_each(?))`, [jsonList(addresses)])).map(toPage);
+	}
+	async listChildScopes(input) {
+		const core = await loadPagesCore();
+		const limit = limitOf(input.limit, core.MAX_KNOWLEDGE_PAGE_LIST_LIMIT);
+		const cursor = decodeCursor(input.cursor, 2);
+		const args = [input.parentId];
+		let after = "";
+		if (cursor) {
+			after = ` AND (position > ? OR (position = ? AND id > ?))`;
+			args.push(cursor[0], cursor[0], cursor[1]);
+		}
+		args.push(limit + 1);
+		const rows = await this.#query(this.#read, `SELECT * FROM "${T.pages}" WHERE isScope = 1 AND parentId IS ?${after} ORDER BY position, id LIMIT ?`, args);
+		return this.#pageOutput(rows, limit, (row) => [String(row.position), String(row.id)]);
+	}
+	#pageOutput(rows, limit, cursorOf) {
+		const page = rows.slice(0, limit);
+		return {
+			pages: page.map(toPage),
+			...rows.length > limit ? { nextCursor: encodeCursor(cursorOf(page[page.length - 1])) } : {}
 		};
-		const args = [];
-		const where = [`n.isScope`, `n.deletedAt IS NULL`];
-		let within = "";
-		if (input.withinAddress !== void 0) {
-			within = `WITH RECURSIVE within_scope(id) AS (SELECT r.id FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" r JOIN "${TABLE_KNOWLEDGE_SCOPE_ADDRESSES}" ra ON ra.scopeNodeId=r.id WHERE ra.address=? AND r.isScope AND r.deletedAt IS NULL UNION SELECT ns.nodeId FROM "${TABLE_KNOWLEDGE_NODE_SCOPES}" ns JOIN within_scope w ON ns.scopeNodeId=w.id JOIN "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" c ON c.id=ns.nodeId WHERE c.isScope AND c.deletedAt IS NULL) `;
-			args.push(input.withinAddress);
-			where.push("n.id IN (SELECT id FROM within_scope)");
+	}
+	async getPage(input) {
+		const readable = pageReadable("p", input.read);
+		const rows = await this.#query(this.#read, `SELECT p.* FROM "${T.pages}" p WHERE p.id = ? AND ${readable.sql}`, [input.id, ...readable.args]);
+		return rows[0] ? toPage(rows[0]) : null;
+	}
+	async getPages(input) {
+		const ids = [...new Set(input.ids)];
+		if (ids.length === 0) return [];
+		const readable = pageReadable("p", input.read);
+		return (await this.#query(this.#read, `SELECT p.* FROM "${T.pages}" p WHERE p.deletedAt IS NULL AND p.id IN (SELECT value FROM json_each(?)) AND ${readable.sql}`, [jsonList(ids), ...readable.args])).map(toPage);
+	}
+	async getPageByPath(input) {
+		const readable = pageReadable("p", input.read);
+		let parentId = input.scopeId;
+		let row;
+		for (const key of input.path) {
+			row = (await this.#query(this.#read, `SELECT p.* FROM "${T.pages}" p WHERE p.parentId = ? AND p.isScope = 0 AND p.key = ? AND p.deletedAt IS NULL AND ${readable.sql}`, [
+				parentId,
+				key,
+				...readable.args
+			]))[0];
+			if (!row) return null;
+			parentId = String(row.id);
+		}
+		return row ? toPage(row) : null;
+	}
+	async findPagesByName(input) {
+		const core = await loadPagesCore();
+		const readable = pageReadable("p", input.read);
+		const args = [core.canonicalKnowledgeName(input.name), ...readable.args];
+		let scope = "";
+		if (input.scopeId !== void 0) {
+			scope = ` AND p.scopeId = ?`;
+			args.push(input.scopeId);
+		}
+		args.push(limitOf(input.limit, core.MAX_KNOWLEDGE_PAGE_LIST_LIMIT));
+		return (await this.#query(this.#read, `SELECT p.* FROM "${T.pages}" p WHERE p.canonicalName = ? AND p.deletedAt IS NULL AND ${readable.sql}${scope} ORDER BY p.createdAt DESC, p.id DESC LIMIT ?`, args)).map(toPage);
+	}
+	async listChildPages(input) {
+		const core = await loadPagesCore();
+		const limit = limitOf(input.limit, core.MAX_KNOWLEDGE_PAGE_LIST_LIMIT);
+		const cursor = decodeCursor(input.cursor, 2);
+		const readable = pageReadable("p", input.read);
+		const args = [input.parentId, ...readable.args];
+		let after = "";
+		if (cursor) {
+			after = ` AND (p.position > ? OR (p.position = ? AND p.id > ?))`;
+			args.push(cursor[0], cursor[0], cursor[1]);
 		}
-		if (input.addresses) {
-			where.push(`a.address IN (${input.addresses.map(() => "?").join(",")})`);
-			args.push(...input.addresses);
+		args.push(limit + 1);
+		const rows = await this.#query(this.#read, `SELECT p.* FROM "${T.pages}" p WHERE p.parentId = ? AND p.isScope = 0 AND p.deletedAt IS NULL AND ${readable.sql}${after} ORDER BY p.position, p.id LIMIT ?`, args);
+		return this.#pageOutput(rows, limit, (row) => [String(row.position), String(row.id)]);
+	}
+	async listPages(input) {
+		const core = await loadPagesCore();
+		const limit = limitOf(input.limit, core.MAX_KNOWLEDGE_PAGE_LIST_LIMIT);
+		const cursor = decodeCursor(input.cursor, 2);
+		const readable = pageReadable("p", input.read);
+		const args = [...readable.args];
+		let filters = "";
+		if (input.scopeId !== void 0) {
+			filters += ` AND p.scopeId = ?`;
+			args.push(input.scopeId);
 		}
-		if (input.ids) {
-			where.push(`n.id IN (${input.ids.map(() => "?").join(",")})`);
-			args.push(...input.ids);
+		if (input.namePrefix) {
+			const prefix = core.canonicalKnowledgeName(input.namePrefix);
+			filters += ` AND substr(p.canonicalName, 1, length(?)) = ?`;
+			args.push(prefix, prefix);
 		}
-		if (after) {
-			where.push("(n.name > ? OR (n.name = ? AND n.id > ?))");
-			args.push(after.name, after.name, after.id);
+		if (cursor) {
+			filters += ` AND (p.name > ? OR (p.name = ? AND p.id > ?))`;
+			args.push(cursor[0], cursor[0], cursor[1]);
 		}
 		args.push(limit + 1);
-		const rows = (await this.#client.execute({
-			sql: `${within}SELECT n.id,n.name,n.kind,n.description,a.address FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" n LEFT JOIN "${TABLE_KNOWLEDGE_SCOPE_ADDRESSES}" a ON a.scopeNodeId=n.id WHERE ${where.join(" AND ")} ORDER BY n.name, n.id LIMIT ?`,
-			args
-		})).rows;
-		if (rows.length === 0) return {
-			scopes: [],
-			nextCursor: null
-		};
-		const parents = await this.#client.execute({
-			sql: `SELECT ns.nodeId,ns.scopeNodeId FROM "${TABLE_KNOWLEDGE_NODE_SCOPES}" ns WHERE ns.nodeId IN (${rows.map(() => "?").join(",")}) ORDER BY ns.scopeNodeId`,
-			args: rows.map((row) => String(row.id))
+		const rows = await this.#query(this.#read, `SELECT p.* FROM "${T.pages}" p WHERE p.isScope = 0 AND p.deletedAt IS NULL AND ${readable.sql}${filters} ORDER BY p.name, p.id LIMIT ?`, args);
+		return this.#pageOutput(rows, limit, (row) => [String(row.name), String(row.id)]);
+	}
+	async #insertPage(tx, input) {
+		const core = await loadPagesCore();
+		await assertKnowledgePageDescriptionWithinBound(input.description);
+		const parent = await this.#livePage(tx, input.parentId);
+		const isScopeParent = Number(parent.isScope) === 1;
+		const scopeId = isScopeParent ? String(parent.id) : String(parent.scopeId);
+		const depth = isScopeParent ? 1 : Number(parent.depth) + 1;
+		if (depth > core.MAX_KNOWLEDGE_PAGE_DEPTH) throw new core.KnowledgePageDepthError(input.parentId);
+		const id = input.id ?? (0, _mastra_core_storage.createKnowledgeUlid)();
+		if (await this.#pageRow(tx, id)) throw new _mastra_core_storage.KnowledgeConflictError(id);
+		if (input.key !== void 0) {
+			const problem = knowledgePageKeyProblem(input.key);
+			if (problem) throw new Error(problem);
+			if ((await this.#query(tx, `SELECT id FROM "${T.pages}" WHERE parentId = ? AND isScope = 0 AND key = ? AND deletedAt IS NULL`, [String(parent.id), input.key])).length > 0) throw new core.KnowledgePageKeyConflictError(input.key, String(parent.id));
+		}
+		const position = input.position ?? core.knowledgePositionBetween(await this.#lastPosition(tx, String(parent.id), false));
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const who = JSON.stringify(input.provenance);
+		await tx.execute({
+			sql: `INSERT INTO "${T.pages}" (id, scopeId, isScope, key, parentId, position, path, depth, name, canonicalName, description, body, version, createdBy, updatedBy, createdAt, updatedAt) VALUES (?, ?, 0, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, ?, ?)`,
+			args: [
+				id,
+				scopeId,
+				input.key ?? null,
+				String(parent.id),
+				position,
+				`${String(parent.path)}${id}/`,
+				depth,
+				input.name,
+				core.canonicalKnowledgeName(input.name),
+				input.description || null,
+				input.body ?? null,
+				who,
+				who,
+				now,
+				now
+			]
 		});
-		const parentsByScopeId = /* @__PURE__ */ new Map();
-		for (const row of parents.rows) {
-			const scopeId = String(row.nodeId);
-			const parentId = String(row.scopeNodeId);
-			const existing = parentsByScopeId.get(scopeId);
-			if (existing) existing.push(parentId);
-			else parentsByScopeId.set(scopeId, [parentId]);
-		}
-		return pageKnowledgeScopeNodes(rows.map((row) => ({
-			id: String(row.id),
-			address: String(row.address),
-			name: String(row.name),
-			...row.kind == null ? {} : { kind: String(row.kind) },
-			...row.description == null ? {} : { description: String(row.description) },
-			parentIds: parentsByScopeId.get(String(row.id)) ?? []
-		})), limit, input);
-	}
-	async listScopeMembers(input) {
-		const { limit, after } = parseListKnowledgeScopeMembersInput(input);
-		const args = [input.scopeNodeId];
-		let keyset = "";
-		if (after) {
-			const updatedAt = after.updatedAt.toISOString();
-			keyset = ` AND (n.updatedAt < ? OR (n.updatedAt = ? AND (n.name > ? OR (n.name = ? AND n.id > ?))))`;
-			args.push(updatedAt, updatedAt, after.name, after.name, after.id);
-		}
-		args.push(limit + 1);
-		return pageKnowledgeScopeMembers((await this.#client.execute({
-			sql: `SELECT *, json(scope) AS scopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" n WHERE EXISTS (SELECT 1 FROM "${TABLE_KNOWLEDGE_NODE_SCOPES}" ns WHERE ns.nodeId=n.id AND ns.scopeNodeId=?) AND n.deletedAt IS NULL AND n.mergedInto IS NULL${keyset} ORDER BY n.updatedAt DESC, n.name ASC, n.id ASC LIMIT ?`,
-			args
-		})).rows.map(parseNode), limit, input);
-	}
-	async createNode(input) {
-		await assertKnowledgeDescriptionWithinBoundCompat(input.description);
-		const scope = (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope);
+		await this.#logActivity(tx, "page-created", {
+			scopeId,
+			pageId: id,
+			provenance: input.provenance
+		}, now);
+		return toPage(await this.#pageRow(tx, id));
+	}
+	async createPage(input) {
+		await assertKnowledgePageDescriptionWithinBound(input.description);
+		return this.#transaction((tx) => this.#insertPage(tx, input));
+	}
+	async updatePage(input) {
+		const core = await loadPagesCore();
+		await assertKnowledgePageDescriptionWithinBound(input.description);
 		return this.#transaction(async (tx) => {
-			const existing = await this.#getNodeByName(tx, input.name, scope);
-			if (existing) {
-				const terminal = await this.#resolveTerminalNode(tx, existing.id);
-				if (!(0, _mastra_core_storage.isKnowledgeScopeVisible)(terminal.scope, scope)) throw new Error(`Merged knowledge node is not visible from scope: ${input.name}`);
-				await this.#placeNodeInScopes(tx, terminal.id, input.scopeAddresses, /* @__PURE__ */ new Date());
-				return terminal;
-			}
-			const now = /* @__PURE__ */ new Date();
-			const node = {
-				id: input.id ?? crypto.randomUUID(),
-				type: "node",
-				name: input.name.trim(),
-				kind: input.kind,
-				content: input.content,
-				description: input.description,
-				scope,
-				version: 1,
-				createdAt: now,
-				updatedAt: now
-			};
+			const row = await this.#livePage(tx, input.id);
+			if (Number(row.version) !== input.expectedVersion) throw new _mastra_core_storage.KnowledgeConflictError(input.id);
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const name = input.name ?? String(row.name);
+			const description = input.description === void 0 ? row.description ?? null : input.description || null;
+			const body = input.body === void 0 ? row.body ?? null : input.body;
 			await tx.execute({
-				sql: `INSERT INTO "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" (id,type,name,canonicalName,kind,content,description,isScope,scope,scopeKey,version,mergedInto,createdAt,updatedAt) VALUES (?,?,?,?,?,?,?,FALSE,jsonb(?),?,?,NULL,?,?)`,
+				sql: `UPDATE "${T.pages}" SET name = ?, canonicalName = ?, description = ?, body = ?, version = version + 1, updatedBy = ?, updatedAt = ? WHERE id = ?`,
 				args: [
-					node.id,
-					"node",
-					node.name,
-					canonicalName(node.name),
-					node.kind,
-					node.content ?? null,
-					node.description ?? null,
-					JSON.stringify(scope),
-					(0, _mastra_core_storage.knowledgeScopeKey)(scope),
-					node.version,
-					now.toISOString(),
-					now.toISOString()
+					name,
+					core.canonicalKnowledgeName(name),
+					description,
+					body,
+					JSON.stringify(input.provenance),
+					now,
+					input.id
 				]
 			});
-			await this.#replaceNodeScopes(tx, node.id, scope, now);
-			await this.#placeNodeInScopes(tx, node.id, input.scopeAddresses, now);
-			await this.#replaceMentions(tx, "node", node.id, node.content ?? "", input.resolutionScope ?? scope, scope);
-			await this.#activity(tx, "node-created", "node", node.id, scope);
-			await this.#outbox(tx, "node", node.id, "upsert", node.version, scope);
-			return node;
+			await this.#logActivity(tx, "page-updated", {
+				scopeId: String(row.scopeId),
+				pageId: input.id,
+				provenance: input.provenance
+			}, now);
+			return toPage(await this.#pageRow(tx, input.id));
 		});
 	}
-	async getNode(id) {
-		return this.#getNode(this.#client, id);
-	}
-	async getNodeByName(input) {
-		return this.#getNodeByName(this.#client, input.name, (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope));
-	}
-	async resolveNode(input) {
-		return this.#resolveNode(this.#client, input.name, (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope));
-	}
-	async listNodes(input) {
-		const keys = visibleScopeKeys((0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope));
-		const clauses = [
-			`type = 'node'`,
-			"mergedInto IS NULL",
-			visibleSql(keys)
-		];
-		const args = [...keys];
-		if (input.namePrefix) {
-			clauses.push("canonicalName LIKE ? ESCAPE '='");
-			args.push(`${escapeLikePattern(canonicalName(input.namePrefix))}%`);
-		}
-		if (input.kind) {
-			clauses.push("kind = ?");
-			args.push(input.kind);
-		}
-		if (input.hasContent !== void 0) clauses.push(input.hasContent ? "content IS NOT NULL AND content <> ''" : "(content IS NULL OR content = '')");
-		if (input.cursor) {
-			const cursor = (0, _mastra_core_storage.parseKnowledgeNodeCursor)(input.cursor, {
-				namePrefix: input.namePrefix,
-				kind: input.kind,
-				hasContent: input.hasContent
-			});
-			clauses.push("(updatedAt < ? OR (updatedAt = ? AND (name > ? OR (name = ? AND id > ?))))");
-			const updatedAt = cursor.updatedAt.toISOString();
-			args.push(updatedAt, updatedAt, cursor.name, cursor.name, cursor.id);
-		}
-		args.push(input.limit ?? 100);
-		return (await this.#client.execute({
-			sql: `SELECT *, json(scope) AS scopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" WHERE ${clauses.join(" AND ")} ORDER BY updatedAt DESC, name ASC, id ASC LIMIT ?`,
-			args
-		})).rows.map(parseNode);
+	/**
+	* Rehomes `root` (and its subtree) under `parent`: new path prefix, scope and depth in one go.
+	* Throws when the subtree is too large, too deep, or the root's key clashes with a live child of `parent`.
+	*/
+	async #rehome(tx, root, parent, options) {
+		const core = await loadPagesCore();
+		const isScopeParent = Number(parent.isScope) === 1;
+		const newScopeId = isScopeParent ? String(parent.id) : String(parent.scopeId);
+		const newDepth = isScopeParent ? 1 : Number(parent.depth) + 1;
+		const oldPath = String(root.path);
+		const within = prefixRange("path", oldPath);
+		const live = (await this.#query(tx, `SELECT id, key, depth, deletedAt FROM "${T.pages}" WHERE ${within.sql}`, within.args)).filter((row) => !row.deletedAt);
+		if (live.length > core.MAX_KNOWLEDGE_MOVE_PAGES) throw new core.KnowledgeMoveTooLargeError(options.countLimitId, live.length);
+		const shift = newDepth - Number(root.depth);
+		if (Math.max(...live.map((row) => Number(row.depth))) + shift > core.MAX_KNOWLEDGE_PAGE_DEPTH) throw new core.KnowledgePageDepthError(String(root.id));
+		if (!root.deletedAt && root.key !== null) {
+			if ((await this.#query(tx, `SELECT id FROM "${T.pages}" WHERE parentId = ? AND isScope = 0 AND key = ? AND deletedAt IS NULL AND id <> ?`, [
+				String(parent.id),
+				String(root.key),
+				String(root.id)
+			])).length > 0) throw new core.KnowledgePageKeyConflictError(String(root.key), String(parent.id));
+		}
+		const newPath = `${String(parent.path)}${String(root.id)}/`;
+		const position = options.position ?? core.knowledgePositionBetween(await this.#lastPosition(tx, String(parent.id), false));
+		await tx.execute({
+			sql: `UPDATE "${T.pages}" SET path = ? || substr(path, length(?) + 1), depth = depth + ?, scopeId = ? WHERE ${within.sql}`,
+			args: [
+				newPath,
+				oldPath,
+				shift,
+				newScopeId,
+				...within.args
+			]
+		});
+		await tx.execute({
+			sql: `UPDATE "${T.pages}" SET parentId = ?, position = ? WHERE id = ?`,
+			args: [
+				String(parent.id),
+				position,
+				String(root.id)
+			]
+		});
+		return {
+			moved: live.length,
+			scopeId: newScopeId
+		};
 	}
-	async updateNode(input) {
-		await assertKnowledgeDescriptionWithinBoundCompat(input.description);
+	movePage(input) {
 		return this.#transaction(async (tx) => {
-			const existing = await this.#getNode(tx, input.id);
-			if (!existing) throw new _mastra_core_storage.KnowledgeNotFoundError("node", input.id);
-			if (existing.mergedInto) throw new Error(`Cannot update merged knowledge node: ${input.id}`);
-			const scope = (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope ?? existing.scope);
-			const name = (input.name ?? existing.name).trim();
-			const content = input.content ?? existing.content;
-			const description = input.description ?? existing.description;
-			const now = /* @__PURE__ */ new Date();
-			if ((await tx.execute({
-				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" SET name=?,canonicalName=?,kind=?,content=?,description=?,scope=jsonb(?),scopeKey=?,version=version+1,updatedAt=? WHERE id=? AND type='node' AND version=?`,
+			const row = await this.#livePage(tx, input.id);
+			if (Number(row.isScope) === 1) throw new Error(`Cannot move ${input.id}: it is a scope page`);
+			if (Number(row.version) !== input.expectedVersion) throw new _mastra_core_storage.KnowledgeConflictError(input.id);
+			const parent = await this.#livePage(tx, input.parentId);
+			const path = String(row.path);
+			if (String(parent.id) === input.id || String(parent.path).startsWith(path)) throw new Error(`Cannot move ${input.id} into its own subtree`);
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const { scopeId } = await this.#rehome(tx, row, parent, {
+				position: input.position,
+				countLimitId: input.id
+			});
+			await tx.execute({
+				sql: `UPDATE "${T.pages}" SET version = version + 1, updatedBy = ?, updatedAt = ? WHERE id = ?`,
 				args: [
-					name,
-					canonicalName(name),
-					input.kind ?? existing.kind,
-					content ?? null,
-					description ?? null,
-					JSON.stringify(scope),
-					(0, _mastra_core_storage.knowledgeScopeKey)(scope),
-					now.toISOString(),
-					input.id,
-					input.version
+					JSON.stringify(input.provenance),
+					now,
+					input.id
 				]
-			})).rowsAffected === 0) throw new _mastra_core_storage.KnowledgeConflictError(input.id);
-			if ((0, _mastra_core_storage.knowledgeScopeKey)(existing.scope) !== (0, _mastra_core_storage.knowledgeScopeKey)(scope)) await this.#swapIdentityScopes(tx, input.id, existing.scope, scope, now);
-			if (input.content !== void 0 || input.name !== void 0 || input.scope !== void 0) await this.#replaceMentions(tx, "node", input.id, content ?? "", input.resolutionScope ?? scope, scope);
-			await this.#activity(tx, "node-updated", "node", input.id, scope);
-			if ((0, _mastra_core_storage.knowledgeScopeKey)(existing.scope) !== (0, _mastra_core_storage.knowledgeScopeKey)(scope)) {
-				await this.#outbox(tx, "node", input.id, "delete", (0, _mastra_core_storage.createKnowledgeUlid)(), existing.scope);
-				const knowledge = await tx.execute({
-					sql: `SELECT id,json(scope) AS scopeJson,deletedAt FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" WHERE node=?`,
-					args: [input.id]
-				});
-				for (const row of knowledge.rows) {
-					const recordScope = parseJson$3(row.scopeJson);
-					await this.#outbox(tx, "record", String(row.id), "delete", (0, _mastra_core_storage.createKnowledgeUlid)(), recordScope);
-					if (row.deletedAt == null) await this.#outbox(tx, "record", String(row.id), "upsert", (0, _mastra_core_storage.createKnowledgeUlid)(), recordScope);
-				}
-			}
-			await this.#outbox(tx, "node", input.id, "upsert", input.version + 1, scope);
-			return {
-				...existing,
-				name,
-				kind: input.kind ?? existing.kind,
-				content,
-				description,
-				scope,
-				version: input.version + 1,
-				updatedAt: now
-			};
+			});
+			await this.#logActivity(tx, "page-moved", {
+				scopeId,
+				pageId: input.id,
+				provenance: input.provenance
+			}, now);
+			return toPage(await this.#pageRow(tx, input.id));
 		});
 	}
-	async mergeNodes(input) {
-		if (input.sourceId === input.targetId) throw new Error("Cannot merge a knowledge node into itself");
+	async mergePages(input) {
+		const core = await loadPagesCore();
 		return this.#transaction(async (tx) => {
-			const source = await this.#getNode(tx, input.sourceId);
-			if (!source) throw new _mastra_core_storage.KnowledgeNotFoundError("node", input.sourceId);
-			const target = await this.#resolveTerminalNode(tx, input.targetId);
-			if (!target) throw new _mastra_core_storage.KnowledgeNotFoundError("node", input.targetId);
-			if (target.id === source.id) throw new Error("Cannot create a knowledge merge cycle");
-			if (!(0, _mastra_core_storage.isKnowledgeScopeVisible)(target.scope, source.scope)) throw new Error("Cannot merge a knowledge node into a target that is narrower than its source scope");
-			const affected = await tx.execute({
-				sql: `SELECT DISTINCT m.sourceType,m.sourceId,json(COALESCE(f.scope,r.scope)) AS scopeJson,CASE WHEN f.deletedAt IS NULL THEN 0 ELSE 1 END AS deleted FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}" m LEFT JOIN "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" f ON m.sourceType='record' AND f.id=m.sourceId LEFT JOIN "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" r ON m.sourceType='node' AND r.id=m.sourceId WHERE m.recordId=?`,
-				args: [source.id]
-			});
-			const movedKnowledge = await tx.execute({
-				sql: `SELECT id,json(scope) AS scopeJson,deletedAt FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" WHERE node=?`,
-				args: [source.id]
-			});
-			if ((await tx.execute({
-				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" SET mergedInto=?,version=version+1,updatedAt=? WHERE id=? AND type='node' AND version=? AND mergedInto IS NULL`,
-				args: [
-					target.id,
-					(/* @__PURE__ */ new Date()).toISOString(),
-					source.id,
-					input.sourceVersion
-				]
-			})).rowsAffected === 0) throw new _mastra_core_storage.KnowledgeConflictError(source.id);
+			const source = await this.#livePage(tx, input.sourceId);
+			const target = await this.#livePage(tx, input.targetId);
+			if (Number(source.isScope) === 1 || Number(target.isScope) === 1) throw new Error("Cannot merge a scope page: merging applies to non-scope pages only");
+			if (Number(source.version) !== input.sourceVersion) throw new _mastra_core_storage.KnowledgeConflictError(input.sourceId);
+			const sourcePath = String(source.path);
+			if (input.sourceId === input.targetId || String(target.path).startsWith(sourcePath)) throw new Error(`Page ${input.targetId} is inside page ${input.sourceId}; it cannot be the merge target (subtree)`);
+			const within = prefixRange("path", sourcePath);
+			const carried = await this.#query(tx, `SELECT COUNT(*) AS n FROM "${T.pages}" WHERE ${within.sql} AND id <> ? AND deletedAt IS NULL`, [...within.args, input.sourceId]);
+			if (Number(carried[0].n) > core.MAX_KNOWLEDGE_MOVE_PAGES) throw new core.KnowledgeMoveTooLargeError(input.sourceId, Number(carried[0].n));
+			const now = (/* @__PURE__ */ new Date()).toISOString();
 			await tx.execute({
-				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" SET node=?,version=version+1,updatedAt=? WHERE node=?`,
+				sql: `UPDATE "${T.pages}" SET deletedAt = ?, deletedBy = ?, mergedInto = ?, scopeId = ?, version = version + 1, updatedBy = ?, updatedAt = ? WHERE id = ?`,
 				args: [
-					target.id,
-					(/* @__PURE__ */ new Date()).toISOString(),
-					source.id
+					now,
+					input.provenance.author,
+					input.targetId,
+					String(target.scopeId),
+					JSON.stringify(input.provenance),
+					now,
+					input.sourceId
 				]
 			});
+			const children = await this.#query(tx, `SELECT * FROM "${T.pages}" WHERE parentId = ? AND isScope = 0`, [input.sourceId]);
+			for (const child of children) await this.#rehome(tx, child, target, {
+				position: String(child.position),
+				countLimitId: input.sourceId
+			});
 			await tx.execute({
-				sql: `DELETE FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}" WHERE recordId=? AND EXISTS (SELECT 1 FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}" target WHERE target.sourceType="${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}".sourceType AND target.sourceId="${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}".sourceId AND target.recordId=?)`,
-				args: [source.id, target.id]
+				sql: `UPDATE "${T.notes}" SET pageId = ? WHERE pageId = ?`,
+				args: [input.targetId, input.sourceId]
 			});
 			await tx.execute({
-				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}" SET recordId=? WHERE recordId=?`,
-				args: [target.id, source.id]
+				sql: `UPDATE OR IGNORE "${T.mentions}" SET pageId = ? WHERE pageId = ?`,
+				args: [input.targetId, input.sourceId]
 			});
-			for (const row of movedKnowledge.rows) await this.#outbox(tx, "record", String(row.id), row.deletedAt == null ? "upsert" : "delete", (0, _mastra_core_storage.createKnowledgeUlid)(), parseJson$3(row.scopeJson));
-			for (const row of affected.rows) await this.#outbox(tx, String(row.sourceType), String(row.sourceId), Number(row.deleted) ? "delete" : "upsert", (0, _mastra_core_storage.createKnowledgeUlid)(), parseJson$3(row.scopeJson));
-			let mergedTarget = target;
-			if (target.description === void 0 && source.description) {
-				const adoptedAt = /* @__PURE__ */ new Date();
-				if ((await tx.execute({
-					sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" SET description=?,version=version+1,updatedAt=? WHERE id=? AND type='node' AND version=? AND description IS NULL`,
+			await tx.execute({
+				sql: `DELETE FROM "${T.mentions}" WHERE pageId = ?`,
+				args: [input.sourceId]
+			});
+			const pins = await this.#query(tx, `SELECT * FROM "${T.pins}" WHERE pageId IN (?, ?)`, [input.sourceId, input.targetId]);
+			const sourcePin = pins.find((pin) => String(pin.pageId) === input.sourceId);
+			if (sourcePin) {
+				const targetPin = pins.find((pin) => String(pin.pageId) === input.targetId);
+				const audience = JSON.parse(String(sourcePin.audience));
+				if (targetPin) {
+					const merged = [.../* @__PURE__ */ new Set([...JSON.parse(String(targetPin.audience)), ...audience])];
+					await tx.execute({
+						sql: `UPDATE "${T.pins}" SET audience = ?, updatedAt = ? WHERE id = ?`,
+						args: [
+							JSON.stringify(merged),
+							now,
+							String(targetPin.id)
+						]
+					});
+					await this.#indexAudience(tx, String(targetPin.id), merged);
+					await this.#indexAudience(tx, String(sourcePin.id), []);
+					await tx.execute({
+						sql: `DELETE FROM "${T.pins}" WHERE id = ?`,
+						args: [String(sourcePin.id)]
+					});
+				} else await tx.execute({
+					sql: `UPDATE "${T.pins}" SET pageId = ?, updatedAt = ? WHERE id = ?`,
 					args: [
-						source.description,
-						adoptedAt.toISOString(),
-						target.id,
-						target.version
+						input.targetId,
+						now,
+						String(sourcePin.id)
 					]
-				})).rowsAffected > 0) {
-					mergedTarget = {
-						...target,
-						description: source.description,
-						version: target.version + 1,
-						updatedAt: adoptedAt
-					};
-					await this.#activity(tx, "node-updated", "node", target.id, target.scope);
-				}
+				});
 			}
-			await this.#activity(tx, "node-merged", "node", source.id, source.scope);
-			await this.#outbox(tx, "node", source.id, "delete", input.sourceVersion + 1, source.scope);
-			await this.#outbox(tx, "node", target.id, "upsert", (0, _mastra_core_storage.createKnowledgeUlid)(), mergedTarget.scope);
-			return mergedTarget;
+			await this.#logActivity(tx, "page-merged", {
+				scopeId: String(target.scopeId),
+				pageId: input.sourceId,
+				provenance: input.provenance
+			}, now);
+			return toPage(await this.#pageRow(tx, input.targetId));
 		});
 	}
-	async appendKnowledge(input) {
-		await assertKnowledgeRecordTextWithinBoundCompat(input.text);
-		const scope = (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope);
-		const resolutionScope = (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.resolutionScope);
-		const defaultScope = (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.defaultScope);
+	async deletePage(input) {
+		const core = await loadPagesCore();
 		return this.#transaction(async (tx) => {
-			const node = nodeReferenceId(input.node);
-			const parent = await this.#resolveTerminalNode(tx, node);
-			if (!parent) throw new _mastra_core_storage.KnowledgeNotFoundError("node", node);
-			const record = {
-				id: input.id ?? (0, _mastra_core_storage.createKnowledgeUlid)(),
-				node: parent.id,
-				text: input.text,
-				scope,
-				sourceThreadId: input.sourceThreadId,
-				capturedAt: /* @__PURE__ */ new Date(),
-				when: input.when ? new Date(input.when) : void 0,
-				metadata: input.metadata
-			};
+			const row = await this.#livePage(tx, input.id);
+			if (Number(row.isScope) === 1) throw new Error(`Cannot delete ${input.id}: it is a scope page`);
+			if (Number(row.version) !== input.expectedVersion) throw new _mastra_core_storage.KnowledgeConflictError(input.id);
+			if ((await this.#query(tx, `SELECT 1 FROM "${T.pages}" WHERE parentId = ? AND deletedAt IS NULL LIMIT 1`, [input.id])).length > 0) throw new core.KnowledgePageHasChildrenError(input.id);
+			const now = (/* @__PURE__ */ new Date()).toISOString();
 			await tx.execute({
-				sql: `INSERT INTO "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" (id,node,text,scope,scopeKey,sourceThreadId,capturedAt,"when",metadata,version,updatedAt,deletedAt,deletedBy) VALUES (?,?,?,jsonb(?),?,?,?,?,jsonb(?),?,?,NULL,NULL)`,
+				sql: `UPDATE "${T.pages}" SET deletedAt = ?, deletedBy = ?, version = version + 1, updatedBy = ?, updatedAt = ? WHERE id = ?`,
 				args: [
-					record.id,
-					record.node,
-					record.text,
-					JSON.stringify(scope),
-					(0, _mastra_core_storage.knowledgeScopeKey)(scope),
-					record.sourceThreadId,
-					record.capturedAt.toISOString(),
-					record.when?.toISOString() ?? null,
-					record.metadata ? JSON.stringify(record.metadata) : null,
-					1,
-					record.capturedAt.toISOString()
+					now,
+					input.deletedBy,
+					JSON.stringify({ author: input.deletedBy }),
+					now,
+					input.id
 				]
 			});
-			await this.#replaceRecordScopes(tx, record.id, scope, record.capturedAt);
-			await this.#replaceMentions(tx, "record", record.id, record.text, resolutionScope, defaultScope);
-			await this.#activity(tx, "record-created", "record", record.id, scope, record.sourceThreadId);
-			await this.#outbox(tx, "record", record.id, "upsert", record.id, scope);
-			return record;
-		});
-	}
-	async getKnowledge(input) {
-		const result = await this.#client.execute({
-			sql: `SELECT *,json(scope) AS scopeJson,json(metadata) AS metadataJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" WHERE id=?${input.includeDeleted ? "" : " AND deletedAt IS NULL"}`,
-			args: [input.id]
+			await tx.execute({
+				sql: `DELETE FROM "${T.pinAudiences}" WHERE pinId IN (SELECT id FROM "${T.pins}" WHERE pageId = ?)`,
+				args: [input.id]
+			});
+			await tx.execute({
+				sql: `DELETE FROM "${T.pins}" WHERE pageId = ?`,
+				args: [input.id]
+			});
+			await this.#logActivity(tx, "page-deleted", {
+				scopeId: String(row.scopeId),
+				pageId: input.id,
+				provenance: { author: input.deletedBy }
+			}, now);
+			return toPage(await this.#pageRow(tx, input.id));
 		});
-		return result.rows[0] ? parseKnowledge(result.rows[0]) : null;
-	}
-	async listKnowledgeAbout(input) {
-		return this.#queryKnowledge(input, "about");
-	}
-	async listKnowledgeMentioning(input) {
-		return this.#queryKnowledge(input, "mentioning");
-	}
-	async listKnowledgeRelatedTo(input) {
-		return this.#queryKnowledge(input, "related");
 	}
-	async knowledgeBySource(input) {
-		const keys = visibleScopeKeys((0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope));
-		const args = [input.sourceThreadId, ...keys];
-		if (input.after) args.push(input.after);
-		const limit = input.limit ?? 100;
+	async #hydrateNotes(executor, rows) {
+		if (rows.length === 0) return [];
+		const ids = jsonList(rows.map((row) => String(row.id)));
+		const stamps = await this.#query(executor, `SELECT noteId, scopeId FROM "${T.stamps}" WHERE noteId IN (SELECT value FROM json_each(?)) ORDER BY scopeId`, [ids]);
+		const mentions = await this.#query(executor, `SELECT noteId, pageId FROM "${T.mentions}" WHERE noteId IN (SELECT value FROM json_each(?)) ORDER BY pageId`, [ids]);
+		return rows.map((row) => toNote(row, stamps.filter((stamp) => String(stamp.noteId) === String(row.id)).map((stamp) => String(stamp.scopeId)), mentions.filter((mention) => String(mention.noteId) === String(row.id)).map((mention) => String(mention.pageId))));
+	}
+	async #noteById(executor, id) {
+		const rows = await this.#query(executor, `SELECT * FROM "${T.notes}" WHERE id = ?`, [id]);
+		return (await this.#hydrateNotes(executor, rows))[0] ?? null;
+	}
+	async getNote(input) {
+		const readable = noteReadable("n", input.read);
+		const rows = await this.#query(this.#read, `SELECT n.* FROM "${T.notes}" n WHERE n.id = ?${input.includeDeleted ? "" : " AND n.deletedAt IS NULL"} AND ${readable.sql}`, [input.id, ...readable.args]);
+		return (await this.#hydrateNotes(this.#read, rows))[0] ?? null;
+	}
+	async listNotes(input) {
+		const core = await loadPagesCore();
+		const limit = limitOf(input.limit, core.MAX_KNOWLEDGE_PAGE_LIST_LIMIT);
+		const cursor = decodeCursor(input.cursor, 2);
+		const readable = noteReadable("n", input.read);
+		const args = [input.pageId, ...readable.args];
+		let after = "";
+		if (cursor) {
+			after = ` AND (n.createdAt > ? OR (n.createdAt = ? AND n.id > ?))`;
+			args.push(cursor[0], cursor[0], cursor[1]);
+		}
 		args.push(limit + 1);
-		const records = (await this.#client.execute({
-			sql: `SELECT *,json(scope) AS scopeJson,json(metadata) AS metadataJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" WHERE sourceThreadId=? AND ${visibleSql(keys)}${input.includeDeleted ? "" : " AND deletedAt IS NULL"}${input.after ? " AND id > ?" : ""} ORDER BY id ASC LIMIT ?`,
-			args
-		})).rows.map(parseKnowledge);
+		const rows = await this.#query(this.#read, `SELECT n.* FROM "${T.notes}" n WHERE n.pageId = ?${input.includeDeleted ? "" : " AND n.deletedAt IS NULL"} AND ${readable.sql}${after} ORDER BY n.createdAt, n.id LIMIT ?`, args);
+		return this.#noteOutput(rows, limit);
+	}
+	async countChildPages(input) {
+		const ids = [...new Set(input.parentIds)];
+		const counts = Object.fromEntries(ids.map((id) => [id, 0]));
+		if (ids.length === 0) return counts;
+		const readable = pageReadable("p", input.read);
+		const rows = await this.#query(this.#read, `SELECT p.parentId AS parentId, COUNT(*) AS total FROM "${T.pages}" p WHERE p.parentId IN (SELECT value FROM json_each(?)) AND p.isScope = 0 AND p.deletedAt IS NULL AND ${readable.sql} GROUP BY p.parentId`, [jsonList(ids), ...readable.args]);
+		for (const row of rows) counts[String(row.parentId)] = Number(row.total);
+		return counts;
+	}
+	async countNotes(input) {
+		const ids = [...new Set(input.pageIds)];
+		const counts = Object.fromEntries(ids.map((id) => [id, 0]));
+		if (ids.length === 0) return counts;
+		const readable = noteReadable("n", input.read);
+		const rows = await this.#query(this.#read, `SELECT n.pageId AS pageId, COUNT(*) AS total FROM "${T.notes}" n WHERE n.pageId IN (SELECT value FROM json_each(?)) AND n.deletedAt IS NULL AND ${readable.sql} GROUP BY n.pageId`, [jsonList(ids), ...readable.args]);
+		for (const row of rows) counts[String(row.pageId)] = Number(row.total);
+		return counts;
+	}
+	async listNotesMentioning(input) {
+		const core = await loadPagesCore();
+		const limit = limitOf(input.limit, core.MAX_KNOWLEDGE_PAGE_LIST_LIMIT);
+		const cursor = decodeCursor(input.cursor, 2);
+		const readable = noteReadable("n", input.read);
+		const args = [
+			input.pageId,
+			input.pageId,
+			...readable.args
+		];
+		let after = "";
+		if (cursor) {
+			after = ` AND (n.createdAt < ? OR (n.createdAt = ? AND n.id < ?))`;
+			args.push(cursor[0], cursor[0], cursor[1]);
+		}
+		args.push(limit + 1);
+		const rows = await this.#query(this.#read, `SELECT n.* FROM "${T.notes}" n WHERE n.pageId <> ? AND n.deletedAt IS NULL AND EXISTS (SELECT 1 FROM "${T.mentions}" m WHERE m.noteId = n.id AND m.pageId = ?) AND ${readable.sql}${after} ORDER BY n.createdAt DESC, n.id DESC LIMIT ?`, args);
+		return this.#noteOutput(rows, limit);
+	}
+	async #noteOutput(rows, limit) {
+		const page = rows.slice(0, limit);
 		return {
-			records: records.slice(0, limit),
-			nextCursor: records.length > limit ? records[limit - 1]?.id : void 0
+			notes: await this.#hydrateNotes(this.#read, page),
+			...rows.length > limit ? { nextCursor: encodeCursor([String(page[page.length - 1].createdAt), String(page[page.length - 1].id)]) } : {}
 		};
 	}
-	async removeKnowledge(input) {
+	async #assertScopes(tx, ids) {
+		if (ids.length === 0) throw new Error("A note needs at least one stamp scope");
+		const found = await this.#query(tx, `SELECT id FROM "${T.pages}" WHERE isScope = 1 AND id IN (SELECT value FROM json_each(?))`, [jsonList(ids)]);
+		const known = new Set(found.map((row) => String(row.id)));
+		const missing = ids.find((id) => !known.has(id));
+		if (missing) throw new Error(`Note stamp ${missing} is not a scope page`);
+	}
+	async addNote(input) {
+		await assertKnowledgeNoteTextWithinBound(input.text);
 		return this.#transaction(async (tx) => {
-			const record = await this.#getKnowledge(tx, input.id, true);
-			if (!record) throw new _mastra_core_storage.KnowledgeNotFoundError("record", input.id);
-			if (record.deletedAt) return record;
-			const deletedAt = /* @__PURE__ */ new Date();
+			const page = await this.#livePage(tx, input.pageId);
+			const stamps = [...new Set(input.stampScopeIds)];
+			await this.#assertScopes(tx, stamps);
+			const mentions = [...new Set(input.mentions)];
+			for (const mention of mentions) await this.#livePage(tx, mention);
+			const id = input.id ?? (0, _mastra_core_storage.createKnowledgeUlid)();
+			if ((await this.#query(tx, `SELECT 1 FROM "${T.notes}" WHERE id = ?`, [id])).length > 0) throw new _mastra_core_storage.KnowledgeConflictError(id);
+			const now = (/* @__PURE__ */ new Date()).toISOString();
 			await tx.execute({
-				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" SET deletedAt=?,deletedBy=?,version=version+1,updatedAt=? WHERE id=? AND deletedAt IS NULL`,
+				sql: `INSERT INTO "${T.notes}" (id, pageId, text, "when", provenance, version, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, 1, ?, ?)`,
 				args: [
-					deletedAt.toISOString(),
-					input.deletedBy,
-					deletedAt.toISOString(),
-					input.id
+					id,
+					input.pageId,
+					input.text,
+					input.when ? input.when.toISOString() : null,
+					JSON.stringify(input.provenance),
+					now,
+					now
 				]
 			});
-			await this.#activity(tx, "record-deleted", "record", input.id, record.scope, record.sourceThreadId);
-			await this.#outbox(tx, "record", input.id, "delete", deletedAt.toISOString(), record.scope);
-			return {
-				...record,
-				deletedAt,
-				deletedBy: input.deletedBy
-			};
+			for (const stamp of stamps) await tx.execute({
+				sql: `INSERT INTO "${T.stamps}" (noteId, scopeId) VALUES (?, ?)`,
+				args: [id, stamp]
+			});
+			for (const mention of mentions) await tx.execute({
+				sql: `INSERT INTO "${T.mentions}" (noteId, pageId) VALUES (?, ?)`,
+				args: [id, mention]
+			});
+			await this.#logActivity(tx, "note-added", {
+				scopeId: String(page.scopeId),
+				pageId: input.pageId,
+				noteId: id,
+				provenance: input.provenance
+			}, now);
+			return await this.#noteById(tx, id);
 		});
 	}
-	async restoreKnowledge(input) {
+	async #noteWithPage(tx, id) {
+		const note = (await this.#query(tx, `SELECT * FROM "${T.notes}" WHERE id = ?`, [id]))[0];
+		if (!note) throw new _mastra_core_storage.KnowledgeNotFoundError("note", id);
+		const page = await this.#pageRow(tx, String(note.pageId));
+		if (!page) throw new _mastra_core_storage.KnowledgeNotFoundError("page", String(note.pageId));
+		return {
+			note,
+			page
+		};
+	}
+	restampNote(input) {
 		return this.#transaction(async (tx) => {
-			const record = await this.#getKnowledge(tx, input.id, true);
-			if (!record) throw new _mastra_core_storage.KnowledgeNotFoundError("record", input.id);
-			if (!record.deletedAt) return record;
+			const { note, page } = await this.#noteWithPage(tx, input.id);
+			if (note.deletedAt) throw new _mastra_core_storage.KnowledgeNotFoundError("note", input.id);
+			if (Number(note.version) !== input.expectedVersion) throw new _mastra_core_storage.KnowledgeConflictError(input.id);
+			const stamps = [...new Set(input.stampScopeIds)];
+			await this.#assertScopes(tx, stamps);
+			const now = (/* @__PURE__ */ new Date()).toISOString();
 			await tx.execute({
-				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" SET deletedAt=NULL,deletedBy=NULL,version=version+1,updatedAt=? WHERE id=?`,
-				args: [(/* @__PURE__ */ new Date()).toISOString(), input.id]
+				sql: `DELETE FROM "${T.stamps}" WHERE noteId = ?`,
+				args: [input.id]
 			});
-			await this.#activity(tx, "record-restored", "record", input.id, record.scope, record.sourceThreadId);
-			await this.#outbox(tx, "record", input.id, "upsert", (0, _mastra_core_storage.createKnowledgeUlid)(), record.scope);
-			return {
-				...record,
-				deletedAt: void 0,
-				deletedBy: void 0
-			};
+			for (const stamp of stamps) await tx.execute({
+				sql: `INSERT INTO "${T.stamps}" (noteId, scopeId) VALUES (?, ?)`,
+				args: [input.id, stamp]
+			});
+			await tx.execute({
+				sql: `UPDATE "${T.notes}" SET version = version + 1, updatedAt = ? WHERE id = ?`,
+				args: [now, input.id]
+			});
+			await this.#logActivity(tx, "note-restamped", {
+				scopeId: String(page.scopeId),
+				pageId: String(page.id),
+				noteId: input.id,
+				provenance: input.provenance
+			}, now);
+			return await this.#noteById(tx, input.id);
 		});
 	}
-	async rescopeKnowledge(input) {
-		const scope = (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope);
+	removeNote(input) {
 		return this.#transaction(async (tx) => {
-			const record = await this.#getKnowledge(tx, input.id, true);
-			if (!record) throw new _mastra_core_storage.KnowledgeNotFoundError("record", input.id);
-			const updatedAt = /* @__PURE__ */ new Date();
+			const { note, page } = await this.#noteWithPage(tx, input.id);
+			if (note.deletedAt) throw new _mastra_core_storage.KnowledgeNotFoundError("note", input.id);
+			const now = (/* @__PURE__ */ new Date()).toISOString();
 			await tx.execute({
-				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" SET scope=jsonb(?),scopeKey=?,version=version+1,updatedAt=? WHERE id=?`,
+				sql: `UPDATE "${T.notes}" SET deletedAt = ?, deletedBy = ?, version = version + 1, updatedAt = ? WHERE id = ?`,
 				args: [
-					JSON.stringify(scope),
-					(0, _mastra_core_storage.knowledgeScopeKey)(scope),
-					updatedAt.toISOString(),
+					now,
+					input.deletedBy,
+					now,
 					input.id
 				]
 			});
-			await this.#replaceRecordScopes(tx, input.id, scope, updatedAt);
-			await this.#activity(tx, "record-rescoped", "record", input.id, scope, record.sourceThreadId);
-			if ((0, _mastra_core_storage.knowledgeScopeKey)(record.scope) !== (0, _mastra_core_storage.knowledgeScopeKey)(scope)) await this.#outbox(tx, "record", input.id, "delete", (0, _mastra_core_storage.createKnowledgeUlid)(), record.scope);
-			if (!record.deletedAt) await this.#outbox(tx, "record", input.id, "upsert", (0, _mastra_core_storage.createKnowledgeUlid)(), scope);
-			return {
-				...record,
-				scope
-			};
+			await this.#logActivity(tx, "note-removed", {
+				scopeId: String(page.scopeId),
+				pageId: String(page.id),
+				noteId: input.id,
+				provenance: input.provenance
+			}, now);
+			return await this.#noteById(tx, input.id);
 		});
 	}
-	async search(input) {
-		const scope = (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope);
-		const keys = visibleScopeKeys(scope);
-		const normalizedQuery = input.query.trim().toLocaleLowerCase();
-		if (!normalizedQuery) return [];
-		const query = `%${escapeLikePattern(normalizedQuery)}%`;
-		const results = (await this.#client.execute({
-			sql: `SELECT *,json(scope) AS scopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" WHERE mergedInto IS NULL AND ${visibleSql(keys)} AND (canonicalName LIKE ? ESCAPE '=' OR lower(COALESCE(kind,'')) LIKE ? ESCAPE '=' OR lower(COALESCE(content,'')) LIKE ? ESCAPE '=' OR lower(COALESCE(description,'')) LIKE ? ESCAPE '=') ORDER BY updatedAt DESC LIMIT ?`,
-			args: [
-				...keys,
-				query,
-				query,
-				query,
-				query,
-				input.limit ?? 20
-			]
-		})).rows.map((row) => ({
-			type: String(row.type),
-			id: String(row.id),
-			recordId: String(row.id),
-			name: String(row.name),
-			text: [
-				String(row.name),
-				...row.description ? [String(row.description)] : [],
-				...row.content ? [String(row.content)] : []
-			].join("\n"),
-			scope: parseJson$3(row.scopeJson)
-		}));
-		if (results.length < (input.limit ?? 20)) {
-			const knowledge = await this.#client.execute({
-				sql: `SELECT k.*,json(k.scope) AS scopeJson,json(k.metadata) AS metadataJson,n.name,json(n.scope) AS parentScopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" k CROSS JOIN "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" n ON n.id=k.node AND n.type='node' AND n.mergedInto IS NULL WHERE k.deletedAt IS NULL AND ${visibleSql(keys, "k.scopeKey")} AND lower(k.text) LIKE ? ESCAPE '=' ORDER BY k.id DESC LIMIT ?`,
-				args: [
-					...keys,
-					query,
-					(input.limit ?? 20) - results.length
-				]
+	restoreNote(input) {
+		return this.#transaction(async (tx) => {
+			const { note, page } = await this.#noteWithPage(tx, input.id);
+			if (!note.deletedAt) throw new _mastra_core_storage.KnowledgeNotFoundError("note", input.id);
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			await tx.execute({
+				sql: `UPDATE "${T.notes}" SET deletedAt = NULL, deletedBy = NULL, version = version + 1, updatedAt = ? WHERE id = ?`,
+				args: [now, input.id]
 			});
-			results.push(...knowledge.rows.map((row) => {
-				const parentVisible = (0, _mastra_core_storage.isKnowledgeScopeVisible)(parseJson$3(row.parentScopeJson), scope);
-				return {
-					type: "record",
-					id: String(row.id),
-					recordId: parentVisible ? String(row.node) : String(row.id),
-					name: parentVisible ? String(row.name) : "(private node)",
-					text: String(row.text),
-					scope: parseJson$3(row.scopeJson)
-				};
-			}));
-		}
-		return results;
-	}
-	/**
-	* @deprecated Curation cursors were removed. Observation-time curate is the only Knowledge writer and needs no
-	* cursor. Always throws.
-	*/
-	async getCurationCursor(_input) {
-		throw new Error(KNOWLEDGE_CURATION_CURSOR_REMOVED_MESSAGE);
-	}
-	/**
-	* @deprecated Curation cursors were removed. Observation-time curate is the only Knowledge writer and needs no
-	* cursor. Always throws.
-	*/
-	async advanceCurationCursor(_input) {
-		throw new Error(KNOWLEDGE_CURATION_CURSOR_REMOVED_MESSAGE);
+			await this.#logActivity(tx, "note-restored", {
+				scopeId: String(page.scopeId),
+				pageId: String(page.id),
+				noteId: input.id,
+				provenance: input.provenance
+			}, now);
+			return await this.#noteById(tx, input.id);
+		});
 	}
-	async listActivity(input) {
-		const keys = visibleScopeKeys((0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope));
-		return (await this.#client.execute({
-			sql: `SELECT *,json(scope) AS scopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_ACTIVITY}" WHERE ${visibleSql(keys)}${input.after ? " AND id < ?" : ""} ORDER BY id DESC LIMIT ?`,
-			args: [
-				...keys,
-				...input.after ? [input.after] : [],
-				input.limit ?? 100
-			]
-		})).rows.map((row) => ({
-			id: String(row.id),
-			action: String(row.action),
-			recordType: String(row.recordType),
-			recordId: String(row.recordId),
-			scope: parseJson$3(row.scopeJson),
-			sourceThreadId: row.sourceThreadId == null ? void 0 : String(row.sourceThreadId),
-			createdAt: toDate(row.createdAt)
+	async searchPages(input) {
+		const words = knowledgeSearchWords(input.query);
+		if (!words.length) return [];
+		const phrase = input.query.trim().toLowerCase().replace(/\s+/g, " ");
+		const limit = Math.max(1, input.limit ?? 20);
+		const likes = words.map((word) => `%${escapeLike(word)}%`);
+		const readable = pageReadable("p", input.read);
+		const scopeFilter = input.scopeIds ? ` AND p.scopeId IN (SELECT value FROM json_each(?))` : "";
+		const scopeArgs = input.scopeIds ? [jsonList(input.scopeIds)] : [];
+		const field = (column) => `lower(COALESCE(${column}, '')) LIKE ? ESCAPE '='`;
+		const pageMatch = words.map(() => `(${field("p.name")} OR ${field("p.description")} OR ${field("p.body")})`).join(" OR ");
+		const pageScore = words.map(() => `(CASE WHEN ${field("p.name")} THEN ${KNOWLEDGE_SEARCH_WEIGHTS.name} WHEN ${field("p.description")} THEN ${KNOWLEDGE_SEARCH_WEIGHTS.description} WHEN ${field("p.body")} THEN ${KNOWLEDGE_SEARCH_WEIGHTS.body} ELSE 0 END)`).join(" + ");
+		const pageCount = words.map(() => `(CASE WHEN ${field("p.name")} OR ${field("p.description")} OR ${field("p.body")} THEN 1 ELSE 0 END)`).join(" + ");
+		const triple = likes.flatMap((like) => [
+			like,
+			like,
+			like
+		]);
+		const hits = (await this.#query(this.#read, `SELECT p.* FROM "${T.pages}" p WHERE p.deletedAt IS NULL AND p.isScope = 0 AND ${readable.sql}${scopeFilter} AND (${pageMatch}) ORDER BY CASE WHEN instr(p.canonicalName, ?) > 0 THEN 0 ELSE 1 END, (${pageCount}) DESC, (${pageScore}) DESC, p.updatedAt DESC, p.id ASC LIMIT ?`, [
+			...readable.args,
+			...scopeArgs,
+			...triple,
+			phrase,
+			...triple,
+			...triple,
+			limit
+		])).map((row) => ({
+			type: "page",
+			page: toPage(row)
 		}));
-	}
-	async listSemanticOutbox(input = {}) {
-		const clauses = [];
-		const args = [];
-		if (input.status) {
-			clauses.push("status=?");
-			args.push(input.status);
-		}
-		if (input.scope) {
-			const keys = visibleScopeKeys(input.scope);
-			clauses.push(visibleSql(keys));
-			args.push(...keys);
+		if (hits.length >= limit) return hits;
+		const noteVisible = noteReadable("n", input.read);
+		const noteHas = words.map(() => `lower(n.text) LIKE ? ESCAPE '='`);
+		const noteRows = await this.#query(this.#read, `SELECT n.* FROM "${T.notes}" n JOIN "${T.pages}" p ON p.id = n.pageId WHERE n.deletedAt IS NULL AND p.deletedAt IS NULL${scopeFilter} AND (${noteHas.join(" OR ")}) AND ${noteVisible.sql} ORDER BY (${noteHas.map((has) => `(CASE WHEN ${has} THEN 1 ELSE 0 END)`).join(" + ")}) DESC, n.updatedAt DESC, n.id DESC LIMIT ?`, [
+			...scopeArgs,
+			...likes,
+			...noteVisible.args,
+			...likes,
+			limit - hits.length
+		]);
+		const notes = await this.#hydrateNotes(this.#read, noteRows);
+		for (const note of notes) {
+			const page = await this.#pageRow(this.#read, note.pageId);
+			if (page) hits.push({
+				type: "note",
+				note,
+				page: toPage(page)
+			});
 		}
-		args.push(input.limit ?? 100);
-		return (await this.#client.execute({
-			sql: `SELECT *,json(scope) AS scopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}"${clauses.length ? ` WHERE ${clauses.join(" AND ")}` : ""} ORDER BY createdAt ASC,id ASC LIMIT ?`,
-			args
-		})).rows.map(parseOutbox);
+		return hits;
+	}
+	async listPageActivity(input) {
+		const core = await loadPagesCore();
+		const limit = limitOf(input.limit, core.MAX_KNOWLEDGE_PAGE_LIST_LIMIT);
+		const cursor = decodeCursor(input.cursor, 1);
+		const readable = pageReadable("p", input.read);
+		const noteVisible = noteReadable("n", input.read);
+		const args = [...readable.args];
+		let filters = "";
+		if (input.scopeId !== void 0) {
+			filters += ` AND p.scopeId = ?`;
+			args.push(input.scopeId);
+		}
+		if (input.pageId !== void 0) {
+			filters += ` AND e.pageId = ?`;
+			args.push(input.pageId);
+		}
+		if (cursor) {
+			filters += ` AND e.id < ?`;
+			args.push(cursor[0]);
+		}
+		args.push(...noteVisible.args, limit + 1);
+		const rows = await this.#query(this.#read, `SELECT e.* FROM "${T.activity}" e JOIN "${T.pages}" p ON p.id = e.pageId WHERE ${readable.sql}${filters} AND (e.noteId IS NULL OR EXISTS (SELECT 1 FROM "${T.notes}" n WHERE n.id = e.noteId AND ${noteVisible.sql})) ORDER BY e.id DESC LIMIT ?`, args);
+		const page = rows.slice(0, limit);
+		return {
+			events: page.map((row) => ({
+				id: String(row.id),
+				action: String(row.action),
+				scopeId: String(row.scopeId),
+				pageId: String(row.pageId),
+				...row.noteId ? { noteId: String(row.noteId) } : {},
+				provenance: provenance(row.provenance),
+				createdAt: new Date(String(row.createdAt))
+			})),
+			...rows.length > limit ? { nextCursor: encodeCursor([String(page[page.length - 1].id)]) } : {}
+		};
 	}
-	async claimSemanticOutbox(input) {
-		const now = input.now ?? /* @__PURE__ */ new Date();
-		const stale = new Date(now.getTime() - (input.claimTimeoutMs ?? 6e4));
+	/** Rewrites the audience index rows of one pin to match `audience`. */
+	async #indexAudience(tx, pinId, audience) {
+		await tx.execute({
+			sql: `DELETE FROM "${T.pinAudiences}" WHERE pinId = ?`,
+			args: [pinId]
+		});
+		for (const entry of audience) await tx.execute({
+			sql: `INSERT OR IGNORE INTO "${T.pinAudiences}" (pinId, audience) VALUES (?, ?)`,
+			args: [pinId, entry]
+		});
+	}
+	addPinAudience(input) {
 		return this.#transaction(async (tx) => {
-			const clauses = [
-				`availableAt <= ?`,
-				`(status='pending' OR (status='processing' AND claimedAt <= ?))`,
-				`NOT EXISTS (SELECT 1 FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" AS earlier WHERE earlier.documentId = "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}".documentId AND earlier.status != 'completed' AND (earlier.createdAt < "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}".createdAt OR (earlier.createdAt = "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}".createdAt AND earlier.id < "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}".id)))`
-			];
-			const args = [now.toISOString(), stale.toISOString()];
-			if (input.scope) {
-				const keys = visibleScopeKeys(input.scope);
-				clauses.push(visibleSql(keys));
-				args.push(...keys);
+			const page = await this.#livePage(tx, input.pageId);
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const existing = (await this.#query(tx, `SELECT * FROM "${T.pins}" WHERE pageId = ?`, [input.pageId]))[0];
+			if (!existing) {
+				const id = (0, _mastra_core_storage.createKnowledgeUlid)();
+				await tx.execute({
+					sql: `INSERT INTO "${T.pins}" (id, pageId, audience, createdBy, createdAt, updatedAt) VALUES (?, ?, ?, ?, ?, ?)`,
+					args: [
+						id,
+						input.pageId,
+						JSON.stringify([...new Set(input.audience)]),
+						input.createdBy,
+						now,
+						now
+					]
+				});
+				await this.#indexAudience(tx, id, [...new Set(input.audience)]);
+				await this.#logActivity(tx, "pin-added", {
+					scopeId: String(page.scopeId),
+					pageId: input.pageId,
+					provenance: { author: input.createdBy }
+				}, now);
+				return toPin((await this.#query(tx, `SELECT * FROM "${T.pins}" WHERE id = ?`, [id]))[0]);
 			}
-			args.push(input.limit ?? 100);
-			const ids = (await tx.execute({
-				sql: `SELECT id FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" WHERE ${clauses.join(" AND ")} ORDER BY createdAt ASC,id ASC LIMIT ?`,
-				args
-			})).rows.map((row) => String(row.id));
-			for (const id of ids) await tx.execute({
-				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" SET status='processing',attempts=attempts+1,claimedAt=?,claimedBy=? WHERE id=?`,
-				args: [
-					now.toISOString(),
-					input.workerId,
-					id
-				]
-			});
-			if (!ids.length) return [];
-			return (await tx.execute({
-				sql: `SELECT *,json(scope) AS scopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" WHERE id IN (${ids.map(() => "?").join(",")}) ORDER BY createdAt ASC,id ASC`,
-				args: ids
-			})).rows.map(parseOutbox);
+			const current = JSON.parse(String(existing.audience));
+			const merged = [.../* @__PURE__ */ new Set([...current, ...input.audience])];
+			if (merged.length !== current.length) {
+				await tx.execute({
+					sql: `UPDATE "${T.pins}" SET audience = ?, updatedAt = ? WHERE id = ?`,
+					args: [
+						JSON.stringify(merged),
+						now,
+						String(existing.id)
+					]
+				});
+				await this.#indexAudience(tx, String(existing.id), merged);
+				await this.#logActivity(tx, "pin-added", {
+					scopeId: String(page.scopeId),
+					pageId: input.pageId,
+					provenance: { author: input.createdBy }
+				}, now);
+			}
+			return toPin((await this.#query(tx, `SELECT * FROM "${T.pins}" WHERE id = ?`, [String(existing.id)]))[0]);
 		});
 	}
-	async completeSemanticOutbox(input) {
-		if (!input.ids.length) return;
-		const now = (/* @__PURE__ */ new Date()).toISOString();
-		await this.#transaction(async (tx) => {
-			for (const id of input.ids) await tx.execute({
-				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" SET status='completed',completedAt=? WHERE id=? AND status='processing' AND claimedBy=?`,
+	removePinAudience(input) {
+		return this.#transaction(async (tx) => {
+			const existing = (await this.#query(tx, `SELECT * FROM "${T.pins}" WHERE pageId = ?`, [input.pageId]))[0];
+			if (!existing) return null;
+			const current = JSON.parse(String(existing.audience));
+			const remove = new Set(input.audience);
+			const remaining = current.filter((entry) => !remove.has(entry));
+			if (remaining.length === current.length) return toPin(existing);
+			const page = await this.#pageRow(tx, input.pageId);
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			if (page) await this.#logActivity(tx, "pin-removed", {
+				scopeId: String(page.scopeId),
+				pageId: input.pageId,
+				provenance: { author: input.removedBy }
+			}, now);
+			if (remaining.length === 0) {
+				await this.#indexAudience(tx, String(existing.id), []);
+				await tx.execute({
+					sql: `DELETE FROM "${T.pins}" WHERE id = ?`,
+					args: [String(existing.id)]
+				});
+				return null;
+			}
+			await tx.execute({
+				sql: `UPDATE "${T.pins}" SET audience = ?, updatedAt = ? WHERE id = ?`,
 				args: [
+					JSON.stringify(remaining),
 					now,
-					id,
-					input.workerId
-				]
-			});
-		});
-	}
-	async releaseSemanticOutbox(input) {
-		if (!input.ids.length) return;
-		await this.#transaction(async (tx) => {
-			for (const id of input.ids) await tx.execute({
-				sql: `UPDATE "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" SET status='pending',availableAt=?,claimedAt=NULL,claimedBy=NULL WHERE id=? AND status='processing' AND claimedBy=?`,
-				args: [
-					(input.retryAt ?? /* @__PURE__ */ new Date()).toISOString(),
-					id,
-					input.workerId
+					String(existing.id)
 				]
 			});
+			await this.#indexAudience(tx, String(existing.id), remaining);
+			return toPin((await this.#query(tx, `SELECT * FROM "${T.pins}" WHERE id = ?`, [String(existing.id)]))[0]);
 		});
 	}
-	async #transaction(operation) {
-		return this.#db.executeWriteOperationWithRetry(() => withClientWriteLock(this.#client, async () => {
-			const tx = await this.#client.transaction("write");
-			try {
-				const result = await operation(tx);
-				await tx.commit();
-				return result;
-			} catch (error) {
-				if (!tx.closed) await tx.rollback();
-				throw error;
-			}
-		}), "write knowledge state");
-	}
-	async #getNode(executor, id) {
-		const result = await executor.execute({
-			sql: `SELECT *,json(scope) AS scopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" WHERE id=? AND type='node'`,
-			args: [id]
-		});
-		return result.rows[0] ? parseNode(result.rows[0]) : null;
+	async listPins(input) {
+		const core = await loadPagesCore();
+		const limit = limitOf(input.limit, core.MAX_KNOWLEDGE_PAGE_LIST_LIMIT);
+		const cursor = decodeCursor(input.cursor, 2);
+		const readable = pageReadable("p", input.read);
+		const args = [...readable.args];
+		let filters = "";
+		if (input.audience !== "all") {
+			filters += ` AND pin.id IN (SELECT pa.pinId FROM json_each(?) a JOIN "${T.pinAudiences}" pa ON pa.audience = a.value)`;
+			args.push(jsonList(input.audience));
+		}
+		if (input.pageIds) {
+			filters += ` AND pin.pageId IN (SELECT value FROM json_each(?))`;
+			args.push(jsonList(input.pageIds));
+		}
+		if (input.excludePageIds?.length) {
+			filters += ` AND pin.pageId NOT IN (SELECT value FROM json_each(?))`;
+			args.push(jsonList(input.excludePageIds));
+		}
+		if (input.withBody) filters += ` AND p.body IS NOT NULL AND trim(p.body, char(32, 9, 10, 11, 12, 13)) <> ''`;
+		const from = `FROM "${T.pins}" pin JOIN "${T.pages}" p ON p.id = pin.pageId WHERE p.deletedAt IS NULL AND ${readable.sql}${filters}`;
+		let total;
+		if (input.count) total = Number((await this.#query(this.#read, `SELECT COUNT(*) AS n ${from}`, args))[0].n);
+		const pageArgs = [...args];
+		let cursorFilter = "";
+		if (cursor) {
+			cursorFilter = ` AND (pin.createdAt < ? OR (pin.createdAt = ? AND pin.id < ?))`;
+			pageArgs.push(cursor[0], cursor[0], cursor[1]);
+		}
+		pageArgs.push(limit + 1);
+		const rows = await this.#query(this.#read, `SELECT pin.*, p.name AS pageName ${from}${cursorFilter} ORDER BY pin.createdAt DESC, pin.id DESC LIMIT ?`, pageArgs);
+		const page = rows.slice(0, limit);
+		return {
+			pins: page.map(toListedPin),
+			...rows.length > limit ? { nextCursor: encodeCursor([String(page[page.length - 1].createdAt), String(page[page.length - 1].id)]) } : {},
+			...total === void 0 ? {} : { total }
+		};
 	}
-	async #getNodeByName(executor, name, scope) {
-		const result = await executor.execute({
-			sql: `SELECT *,json(scope) AS scopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" WHERE type='node' AND scopeKey=? AND canonicalName=?`,
-			args: [(0, _mastra_core_storage.knowledgeScopeKey)(scope), canonicalName(name)]
-		});
-		return result.rows[0] ? parseNode(result.rows[0]) : null;
-	}
-	async #resolveNode(executor, name, scope) {
-		const keys = visibleScopeKeys(scope);
-		const candidates = (await executor.execute({
-			sql: `SELECT *,json(scope) AS scopeJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" WHERE type='node' AND canonicalName=? AND (scopeKey IN (${keys.map(() => "?").join(",")}) OR mergedInto IS NOT NULL)`,
-			args: [canonicalName(name), ...keys]
-		})).rows.map(parseNode).sort((left, right) => right.scope.length - left.scope.length);
-		for (const candidate of candidates) {
-			const terminal = await this.#resolveTerminalNode(executor, candidate.id);
-			if (terminal && (0, _mastra_core_storage.isKnowledgeScopeVisible)(terminal.scope, scope)) return terminal;
-		}
-		return null;
-	}
-	async #resolveTerminalNode(executor, id) {
-		let node = await this.#getNode(executor, id);
-		const seen = /* @__PURE__ */ new Set();
-		while (node?.mergedInto) {
-			if (seen.has(node.id)) throw new Error(`Knowledge merge cycle detected at ${node.id}`);
-			seen.add(node.id);
-			node = await this.#getNode(executor, node.mergedInto);
+};
+// src/storage/domains/knowledge/index.ts
+function canonicalizeLibSQLUrl(url) {
+	if (url.includes(":memory:")) return /[?&]cache=shared(?:&|$)/.test(url) ? "file::memory:?cache=shared" : void 0;
+	if (url.startsWith("file:")) {
+		const [path$1] = url.slice(5).split("?");
+		if (url.startsWith("file://")) {
+			const parsed = new URL(url);
+			const host = parsed.hostname.toLocaleLowerCase();
+			const filePath = host && host !== "localhost" ? `//${host}${parsed.pathname}` : parsed.pathname;
+			return `file:${(0, path.resolve)(decodeURIComponent(filePath))}`;
 		}
-		return node;
+		return `file:${(0, path.resolve)(decodeURIComponent(path$1))}`;
 	}
-	async #getKnowledge(executor, id, includeDeleted) {
-		const result = await executor.execute({
-			sql: `SELECT *,json(scope) AS scopeJson,json(metadata) AS metadataJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" WHERE id=?${includeDeleted ? "" : " AND deletedAt IS NULL"}`,
-			args: [id]
+	try {
+		const parsed = new URL(url);
+		const port = parsed.port || (parsed.protocol === "libsql:" || parsed.protocol === "https:" ? "443" : "80");
+		return `${parsed.protocol}//${parsed.hostname.toLocaleLowerCase()}:${port}${parsed.pathname}`;
+	} catch {
+		return url;
+	}
+}
+const unidentifiedClientIsolationKey = {};
+function getLibSQLKnowledgeIsolationKey(config, client) {
+	if (config.storageIsolationKey !== void 0) return config.storageIsolationKey;
+	if (!config.url) return unidentifiedClientIsolationKey;
+	const urlKey = canonicalizeLibSQLUrl(config.url);
+	return urlKey ? `libsql:${urlKey}` : client ?? config.client ?? config;
+}
+var KnowledgeLibSQL = class extends _mastra_core_storage.KnowledgeStorage {
+	#client;
+	#db;
+	#pages;
+	constructor(config) {
+		const client = resolveClient(config);
+		const storageIsolationKey = config.storageIsolationKey ?? getLibSQLKnowledgeIsolationKey(config, client);
+		super({ storageIsolationKey });
+		this.#client = client;
+		this.#db = new LibSQLDB({
+			client: this.#client,
+			maxRetries: config.maxRetries,
+			initialBackoffMs: config.initialBackoffMs
 		});
-		return result.rows[0] ? parseKnowledge(result.rows[0]) : null;
-	}
-	async #queryKnowledge(input, relationship) {
-		const scope = (0, _mastra_core_storage.canonicalizeKnowledgeScope)(input.scope);
-		const node = await this.#resolveTerminalNode(this.#client, nodeReferenceId(input.node));
-		if (!node) return { records: [] };
-		const keys = visibleScopeKeys(scope);
-		const includesMentions = relationship !== "about";
-		const relationSql = relationship === "about" ? "k.node=?" : relationship === "mentioning" ? "m.recordId=?" : "(k.node=? OR m.recordId=?)";
-		const args = [
-			node.id,
-			...relationship === "related" ? [node.id] : [],
-			...keys
-		];
-		if (input.after) args.push(input.after);
-		args.push((input.limit ?? 100) + 1);
-		const result = await this.#client.execute({
-			sql: `SELECT DISTINCT k.*,json(k.scope) AS scopeJson,json(k.metadata) AS metadataJson FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_RECORDS}" k${includesMentions ? ` LEFT JOIN "${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}" m ON m.sourceType='record' AND m.sourceId=k.id` : ""} WHERE ${relationSql} AND ${visibleSql(keys, "k.scopeKey")}${input.includeDeleted ? "" : " AND k.deletedAt IS NULL"}${input.after ? " AND k.id < ?" : ""} ORDER BY k.id DESC LIMIT ?`,
-			args
+		this.#pages = new LibSQLKnowledgePages({
+			read: this.#client,
+			transaction: (operation) => this.#transaction(operation)
 		});
-		const limit = input.limit ?? 100;
-		const rows = result.rows.slice(0, limit);
+	}
+	getCapabilities() {
 		return {
-			records: rows.map(parseKnowledge),
-			nextCursor: result.rows.length > limit ? String(rows.at(-1)?.id) : void 0
+			contractVersion: 4,
+			schemaVersion: 4,
+			supportsSchemaInspection: true,
+			supportsExplicitReset: true
 		};
 	}
-	async #resolveScopeNodeIds(executor, addresses) {
-		const scopeNodeIds = /* @__PURE__ */ new Set();
-		for (const address of addresses) {
-			const result = await executor.execute({
-				sql: `SELECT scopeNodeId FROM "${TABLE_KNOWLEDGE_SCOPE_ADDRESSES}" WHERE address=?`,
-				args: [address]
-			});
-			if (result.rows[0]?.scopeNodeId != null) scopeNodeIds.add(String(result.rows[0].scopeNodeId));
-		}
-		return [...scopeNodeIds];
-	}
-	async #replaceNodeScopes(executor, nodeId, addresses, addedAt) {
-		await executor.execute({
-			sql: `DELETE FROM "${TABLE_KNOWLEDGE_NODE_SCOPES}" WHERE nodeId=?`,
-			args: [nodeId]
-		});
-		for (const scopeNodeId of await this.#resolveScopeNodeIds(executor, addresses)) await executor.execute({
-			sql: `INSERT OR IGNORE INTO "${TABLE_KNOWLEDGE_NODE_SCOPES}" (nodeId,scopeNodeId,addedAt) VALUES (?,?,?)`,
-			args: [
-				nodeId,
-				scopeNodeId,
-				addedAt.toISOString()
-			]
-		});
+	async dangerouslyClearAll() {
+		await this.#pages.clearAll();
 	}
-	/**
-	* Move a node's identity memberships from `from` to `to` without touching structural
-	* placements added by `#placeNodeInScopes`, which a scope change must not erase.
-	*/
-	async #swapIdentityScopes(executor, nodeId, from, to, addedAt) {
-		const next = await this.#resolveScopeNodeIds(executor, to);
-		for (const scopeNodeId of await this.#resolveScopeNodeIds(executor, from)) {
-			if (next.includes(scopeNodeId)) continue;
-			await executor.execute({
-				sql: `DELETE FROM "${TABLE_KNOWLEDGE_NODE_SCOPES}" WHERE nodeId=? AND scopeNodeId=?`,
-				args: [nodeId, scopeNodeId]
-			});
-		}
-		for (const scopeNodeId of next) await executor.execute({
-			sql: `INSERT OR IGNORE INTO "${TABLE_KNOWLEDGE_NODE_SCOPES}" (nodeId,scopeNodeId,addedAt) VALUES (?,?,?)`,
-			args: [
-				nodeId,
-				scopeNodeId,
-				addedAt.toISOString()
-			]
-		});
+	async #inspectPages(tx) {
+		return inspectKnowledgePagesSchema(await this.#pagesSnapshot(tx));
 	}
-	/**
-	* Additive structural placement: every address must resolve to a live scope node
-	* (unlike identity membership, an unknown address is a caller error, not a lazy
-	* materialization miss). Runs inside the caller's transaction, so a throw aborts
-	* the whole mutation.
-	*/
-	async #placeNodeInScopes(executor, nodeId, addresses, addedAt) {
-		for (const address of addresses ?? []) {
-			const scopeNodeId = (await executor.execute({
-				sql: `SELECT sa.scopeNodeId AS scopeNodeId FROM "${TABLE_KNOWLEDGE_SCOPE_ADDRESSES}" sa JOIN "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" n ON n.id=sa.scopeNodeId WHERE sa.address=? AND n.isScope AND n.deletedAt IS NULL`,
-				args: [address]
-			})).rows[0]?.scopeNodeId;
-			if (scopeNodeId == null) throw new _mastra_core_storage.KnowledgeNotFoundError("scope", address);
-			await executor.execute({
-				sql: `INSERT OR IGNORE INTO "${TABLE_KNOWLEDGE_NODE_SCOPES}" (nodeId,scopeNodeId,addedAt) VALUES (?,?,?)`,
-				args: [
-					nodeId,
-					String(scopeNodeId),
-					addedAt.toISOString()
-				]
-			});
+	async #pagesSnapshot(tx) {
+		const tableNames = (await tx.execute({ sql: "SELECT name FROM sqlite_master WHERE type = 'table' AND name LIKE 'mastra\\_knowledge\\_%' ESCAPE '\\'" })).rows.map((row) => String(row.name));
+		let schemaVersion;
+		if (tableNames.includes("mastra_knowledge_access_state")) {
+			const state = await tx.execute({ sql: `SELECT schemaVersion FROM "${TABLE_KNOWLEDGE_PAGES_STATE}" WHERE id = 'knowledge'` });
+			if (state.rows[0]) schemaVersion = Number(state.rows[0].schemaVersion);
 		}
+		return {
+			tableNames,
+			schemaVersion
+		};
 	}
-	async #replaceRecordScopes(executor, recordId, addresses, addedAt) {
-		await executor.execute({
-			sql: `DELETE FROM "${TABLE_KNOWLEDGE_RECORD_SCOPES}" WHERE recordId=?`,
-			args: [recordId]
-		});
-		for (const scopeNodeId of await this.#resolveScopeNodeIds(executor, addresses)) await executor.execute({
-			sql: `INSERT OR IGNORE INTO "${TABLE_KNOWLEDGE_RECORD_SCOPES}" (recordId,scopeNodeId,addedAt) VALUES (?,?,?)`,
-			args: [
-				recordId,
-				scopeNodeId,
-				addedAt.toISOString()
-			]
-		});
+	async inspectSchema() {
+		return this.#inspectPages(this.#client);
 	}
-	async #replaceMentions(tx, sourceType, sourceId, text, resolutionScope, defaultScope) {
-		await tx.execute({
-			sql: `DELETE FROM "${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}" WHERE sourceType=? AND sourceId=?`,
-			args: [sourceType, sourceId]
-		});
-		for (const name of (0, _mastra_core_storage.parseKnowledgeWikilinks)(text)) {
-			let node = await this.#resolveNode(tx, name, resolutionScope);
-			if (!node) {
-				node = await this.#getNodeByName(tx, name, defaultScope);
-				if (node) node = await this.#resolveTerminalNode(tx, node.id);
-				if (!node) {
-					const now = /* @__PURE__ */ new Date();
-					node = {
-						id: crypto.randomUUID(),
-						type: "node",
-						name,
-						kind: "node",
-						scope: defaultScope,
-						version: 1,
-						createdAt: now,
-						updatedAt: now
-					};
-					await tx.execute({
-						sql: `INSERT INTO "${_mastra_core_storage.TABLE_KNOWLEDGE_NODES}" (id,type,name,canonicalName,kind,content,isScope,scope,scopeKey,version,mergedInto,createdAt,updatedAt) VALUES (?,?,?,?,?,NULL,FALSE,jsonb(?),?,?,NULL,?,?)`,
-						args: [
-							node.id,
-							"node",
-							node.name,
-							canonicalName(node.name),
-							node.kind,
-							JSON.stringify(defaultScope),
-							(0, _mastra_core_storage.knowledgeScopeKey)(defaultScope),
-							1,
-							now.toISOString(),
-							now.toISOString()
-						]
-					});
-					await this.#replaceNodeScopes(tx, node.id, defaultScope, now);
-					await this.#activity(tx, "node-created", "node", node.id, defaultScope);
-					await this.#outbox(tx, "node", node.id, "upsert", 1, defaultScope);
-				}
-			}
+	async init() {
+		await this.#transaction(async (tx) => {
+			for (const table of legacyKnowledgeTablesToDrop(await this.#pagesSnapshot(tx))) await tx.execute(`DROP TABLE IF EXISTS "${table}"`);
+			const inspection = await this.#inspectPages(tx);
+			if (inspection.status === "incompatible-reset-required") throw new _mastra_core_storage.KnowledgeSchemaResetRequiredError(inspection);
+			for (const statement of KNOWLEDGE_PAGE_DDL) await tx.execute(statement);
 			await tx.execute({
-				sql: `INSERT OR IGNORE INTO "${_mastra_core_storage.TABLE_KNOWLEDGE_MENTIONS}" (sourceType,sourceId,recordId) VALUES (?,?,?)`,
-				args: [
-					sourceType,
-					sourceId,
-					node.id
-				]
+				sql: `INSERT OR IGNORE INTO "${TABLE_KNOWLEDGE_PAGES_STATE}" (id, schemaVersion) VALUES ('knowledge', ?)`,
+				args: [4]
 			});
-		}
-	}
-	async #activity(executor, action, recordType, recordId, scope, sourceThreadId) {
-		const now = /* @__PURE__ */ new Date();
-		const [contextScopeId] = await this.#resolveScopeNodeIds(executor, scope);
-		await executor.execute({
-			sql: `INSERT INTO "${_mastra_core_storage.TABLE_KNOWLEDGE_ACTIVITY}" (id,action,targetType,targetId,contextScopeId,recordType,recordId,scope,scopeKey,sourceThreadId,createdAt) VALUES (?,?,?,?,?,?,?,jsonb(?),?,?,?)`,
-			args: [
-				(0, _mastra_core_storage.createKnowledgeUlid)(),
-				action,
-				recordType,
-				recordId,
-				contextScopeId ?? null,
-				recordType,
-				recordId,
-				JSON.stringify(scope),
-				(0, _mastra_core_storage.knowledgeScopeKey)(scope),
-				sourceThreadId ?? null,
-				now.toISOString()
-			]
 		});
 	}
-	async #outbox(executor, documentType, id, operation, version, scope) {
-		const documentId = (0, _mastra_core_storage.knowledgeSemanticDocumentId)(documentType, id);
-		const idempotencyKey = (0, _mastra_core_storage.knowledgeSemanticIdempotencyKey)(documentId, operation, version);
-		const now = /* @__PURE__ */ new Date();
-		await executor.execute({
-			sql: `INSERT OR IGNORE INTO "${_mastra_core_storage.TABLE_KNOWLEDGE_SEMANTIC_OUTBOX}" (id,idempotencyKey,documentId,documentType,operation,scope,scopeKey,status,attempts,availableAt,claimedAt,claimedBy,createdAt,completedAt) VALUES (?,?,?,?,?,jsonb(?),?,'pending',0,?,NULL,NULL,?,NULL)`,
-			args: [
-				(0, _mastra_core_storage.createKnowledgeUlid)(),
-				idempotencyKey,
-				documentId,
-				documentType,
-				operation,
-				JSON.stringify(scope),
-				(0, _mastra_core_storage.knowledgeScopeKey)(scope),
-				now.toISOString(),
-				now.toISOString()
-			]
+	async dangerouslyReset() {
+		await withClientWriteLock(this.#client, async () => {
+			await this.#client.batch([...KNOWLEDGE_RESETTABLE_TABLE_NAMES, KNOWLEDGE_PAGE_TABLES.pinAudiences].map((table) => ({
+				sql: `DROP TABLE IF EXISTS "${table}"`,
+				args: []
+			})), "write");
 		});
+		await this.init();
+	}
+	materializeScope(input) {
+		return this.#pages.materializeScope(input);
+	}
+	listScopeDeclarations() {
+		return this.#pages.listScopeDeclarations();
+	}
+	renameScopeDeclaration(input) {
+		return this.#pages.renameScopeDeclaration(input);
+	}
+	getScopesByAddress(input) {
+		return this.#pages.getScopesByAddress(input);
+	}
+	listChildScopes(input) {
+		return this.#pages.listChildScopes(input);
+	}
+	getPage(input) {
+		return this.#pages.getPage(input);
+	}
+	getPageByPath(input) {
+		return this.#pages.getPageByPath(input);
+	}
+	findPagesByName(input) {
+		return this.#pages.findPagesByName(input);
+	}
+	listChildPages(input) {
+		return this.#pages.listChildPages(input);
+	}
+	listPages(input) {
+		return this.#pages.listPages(input);
+	}
+	createPage(input) {
+		return this.#pages.createPage(input);
+	}
+	updatePage(input) {
+		return this.#pages.updatePage(input);
+	}
+	movePage(input) {
+		return this.#pages.movePage(input);
+	}
+	mergePages(input) {
+		return this.#pages.mergePages(input);
+	}
+	deletePage(input) {
+		return this.#pages.deletePage(input);
+	}
+	getNote(input) {
+		return this.#pages.getNote(input);
+	}
+	listNotes(input) {
+		return this.#pages.listNotes(input);
+	}
+	countChildPages(input) {
+		return this.#pages.countChildPages(input);
+	}
+	countNotes(input) {
+		return this.#pages.countNotes(input);
+	}
+	listNotesMentioning(input) {
+		return this.#pages.listNotesMentioning(input);
+	}
+	addNote(input) {
+		return this.#pages.addNote(input);
+	}
+	restampNote(input) {
+		return this.#pages.restampNote(input);
+	}
+	removeNote(input) {
+		return this.#pages.removeNote(input);
+	}
+	restoreNote(input) {
+		return this.#pages.restoreNote(input);
+	}
+	searchPages(input) {
+		return this.#pages.searchPages(input);
+	}
+	listPageActivity(input) {
+		return this.#pages.listPageActivity(input);
+	}
+	addPinAudience(input) {
+		return this.#pages.addPinAudience(input);
+	}
+	removePinAudience(input) {
+		return this.#pages.removePinAudience(input);
+	}
+	getPages(input) {
+		return this.#pages.getPages(input);
+	}
+	listPins(input) {
+		return this.#pages.listPins(input);
+	}
+	async #transaction(operation) {
+		return this.#db.executeWriteOperationWithRetry(() => withClientWriteLock(this.#client, async () => {
+			const tx = await this.#client.transaction("write");
+			try {
+				const result = await operation(tx);
+				await tx.commit();
+				return result;
+			} catch (error) {
+				if (!tx.closed) await tx.rollback();
+				throw error;
+			}
+		}), "write knowledge state");
 	}
 };
 // src/storage/domains/mcp-clients/index.ts