dineway 0.1.9 → 0.1.12

package/dist/briefing-MVYe_Uyf.mjs

@@ -0,0 +1,1294 @@
+import { n as decodeCursor, r as encodeCursor } from "./types-Bs6lTBBW.mjs";
+import { t as SiteActivityRepository } from "./site-activity-B8FjLIVh.mjs";
+import { t as ReviewRequestRepository } from "./review-requests-C2DIHwlJ.mjs";
+import { t as withTransaction } from "./transaction-x2tJQ-A1.mjs";
+import { n as isSiteContextType, t as SITE_CONTEXT_TYPES } from "./context-types-C-LwdAxx.mjs";
+import { n as SchemaRegistry } from "./registry-C-_hxLqa.mjs";
+import { a as getSiteSettingsWithDb } from "./settings-DGtLLSaz.mjs";
+import { sql } from "kysely";
+import { ulid } from "ulidx";
+
+//#region src/plugins/state.ts
+function toPluginStatus(value) {
+	if (value === "active") return "active";
+	return "inactive";
+}
+function toPluginSource(value) {
+	if (value === "marketplace") return "marketplace";
+	return "config";
+}
+/**
+* Repository for plugin state in the database
+*/
+var PluginStateRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	/**
+	* Get state for a specific plugin
+	*/
+	async get(pluginId) {
+		const row = await this.db.selectFrom("_plugin_state").selectAll().where("plugin_id", "=", pluginId).executeTakeFirst();
+		if (!row) return null;
+		return {
+			pluginId: row.plugin_id,
+			status: toPluginStatus(row.status),
+			version: row.version,
+			installedAt: new Date(row.installed_at),
+			activatedAt: row.activated_at ? new Date(row.activated_at) : null,
+			deactivatedAt: row.deactivated_at ? new Date(row.deactivated_at) : null,
+			source: toPluginSource(row.source),
+			marketplaceVersion: row.marketplace_version ?? null,
+			displayName: row.display_name ?? null,
+			description: row.description ?? null
+		};
+	}
+	/**
+	* Get all plugin states
+	*/
+	async getAll() {
+		return (await this.db.selectFrom("_plugin_state").selectAll().execute()).map((row) => ({
+			pluginId: row.plugin_id,
+			status: toPluginStatus(row.status),
+			version: row.version,
+			installedAt: new Date(row.installed_at),
+			activatedAt: row.activated_at ? new Date(row.activated_at) : null,
+			deactivatedAt: row.deactivated_at ? new Date(row.deactivated_at) : null,
+			source: toPluginSource(row.source),
+			marketplaceVersion: row.marketplace_version ?? null,
+			displayName: row.display_name ?? null,
+			description: row.description ?? null
+		}));
+	}
+	/**
+	* Get all marketplace-installed plugin states
+	*/
+	async getMarketplacePlugins() {
+		return (await this.db.selectFrom("_plugin_state").selectAll().where("source", "=", "marketplace").execute()).map((row) => ({
+			pluginId: row.plugin_id,
+			status: toPluginStatus(row.status),
+			version: row.version,
+			installedAt: new Date(row.installed_at),
+			activatedAt: row.activated_at ? new Date(row.activated_at) : null,
+			deactivatedAt: row.deactivated_at ? new Date(row.deactivated_at) : null,
+			source: toPluginSource(row.source),
+			marketplaceVersion: row.marketplace_version ?? null,
+			displayName: row.display_name ?? null,
+			description: row.description ?? null
+		}));
+	}
+	/**
+	* Create or update plugin state
+	*/
+	async upsert(pluginId, version, status, opts) {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const existing = await this.get(pluginId);
+		if (existing) {
+			const updates = {
+				status,
+				version
+			};
+			if (status === "active" && existing.status !== "active") updates.activated_at = now;
+			else if (status === "inactive" && existing.status !== "inactive") updates.deactivated_at = now;
+			if (opts?.source) updates.source = opts.source;
+			if (opts?.marketplaceVersion !== void 0) updates.marketplace_version = opts.marketplaceVersion;
+			if (opts?.displayName !== void 0) updates.display_name = opts.displayName;
+			if (opts?.description !== void 0) updates.description = opts.description;
+			await this.db.updateTable("_plugin_state").set(updates).where("plugin_id", "=", pluginId).execute();
+		} else await this.db.insertInto("_plugin_state").values({
+			plugin_id: pluginId,
+			status,
+			version,
+			installed_at: now,
+			activated_at: status === "active" ? now : null,
+			deactivated_at: null,
+			data: null,
+			source: opts?.source ?? "config",
+			marketplace_version: opts?.marketplaceVersion ?? null,
+			display_name: opts?.displayName ?? null,
+			description: opts?.description ?? null
+		}).execute();
+		return await this.get(pluginId);
+	}
+	/**
+	* Enable a plugin
+	*/
+	async enable(pluginId, version) {
+		return this.upsert(pluginId, version, "active");
+	}
+	/**
+	* Disable a plugin
+	*/
+	async disable(pluginId, version) {
+		return this.upsert(pluginId, version, "inactive");
+	}
+	/**
+	* Delete plugin state
+	*/
+	async delete(pluginId) {
+		return ((await this.db.deleteFrom("_plugin_state").where("plugin_id", "=", pluginId).executeTakeFirst()).numDeletedRows ?? 0) > 0;
+	}
+};
+
+//#endregion
+//#region src/api/handlers/plugins.ts
+function marketplaceIconUrl(marketplaceUrl, pluginId) {
+	return `${marketplaceUrl}/api/v1/plugins/${encodeURIComponent(pluginId)}/icon`;
+}
+/**
+* Get plugin info from configured plugin and database state
+*/
+function buildPluginInfo(plugin, state, marketplaceUrl) {
+	const status = state?.status ?? "active";
+	const enabled = status === "active";
+	const isMarketplace = (state?.source ?? "config") === "marketplace";
+	return {
+		id: plugin.id,
+		name: state?.displayName || plugin.id,
+		version: plugin.version,
+		package: void 0,
+		enabled,
+		status,
+		source: state?.source ?? "config",
+		marketplaceVersion: state?.marketplaceVersion ?? void 0,
+		capabilities: plugin.capabilities,
+		hasAdminPages: (plugin.admin.pages?.length ?? 0) > 0,
+		hasDashboardWidgets: (plugin.admin.widgets?.length ?? 0) > 0,
+		hasHooks: Object.keys(plugin.hooks ?? {}).length > 0,
+		installedAt: state?.installedAt?.toISOString(),
+		activatedAt: state?.activatedAt?.toISOString() ?? void 0,
+		deactivatedAt: state?.deactivatedAt?.toISOString() ?? void 0,
+		description: state?.description ?? void 0,
+		iconUrl: isMarketplace && marketplaceUrl ? marketplaceIconUrl(marketplaceUrl, plugin.id) : void 0
+	};
+}
+/**
+* List all configured plugins with their state
+*/
+async function handlePluginList(db, configuredPlugins, marketplaceUrl) {
+	try {
+		const allStates = await new PluginStateRepository(db).getAll();
+		const stateMap = new Map(allStates.map((s) => [s.pluginId, s]));
+		const configuredIds = new Set(configuredPlugins.map((p) => p.id));
+		const items = configuredPlugins.map((plugin) => {
+			return buildPluginInfo(plugin, stateMap.get(plugin.id) ?? null, marketplaceUrl);
+		});
+		for (const state of allStates) {
+			if (state.source !== "marketplace") continue;
+			if (configuredIds.has(state.pluginId)) continue;
+			items.push({
+				id: state.pluginId,
+				name: state.displayName || state.pluginId,
+				version: state.marketplaceVersion ?? state.version,
+				enabled: state.status === "active",
+				status: state.status,
+				source: "marketplace",
+				marketplaceVersion: state.marketplaceVersion ?? void 0,
+				capabilities: [],
+				hasAdminPages: false,
+				hasDashboardWidgets: false,
+				hasHooks: false,
+				installedAt: state.installedAt?.toISOString(),
+				activatedAt: state.activatedAt?.toISOString() ?? void 0,
+				deactivatedAt: state.deactivatedAt?.toISOString() ?? void 0,
+				description: state.description ?? void 0,
+				iconUrl: marketplaceUrl ? marketplaceIconUrl(marketplaceUrl, state.pluginId) : void 0
+			});
+		}
+		return {
+			success: true,
+			data: { items }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "PLUGIN_LIST_ERROR",
+				message: "Failed to list plugins"
+			}
+		};
+	}
+}
+/**
+* Get a single plugin's info
+*/
+async function handlePluginGet(db, configuredPlugins, pluginId, marketplaceUrl) {
+	try {
+		const plugin = configuredPlugins.find((p) => p.id === pluginId);
+		if (!plugin) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Plugin not found: ${pluginId}`
+			}
+		};
+		return {
+			success: true,
+			data: { item: buildPluginInfo(plugin, await new PluginStateRepository(db).get(pluginId), marketplaceUrl) }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "PLUGIN_GET_ERROR",
+				message: "Failed to get plugin"
+			}
+		};
+	}
+}
+/**
+* Enable a plugin
+*/
+async function handlePluginEnable(db, configuredPlugins, pluginId) {
+	try {
+		const plugin = configuredPlugins.find((p) => p.id === pluginId);
+		if (!plugin) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Plugin not found: ${pluginId}`
+			}
+		};
+		return {
+			success: true,
+			data: { item: buildPluginInfo(plugin, await new PluginStateRepository(db).enable(pluginId, plugin.version)) }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "PLUGIN_ENABLE_ERROR",
+				message: "Failed to enable plugin"
+			}
+		};
+	}
+}
+/**
+* Disable a plugin
+*/
+async function handlePluginDisable(db, configuredPlugins, pluginId) {
+	try {
+		const plugin = configuredPlugins.find((p) => p.id === pluginId);
+		if (!plugin) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Plugin not found: ${pluginId}`
+			}
+		};
+		return {
+			success: true,
+			data: { item: buildPluginInfo(plugin, await new PluginStateRepository(db).disable(pluginId, plugin.version)) }
+		};
+	} catch {
+		return {
+			success: false,
+			error: {
+				code: "PLUGIN_DISABLE_ERROR",
+				message: "Failed to disable plugin"
+			}
+		};
+	}
+}
+
+//#endregion
+//#region src/database/repositories/context-entries.ts
+var ContextRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async create(input) {
+		validateContextType(input.contextType);
+		const id = ulid();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const tags = normalizeTags(input.tags);
+		await withTransaction(this.db, async (trx) => {
+			await trx.insertInto("_dineway_context_entries").values(toInsertableContextEntry(id, input, now)).execute();
+			await insertTags(trx, id, tags);
+		});
+		const entry = await this.findById(id);
+		if (!entry) throw new Error("Failed to create context entry");
+		return entry;
+	}
+	async findById(id) {
+		const row = await this.db.selectFrom("_dineway_context_entries").selectAll().where("id", "=", id).executeTakeFirst();
+		if (!row) return null;
+		return rowToContextEntry(row, (await this.loadTags([id])).get(id) ?? []);
+	}
+	async findSupersedeHistory(id) {
+		const seen = /* @__PURE__ */ new Set();
+		const entries = /* @__PURE__ */ new Map();
+		const queue = [id];
+		while (queue.length > 0) {
+			const nextId = queue.shift();
+			if (seen.has(nextId)) continue;
+			seen.add(nextId);
+			const entry = await this.findById(nextId);
+			if (!entry) continue;
+			entries.set(entry.id, entry);
+			if (entry.supersedesId) queue.push(entry.supersedesId);
+			const replacements = await this.findSupersedingEntries(entry.id);
+			for (const replacement of replacements) queue.push(replacement.id);
+		}
+		return [...entries.values()].toSorted(compareHistoryEntries);
+	}
+	async list(query = {}) {
+		const rows = await this.queryRows(query).execute();
+		return this.rowsToPaginatedEntries(rows, clampLimit$1(query.limit));
+	}
+	async search(query) {
+		const term = `%${query.query.toLowerCase()}%`;
+		let q = this.queryRows(query);
+		q = q.where((eb) => eb.or([
+			sql`lower(title) like ${term}`,
+			sql`lower(body) like ${term}`,
+			sql`lower(scope) like ${term}`,
+			sql`lower(coalesce(policy_key, '')) like ${term}`
+		]));
+		const rows = await q.execute();
+		return this.rowsToPaginatedEntries(rows, clampLimit$1(query.limit));
+	}
+	async supersede(id, input) {
+		const newId = ulid();
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const tags = normalizeTags(input.tags);
+		const createdId = await withTransaction(this.db, async (trx) => {
+			const existing = await trx.selectFrom("_dineway_context_entries").selectAll().where("id", "=", id).executeTakeFirst();
+			if (!existing) return null;
+			const contextType = input.contextType ?? existing.context_type;
+			validateContextType(contextType);
+			await trx.updateTable("_dineway_context_entries").set({
+				is_current: 0,
+				updated_at: now
+			}).where("id", "=", id).execute();
+			await trx.insertInto("_dineway_context_entries").values(toInsertableContextEntry(newId, {
+				scope: input.scope ?? existing.scope,
+				contextType,
+				title: input.title,
+				body: input.body,
+				policyKey: input.policyKey ?? existing.policy_key,
+				sourceActivityId: input.sourceActivityId ?? existing.source_activity_id,
+				createdByActorType: input.createdByActorType,
+				createdByActorId: input.createdByActorId,
+				createdAuthMetadata: input.createdAuthMetadata,
+				supersedesId: existing.id,
+				version: existing.version + 1,
+				isCurrent: true,
+				validUntil: input.validUntil ?? existing.valid_until,
+				tags,
+				createdAt: input.createdAt,
+				updatedAt: input.createdAt
+			}, now)).execute();
+			await insertTags(trx, newId, tags);
+			return newId;
+		});
+		return createdId ? this.findById(createdId) : null;
+	}
+	async review(id, input) {
+		const reviewedAt = input.reviewedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		await this.db.updateTable("_dineway_context_entries").set({
+			reviewed_at: reviewedAt,
+			reviewed_by_actor_type: input.reviewedByActorType,
+			reviewed_by_actor_id: input.reviewedByActorId,
+			review_note: input.reviewNote ?? null,
+			valid_until: input.validUntil ?? void 0,
+			updated_at: reviewedAt
+		}).where("id", "=", id).execute();
+		return this.findById(id);
+	}
+	async listStale(query = {}) {
+		const now = query.now ?? (/* @__PURE__ */ new Date()).toISOString();
+		let q = this.queryRows({
+			...query,
+			currentOnly: true
+		});
+		q = q.where("valid_until", "is not", null).where("valid_until", "<", now);
+		const rows = await q.execute();
+		return this.rowsToPaginatedEntries(rows, clampLimit$1(query.limit));
+	}
+	async diff(query) {
+		const [newEntries, supersededEntries, staleEntries, reviewedEntries] = await Promise.all([
+			this.rowsForDiff({
+				scopes: query.scopes,
+				sinceColumn: "created_at",
+				since: query.since,
+				excludeSupersedeReplacements: true
+			}),
+			this.rowsForDiff({
+				scopes: query.scopes,
+				sinceColumn: "updated_at",
+				since: query.since,
+				currentOnly: false,
+				onlySuperseded: true
+			}),
+			this.staleRowsForDiff({
+				scopes: query.scopes,
+				since: query.since,
+				now: query.now
+			}),
+			this.rowsForDiff({
+				scopes: query.scopes,
+				sinceColumn: "reviewed_at",
+				since: query.since,
+				reviewedOnly: true
+			})
+		]);
+		return {
+			newEntries,
+			supersededEntries,
+			staleEntries,
+			reviewedEntries
+		};
+	}
+	queryRows(query) {
+		const limit = clampLimit$1(query.limit);
+		let q = this.db.selectFrom("_dineway_context_entries").selectAll().orderBy("updated_at", "desc").orderBy("id", "desc").limit(limit + 1);
+		if (query.currentOnly !== false) q = q.where("is_current", "=", 1);
+		if (query.scopes) if (query.scopes.length === 0) q = q.where("id", "=", "__no_context_entries__");
+		else q = q.where("scope", "in", query.scopes);
+		if (query.contextTypes && query.contextTypes.length > 0) q = q.where("context_type", "in", query.contextTypes);
+		if (query.createdByActorType) q = q.where("created_by_actor_type", "=", query.createdByActorType);
+		if (query.createdByActorId) q = q.where("created_by_actor_id", "=", query.createdByActorId);
+		const tags = normalizeTags(query.tags);
+		if (tags.length > 0) {
+			const taggedIds = this.db.selectFrom("_dineway_context_tags").select("context_entry_id").where("tag", "in", tags);
+			q = q.where("id", "in", taggedIds);
+		}
+		if (query.cursor) {
+			const decoded = decodeCursor(query.cursor);
+			if (decoded) q = q.where((eb) => eb.or([eb("updated_at", "<", decoded.orderValue), eb.and([eb("updated_at", "=", decoded.orderValue), eb("id", "<", decoded.id)])]));
+		}
+		return q;
+	}
+	async rowsForDiff(input) {
+		let q = this.db.selectFrom("_dineway_context_entries").selectAll().orderBy("updated_at", "desc").orderBy("id", "desc").limit(100);
+		if (input.scopes) {
+			if (input.scopes.length === 0) return [];
+			q = q.where("scope", "in", input.scopes);
+		}
+		if (input.currentOnly !== false) q = q.where("is_current", "=", 1);
+		if (input.onlySuperseded) q = q.where("is_current", "=", 0);
+		if (input.reviewedOnly) q = q.where("reviewed_at", "is not", null);
+		if (input.excludeSupersedeReplacements) q = q.where("supersedes_id", "is", null);
+		q = q.where(input.sinceColumn, ">=", input.since);
+		const rows = await q.execute();
+		return this.rowsToEntries(rows);
+	}
+	async staleRowsForDiff(input) {
+		const now = input.now ?? (/* @__PURE__ */ new Date()).toISOString();
+		let q = this.db.selectFrom("_dineway_context_entries").selectAll().where("is_current", "=", 1).where("valid_until", "is not", null).where("valid_until", ">=", input.since).where("valid_until", "<", now).orderBy("valid_until", "asc").orderBy("updated_at", "desc").orderBy("id", "desc").limit(100);
+		if (input.scopes) {
+			if (input.scopes.length === 0) return [];
+			q = q.where("scope", "in", input.scopes);
+		}
+		const rows = await q.execute();
+		return this.rowsToEntries(rows);
+	}
+	async rowsToPaginatedEntries(rows, limit) {
+		const pageRows = rows.slice(0, limit);
+		const items = await this.rowsToEntries(pageRows);
+		const result = { items };
+		if (rows.length > limit && items.length > 0) {
+			const last = items.at(-1);
+			result.nextCursor = encodeCursor(last.updatedAt, last.id);
+		}
+		return result;
+	}
+	async rowsToEntries(rows) {
+		const ids = rows.map((row) => row.id);
+		const tagMap = await this.loadTags(ids);
+		return rows.map((row) => rowToContextEntry(row, tagMap.get(row.id) ?? []));
+	}
+	async findSupersedingEntries(id) {
+		const rows = await this.db.selectFrom("_dineway_context_entries").selectAll().where("supersedes_id", "=", id).orderBy("version", "asc").orderBy("created_at", "asc").orderBy("id", "asc").execute();
+		return this.rowsToEntries(rows);
+	}
+	async loadTags(ids) {
+		const tagMap = /* @__PURE__ */ new Map();
+		if (ids.length === 0) return tagMap;
+		const rows = await this.db.selectFrom("_dineway_context_tags").select(["context_entry_id", "tag"]).where("context_entry_id", "in", ids).orderBy("tag", "asc").execute();
+		for (const row of rows) {
+			const tags = tagMap.get(row.context_entry_id) ?? [];
+			tags.push(row.tag);
+			tagMap.set(row.context_entry_id, tags);
+		}
+		return tagMap;
+	}
+};
+function toInsertableContextEntry(id, input, now) {
+	return {
+		id,
+		scope: input.scope,
+		context_type: input.contextType,
+		title: input.title,
+		body: input.body,
+		policy_key: input.policyKey ?? null,
+		source_activity_id: input.sourceActivityId ?? null,
+		created_by_actor_type: input.createdByActorType,
+		created_by_actor_id: input.createdByActorId,
+		created_auth_metadata: jsonOrNull(input.createdAuthMetadata),
+		supersedes_id: input.supersedesId ?? null,
+		version: input.version ?? 1,
+		is_current: input.isCurrent === false ? 0 : 1,
+		valid_until: input.validUntil ?? null,
+		reviewed_at: null,
+		reviewed_by_actor_type: null,
+		reviewed_by_actor_id: null,
+		review_note: null,
+		created_at: input.createdAt ?? now,
+		updated_at: input.updatedAt ?? input.createdAt ?? now
+	};
+}
+async function insertTags(db, entryId, tags) {
+	if (tags.length === 0) return;
+	await db.insertInto("_dineway_context_tags").values(tags.map((tag) => ({
+		context_entry_id: entryId,
+		tag
+	}))).execute();
+}
+function rowToContextEntry(row, tags) {
+	const contextType = row.context_type;
+	validateContextType(contextType);
+	return {
+		id: row.id,
+		scope: row.scope,
+		contextType,
+		title: row.title,
+		body: row.body,
+		policyKey: row.policy_key,
+		sourceActivityId: row.source_activity_id,
+		createdByActorType: row.created_by_actor_type,
+		createdByActorId: row.created_by_actor_id,
+		createdAuthMetadata: parseRecord(row.created_auth_metadata),
+		supersedesId: row.supersedes_id,
+		version: row.version,
+		isCurrent: row.is_current === 1,
+		validUntil: row.valid_until,
+		reviewedAt: row.reviewed_at,
+		reviewedByActorType: row.reviewed_by_actor_type,
+		reviewedByActorId: row.reviewed_by_actor_id,
+		reviewNote: row.review_note,
+		tags,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function validateContextType(value) {
+	if (!isSiteContextType(value)) throw new Error(`Invalid context type: ${value}`);
+}
+function normalizeTags(tags) {
+	if (!tags) return [];
+	return [...new Set(tags.map((tag) => tag.trim().toLowerCase()).filter((tag) => tag.length > 0))].toSorted();
+}
+function compareHistoryEntries(a, b) {
+	if (a.version !== b.version) return a.version - b.version;
+	const created = a.createdAt.localeCompare(b.createdAt);
+	if (created !== 0) return created;
+	return a.id.localeCompare(b.id);
+}
+function jsonOrNull(value) {
+	return value ? JSON.stringify(value) : null;
+}
+function parseRecord(value) {
+	if (!value) return null;
+	try {
+		const parsed = JSON.parse(value);
+		return isRecord(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function clampLimit$1(value) {
+	return Math.min(Math.max(1, value ?? 50), 100);
+}
+
+//#endregion
+//#region src/site-context/briefing.ts
+const COLLECTION_SLUG_PATTERN = /^[a-z][a-z0-9_]*$/;
+const DEFAULT_ACTIVITY_LIMIT = 10;
+const DEFAULT_REVIEW_REQUEST_LIMIT = 25;
+const MAX_ACTIVITY_LIMIT = 100;
+const DEFAULT_TOKEN_BUDGET = 8e3;
+const TOKEN_CHARS = 4;
+const RELATIVE_SINCE_PATTERN = /^(\d+)(m|h|d|w)$/i;
+var SiteBriefingError = class extends Error {
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "SiteBriefingError";
+	}
+};
+var SiteBriefingAssembler = class {
+	db;
+	storage;
+	configuredPlugins;
+	marketplaceUrl;
+	permissions;
+	now;
+	constructor(options) {
+		this.db = options.db;
+		this.storage = options.storage ?? null;
+		this.configuredPlugins = options.configuredPlugins ?? [];
+		this.marketplaceUrl = options.marketplaceUrl;
+		this.permissions = {
+			canReadContent: false,
+			canReadSchema: false,
+			canReadSettings: false,
+			canReadPlugins: false,
+			...options.permissions
+		};
+		this.now = options.now ?? /* @__PURE__ */ new Date();
+	}
+	async assemble(input = {}) {
+		const parsedScope = parseSiteBriefingScope(input.scope ?? "site");
+		const since = resolveSince(input.since, this.now);
+		const contextTypes = parseContextTypes(input.contextTypes ?? []);
+		const includeStale = input.includeStale !== false;
+		const activityLimit = clampLimit(input.activityLimit ?? DEFAULT_ACTIVITY_LIMIT);
+		const tokenBudget = Math.max(1, Math.floor(input.tokenBudget ?? DEFAULT_TOKEN_BUDGET));
+		const [schema, contextEntries, activity, plugins, settings, staleWarnings, reviewRequests] = await Promise.all([
+			this.loadSchemaSection(parsedScope),
+			this.loadContextEntriesSection(parsedScope, contextTypes),
+			this.loadActivitySection(parsedScope, since, activityLimit),
+			this.loadPluginSection(),
+			this.loadSettingsSection(),
+			this.loadStaleWarningsSection(parsedScope, contextTypes, includeStale),
+			this.loadReviewRequestsSection(parsedScope)
+		]);
+		return applyTokenBudget({
+			kind: "site_briefing",
+			generatedAt: this.now.toISOString(),
+			scope: {
+				requested: input.scope ?? "site",
+				resolved: parsedScope.scope,
+				type: parsedScope.type,
+				ancestors: parsedScope.ancestors,
+				collection: parsedScope.collection,
+				contentId: parsedScope.contentId,
+				pluginId: parsedScope.pluginId,
+				taxonomyId: parsedScope.taxonomyId,
+				menuId: parsedScope.menuId
+			},
+			since,
+			contextTypes,
+			tokenBudget,
+			tokenEstimate: 0,
+			truncated: false,
+			packing: [],
+			sections: {
+				schema,
+				contextEntries,
+				activity,
+				plugins,
+				settings,
+				staleWarnings,
+				reviewRequests
+			}
+		}, tokenBudget);
+	}
+	async loadSchemaSection(scope) {
+		if (!this.permissions.canReadSchema) return omittedSection({ collections: [] }, "missing schema:read permission");
+		const registry = new SchemaRegistry(this.db);
+		const collections = scope.collection !== void 0 ? compactCollection(await registry.getCollectionWithFields(scope.collection)) : await this.loadAllCollections(registry);
+		return includedSection({
+			collections,
+			currentCollection: scope.collection !== void 0 ? collections.find((item) => item.slug === scope.collection) : void 0
+		});
+	}
+	async loadAllCollections(registry) {
+		const collections = await registry.listCollections();
+		return (await Promise.all(collections.map((collection) => registry.getCollectionWithFields(collection.slug)))).flatMap((collection) => compactCollection(collection));
+	}
+	async loadContextEntriesSection(scope, contextTypes) {
+		if (!this.permissions.canReadContent) return omittedSection({
+			groups: [],
+			scopes: scope.ancestors
+		}, "missing content:read permission");
+		return includedSection({
+			groups: groupContextEntries(selectActiveBriefingContextEntries((await new ContextRepository(this.db).list({
+				scopes: scope.ancestors,
+				contextTypes: contextTypes.length > 0 ? contextTypes : void 0,
+				currentOnly: true,
+				limit: 50
+			})).items, scope.ancestors, this.now).map((entry) => summarizeContextEntry(entry))),
+			scopes: scope.ancestors
+		});
+	}
+	async loadActivitySection(scope, since, limit) {
+		if (!this.permissions.canReadContent) return omittedSection({
+			scopes: scope.ancestors,
+			items: []
+		}, "missing content:read permission");
+		const items = (await new SiteActivityRepository(this.db).findTimeline({
+			scopes: scope.ancestors,
+			since: since ?? void 0,
+			limit
+		})).items.filter((activity) => this.canIncludeActivity(activity)).map((activity) => summarizeActivity(activity));
+		return includedSection({
+			scopes: scope.ancestors,
+			items
+		});
+	}
+	async loadPluginSection() {
+		if (!this.permissions.canReadPlugins) return omittedSection({ active: [] }, "missing plugins:read permission");
+		const result = await handlePluginList(this.db, this.configuredPlugins, this.marketplaceUrl);
+		if (!result.success || !result.data) return omittedSection({ active: [] }, "plugin list could not be loaded");
+		return includedSection({ active: result.data.items.filter((plugin) => plugin.enabled).map((plugin) => summarizePlugin(plugin)) });
+	}
+	async loadSettingsSection() {
+		if (!this.permissions.canReadSettings) return omittedSection(null, "missing settings:read permission");
+		return includedSection(summarizeSettings(await getSiteSettingsWithDb(this.db, this.storage)));
+	}
+	async loadStaleWarningsSection(scope, contextTypes, includeStale) {
+		if (!includeStale) return omittedSection({
+			scopes: scope.ancestors,
+			items: []
+		}, "stale warnings disabled by include_stale=false");
+		if (!this.permissions.canReadContent) return omittedSection({
+			scopes: scope.ancestors,
+			items: []
+		}, "missing content:read permission");
+		const entries = await new ContextRepository(this.db).listStale({
+			scopes: scope.ancestors,
+			contextTypes: contextTypes.length > 0 ? contextTypes : void 0,
+			limit: 50,
+			now: this.now.toISOString()
+		});
+		return includedSection({
+			scopes: scope.ancestors,
+			items: entries.items.map((entry) => summarizeStaleWarning(entry))
+		});
+	}
+	async loadReviewRequestsSection(scope) {
+		if (!this.permissions.canReadContent) return omittedSection({
+			scopes: scope.ancestors,
+			items: []
+		}, "missing content:read permission");
+		const requests = await new ReviewRequestRepository(this.db).list({
+			status: "pending",
+			scopes: scope.ancestors,
+			limit: DEFAULT_REVIEW_REQUEST_LIMIT
+		});
+		return includedSection({
+			scopes: scope.ancestors,
+			items: requests.items.map((request) => summarizeReviewRequest(request))
+		});
+	}
+	canIncludeActivity(activity) {
+		if (activity.actionType.startsWith("content.")) return this.permissions.canReadContent;
+		if (activity.actionType.startsWith("schema.")) return this.permissions.canReadSchema;
+		if (activity.actionType.startsWith("plugin.")) return this.permissions.canReadPlugins;
+		if (activity.actionType.startsWith("settings.")) return this.permissions.canReadSettings;
+		return this.permissions.canReadContent;
+	}
+};
+function parseSiteBriefingScope(scope) {
+	const parts = scope.split(":");
+	if (scope === "site") return {
+		type: "site",
+		scope: "site",
+		ancestors: ["site"]
+	};
+	if (parts[0] === "collection" && parts.length === 2 && isCollectionSlug(parts[1])) {
+		const resolved = `collection:${parts[1]}`;
+		return {
+			type: "collection",
+			scope: resolved,
+			ancestors: ["site", resolved],
+			collection: parts[1]
+		};
+	}
+	if (parts[0] === "content" && parts.length === 3 && isCollectionSlug(parts[1]) && parts[2].length > 0) {
+		const collectionScope = `collection:${parts[1]}`;
+		const resolved = `content:${parts[1]}:${parts[2]}`;
+		return {
+			type: "content",
+			scope: resolved,
+			ancestors: [
+				"site",
+				collectionScope,
+				resolved
+			],
+			collection: parts[1],
+			contentId: parts[2]
+		};
+	}
+	if (parts[0] === "plugin" && parts.length === 2 && parts[1].length > 0) {
+		const resolved = `plugin:${parts[1]}`;
+		return {
+			type: "plugin",
+			scope: resolved,
+			ancestors: ["site", resolved],
+			pluginId: parts[1]
+		};
+	}
+	if (parts[0] === "taxonomy" && parts.length === 2 && parts[1].length > 0) {
+		const resolved = `taxonomy:${parts[1]}`;
+		return {
+			type: "taxonomy",
+			scope: resolved,
+			ancestors: ["site", resolved],
+			taxonomyId: parts[1]
+		};
+	}
+	if (parts[0] === "menu" && parts.length === 2 && parts[1].length > 0) {
+		const resolved = `menu:${parts[1]}`;
+		return {
+			type: "menu",
+			scope: resolved,
+			ancestors: ["site", resolved],
+			menuId: parts[1]
+		};
+	}
+	throw new SiteBriefingError(`Invalid scope "${scope}". Expected site, collection:{slug}, content:{collection}:{id}, plugin:{id}, taxonomy:{id}, or menu:{id}.`, "INVALID_SCOPE");
+}
+function formatSiteBriefingText(briefing) {
+	const lines = [];
+	lines.push(`# Site Briefing: ${briefing.scope.resolved}`);
+	lines.push(`Generated: ${briefing.generatedAt}`);
+	if (briefing.since) lines.push(`Since: ${briefing.since}`);
+	lines.push("");
+	if (briefing.sections.schema.status === "included") {
+		lines.push("## Schema");
+		for (const collection of briefing.sections.schema.data.collections) lines.push(`- ${collection.slug}: ${collection.label} (${collection.fields.length} fields, supports: ${collection.supports.join(", ") || "none"})`);
+		lines.push("");
+	}
+	if (briefing.sections.contextEntries.status === "included") {
+		lines.push("## Context Entries");
+		for (const group of briefing.sections.contextEntries.data.groups) {
+			lines.push(`### ${group.contextType}`);
+			for (const entry of group.items) lines.push(`- ${entry.scope}: ${entry.title} - ${entry.body}`);
+		}
+		if (briefing.sections.contextEntries.data.groups.length === 0) lines.push("- No active context entries.");
+		lines.push("");
+	}
+	if (briefing.sections.activity.status === "included") {
+		lines.push("## Recent Activity");
+		for (const activity of briefing.sections.activity.data.items) lines.push(`- ${activity.createdAt}: ${activity.actionType} - ${activity.summary}`);
+		if (briefing.sections.activity.data.items.length === 0) lines.push("- No matching activity.");
+		lines.push("");
+	}
+	if (briefing.sections.staleWarnings.status === "included") {
+		lines.push("## Stale Context Warnings");
+		for (const warning of briefing.sections.staleWarnings.data.items) lines.push(`- ${warning.scope} ${warning.contextType} ${warning.title}${warning.validUntil ? ` (expired ${warning.validUntil})` : ""}`);
+		if (briefing.sections.staleWarnings.data.items.length === 0) lines.push("- No stale context warnings.");
+		lines.push("");
+	}
+	if (briefing.sections.reviewRequests.status === "included") {
+		lines.push("## Open Review Requests");
+		for (const request of briefing.sections.reviewRequests.data.items) lines.push(`- ${request.createdAt}: ${request.id} ${request.actionType} for ${request.scope}${request.summary ? ` - ${request.summary}` : ""}`);
+		if (briefing.sections.reviewRequests.data.items.length === 0) lines.push("- No open review requests.");
+		lines.push("");
+	}
+	if (briefing.sections.plugins.status === "included") {
+		lines.push("## Active Plugins");
+		for (const plugin of briefing.sections.plugins.data.active) lines.push(`- ${plugin.id}@${plugin.version}: ${plugin.capabilities.join(", ") || "no capabilities"}`);
+		if (briefing.sections.plugins.data.active.length === 0) lines.push("- No active plugins.");
+		lines.push("");
+	}
+	if (briefing.sections.settings.status === "included" && briefing.sections.settings.data) {
+		const settings = briefing.sections.settings.data;
+		lines.push("## Site Settings");
+		lines.push(`- Title: ${settings.title ?? "(unset)"}`);
+		if (settings.tagline) lines.push(`- Tagline: ${settings.tagline}`);
+		if (settings.url) lines.push(`- URL: ${settings.url}`);
+		lines.push("");
+	}
+	const unavailable = Object.entries(briefing.sections).filter(([, section]) => section.status === "not_available").map(([key, section]) => `${key}: ${section.reason ?? "not available"}`);
+	if (unavailable.length > 0) {
+		lines.push("## Not Yet Available");
+		for (const item of unavailable) lines.push(`- ${item}`);
+	}
+	return lines.join("\n").trim();
+}
+function compactCollection(collection) {
+	if (!collection) return [];
+	return [{
+		slug: collection.slug,
+		label: collection.label,
+		labelSingular: collection.labelSingular,
+		description: collection.description,
+		supports: collection.supports,
+		hasSeo: collection.hasSeo,
+		urlPattern: collection.urlPattern,
+		comments: {
+			enabled: collection.commentsEnabled,
+			moderation: collection.commentsModeration,
+			closedAfterDays: collection.commentsClosedAfterDays,
+			autoApproveUsers: collection.commentsAutoApproveUsers
+		},
+		fields: collection.fields.map((field) => summarizeField(field))
+	}];
+}
+function summarizeField(field) {
+	return {
+		slug: field.slug,
+		label: field.label,
+		type: field.type,
+		required: field.required,
+		unique: field.unique,
+		searchable: field.searchable,
+		translatable: field.translatable,
+		referenceCollection: field.type === "reference" && typeof field.options?.collection === "string" ? field.options.collection : void 0
+	};
+}
+function summarizeActivity(activity) {
+	return {
+		id: activity.id,
+		actionType: activity.actionType,
+		subjectType: activity.subjectType,
+		subjectId: activity.subjectId,
+		relatedSubjectType: activity.relatedSubjectType,
+		relatedSubjectId: activity.relatedSubjectId,
+		sourceType: activity.sourceType,
+		sourceName: activity.sourceName,
+		resultStatus: activity.resultStatus,
+		scope: activity.scope,
+		summary: activity.summary,
+		actorType: activity.actorType,
+		actorId: activity.actorId,
+		detail: summarizeActivityDetail(activity.detail),
+		createdAt: activity.createdAt
+	};
+}
+function summarizeContextEntry(entry) {
+	return {
+		id: entry.id,
+		scope: entry.scope,
+		contextType: entry.contextType,
+		title: entry.title,
+		body: entry.body,
+		policyKey: entry.policyKey,
+		supersedesId: entry.supersedesId,
+		version: entry.version,
+		validUntil: entry.validUntil,
+		reviewedAt: entry.reviewedAt,
+		tags: entry.tags,
+		updatedAt: entry.updatedAt
+	};
+}
+function selectActiveBriefingContextEntries(entries, ancestorScopes, now) {
+	const activeEntries = entries.filter((entry) => !isStaleContextEntry(entry, now));
+	const scopeOrder = new Map(ancestorScopes.map((scope, index) => [scope, index]));
+	const narrowestScopeByPolicyKey = /* @__PURE__ */ new Map();
+	for (const entry of activeEntries) {
+		if (!entry.policyKey) continue;
+		const scopeIndex = scopeOrder.get(entry.scope);
+		if (scopeIndex === void 0) continue;
+		const current = narrowestScopeByPolicyKey.get(entry.policyKey);
+		if (current === void 0 || scopeIndex > current) narrowestScopeByPolicyKey.set(entry.policyKey, scopeIndex);
+	}
+	return activeEntries.filter((entry) => {
+		if (!entry.policyKey) return true;
+		const scopeIndex = scopeOrder.get(entry.scope);
+		if (scopeIndex === void 0) return true;
+		return narrowestScopeByPolicyKey.get(entry.policyKey) === scopeIndex;
+	});
+}
+function groupContextEntries(entries) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const items = grouped.get(entry.contextType) ?? [];
+		items.push(entry);
+		grouped.set(entry.contextType, items);
+	}
+	return SITE_CONTEXT_TYPES.flatMap((contextType) => {
+		const items = grouped.get(contextType);
+		return items && items.length > 0 ? [{
+			contextType,
+			items
+		}] : [];
+	});
+}
+function summarizeStaleWarning(entry) {
+	return {
+		id: entry.id,
+		scope: entry.scope,
+		contextType: entry.contextType,
+		title: entry.title,
+		policyKey: entry.policyKey,
+		validUntil: entry.validUntil,
+		reviewedAt: entry.reviewedAt,
+		updatedAt: entry.updatedAt
+	};
+}
+function isStaleContextEntry(entry, now) {
+	if (!entry.validUntil) return false;
+	return entry.validUntil < now.toISOString();
+}
+function summarizeActivityDetail(detail) {
+	if (!detail) return null;
+	const allowedKeys = [
+		"collection",
+		"entryId",
+		"field",
+		"fieldType",
+		"pluginId",
+		"status",
+		"scheduledAt",
+		"changedFields",
+		"slugChanged",
+		"authorChanged"
+	];
+	const summary = {};
+	for (const key of allowedKeys) if (key in detail) summary[key] = detail[key];
+	return Object.keys(summary).length > 0 ? summary : null;
+}
+function summarizePlugin(plugin) {
+	return {
+		id: plugin.id,
+		name: plugin.name,
+		version: plugin.version,
+		status: plugin.status,
+		capabilities: plugin.capabilities.toSorted(),
+		hasAdminPages: plugin.hasAdminPages,
+		hasDashboardWidgets: plugin.hasDashboardWidgets,
+		hasHooks: plugin.hasHooks
+	};
+}
+function summarizeSettings(settings) {
+	const social = settings.social ?? {};
+	return {
+		title: settings.title,
+		tagline: settings.tagline,
+		url: settings.url,
+		timezone: settings.timezone,
+		dateFormat: settings.dateFormat,
+		postsPerPage: settings.postsPerPage,
+		branding: {
+			logoConfigured: Boolean(settings.logo),
+			faviconConfigured: Boolean(settings.favicon)
+		},
+		socialChannels: Object.entries(social).filter(([, value]) => typeof value === "string" && value.length > 0).map(([key]) => key).toSorted(),
+		seo: {
+			titleSeparator: settings.seo?.titleSeparator,
+			defaultOgImageConfigured: Boolean(settings.seo?.defaultOgImage),
+			robotsTxtConfigured: Boolean(settings.seo?.robotsTxt),
+			googleVerificationConfigured: Boolean(settings.seo?.googleVerification),
+			bingVerificationConfigured: Boolean(settings.seo?.bingVerification)
+		}
+	};
+}
+function summarizeReviewRequest(request) {
+	return {
+		id: request.id,
+		status: request.status,
+		scope: request.scope,
+		collection: request.collection,
+		entryId: request.entryId,
+		actionType: request.actionType,
+		riskReason: request.riskReason,
+		summary: reviewPayloadSummary(request.reviewPayload),
+		liveRevisionId: request.liveRevisionId,
+		draftRevisionId: request.draftRevisionId,
+		reviewedRev: request.reviewedRev,
+		actionHash: request.actionHash,
+		requestedByActorType: request.requestedByActorType,
+		requestedByActorId: request.requestedByActorId,
+		createdAt: request.createdAt,
+		updatedAt: request.updatedAt
+	};
+}
+function reviewPayloadSummary(payload) {
+	const summary = payload.summary;
+	return typeof summary === "string" && summary.length > 0 ? summary : null;
+}
+function resolveSince(value, now) {
+	if (!value) return null;
+	const relative = RELATIVE_SINCE_PATTERN.exec(value);
+	if (relative) {
+		const amount = Number(relative[1]);
+		const unit = relative[2].toLowerCase();
+		const multiplier = unit === "m" ? 60 * 1e3 : unit === "h" ? 3600 * 1e3 : unit === "d" ? 1440 * 60 * 1e3 : 10080 * 60 * 1e3;
+		return new Date(now.getTime() - amount * multiplier).toISOString();
+	}
+	const parsed = new Date(value);
+	if (Number.isNaN(parsed.getTime())) throw new SiteBriefingError(`Invalid since value "${value}". Use an ISO timestamp or relative value like 7d.`, "INVALID_SINCE");
+	return parsed.toISOString();
+}
+function parseContextTypes(values) {
+	return values.map((value) => {
+		if (!isSiteContextType(value)) throw new SiteBriefingError(`Invalid context type "${value}".`, "INVALID_CONTEXT_TYPE");
+		return value;
+	});
+}
+function applyTokenBudget(briefing, tokenBudget) {
+	let used = estimateTokens({
+		kind: briefing.kind,
+		generatedAt: briefing.generatedAt,
+		scope: briefing.scope,
+		since: briefing.since
+	});
+	const schemaTokens = estimateSection(briefing.sections.schema);
+	briefing.sections.schema.tokenEstimate = schemaTokens;
+	used += schemaTokens;
+	const packing = [{
+		section: "schema",
+		priority: 1,
+		status: briefing.sections.schema.status,
+		truncated: false,
+		reason: "schema snapshot is never truncated"
+	}];
+	used = packContextGroupSection(briefing.sections.contextEntries, used, tokenBudget, packing, "contextEntries", 2);
+	used = packArraySection(briefing.sections.activity, "items", used, tokenBudget, packing, "activity", 3);
+	used = packArraySection(briefing.sections.plugins, "active", used, tokenBudget, packing, "plugins", 4);
+	used = packScalarSection(briefing.sections.settings, used, tokenBudget, packing, "settings", 5);
+	used = packArraySection(briefing.sections.staleWarnings, "items", used, tokenBudget, packing, "staleWarnings", 6);
+	used = packArraySection(briefing.sections.reviewRequests, "items", used, tokenBudget, packing, "reviewRequests", 7);
+	briefing.packing = packing;
+	briefing.tokenEstimate = estimateTokens(briefing);
+	briefing.truncated = packing.some((item) => item.truncated);
+	return briefing;
+}
+function packContextGroupSection(section, used, tokenBudget, packing, sectionName, priority) {
+	section.tokenEstimate = estimateSection(section);
+	if (section.status !== "included") {
+		packing.push({
+			section: sectionName,
+			priority,
+			status: section.status,
+			truncated: false,
+			reason: section.reason
+		});
+		return used + section.tokenEstimate;
+	}
+	const originalCount = section.data.groups.reduce((total, group) => total + group.items.length, 0);
+	const keptGroups = [];
+	let nextUsed = used + estimateTokens({
+		...section,
+		data: {
+			...section.data,
+			groups: []
+		}
+	});
+	let truncated = false;
+	for (const group of section.data.groups) {
+		const keptItems = [];
+		for (const item of group.items) {
+			const itemTokens = estimateTokens(item);
+			if (nextUsed + itemTokens > tokenBudget) {
+				truncated = true;
+				break;
+			}
+			keptItems.push(item);
+			nextUsed += itemTokens;
+		}
+		if (keptItems.length > 0) keptGroups.push({
+			...group,
+			items: keptItems
+		});
+		if (truncated) break;
+	}
+	if (keptGroups.reduce((total, group) => total + group.items.length, 0) !== originalCount) {
+		section.data = {
+			...section.data,
+			groups: keptGroups
+		};
+		section.truncated = true;
+	}
+	section.tokenEstimate = estimateSection(section);
+	packing.push({
+		section: sectionName,
+		priority,
+		status: section.status,
+		truncated: Boolean(section.truncated),
+		reason: section.reason
+	});
+	return nextUsed;
+}
+function packArraySection(section, arrayKey, used, tokenBudget, packing, sectionName, priority) {
+	section.tokenEstimate = estimateSection(section);
+	const value = section.data[arrayKey];
+	if (!Array.isArray(value) || section.status !== "included") {
+		packing.push({
+			section: sectionName,
+			priority,
+			status: section.status,
+			truncated: false,
+			reason: section.reason
+		});
+		return used + section.tokenEstimate;
+	}
+	const kept = [];
+	let nextUsed = used + estimateTokens({
+		...section,
+		data: {
+			...section.data,
+			[arrayKey]: []
+		}
+	});
+	for (const item of value) {
+		const itemTokens = estimateTokens(item);
+		if (nextUsed + itemTokens > tokenBudget) {
+			section.truncated = true;
+			break;
+		}
+		kept.push(item);
+		nextUsed += itemTokens;
+	}
+	if (kept.length !== value.length) {
+		section.data = {
+			...section.data,
+			[arrayKey]: kept
+		};
+		section.truncated = true;
+	}
+	section.tokenEstimate = estimateSection(section);
+	packing.push({
+		section: sectionName,
+		priority,
+		status: section.status,
+		truncated: Boolean(section.truncated),
+		reason: section.reason
+	});
+	return nextUsed;
+}
+function packScalarSection(section, used, tokenBudget, packing, sectionName, priority) {
+	section.tokenEstimate = estimateSection(section);
+	if (section.status === "included" && section.data !== null && used + section.tokenEstimate > tokenBudget) {
+		section.data = null;
+		section.truncated = true;
+		section.tokenEstimate = estimateSection(section);
+	}
+	packing.push({
+		section: sectionName,
+		priority,
+		status: section.status,
+		truncated: Boolean(section.truncated),
+		reason: section.reason
+	});
+	return used + section.tokenEstimate;
+}
+function includedSection(data) {
+	return {
+		status: "included",
+		data,
+		tokenEstimate: estimateTokens(data)
+	};
+}
+function omittedSection(data, reason) {
+	return {
+		status: "omitted",
+		reason,
+		data,
+		tokenEstimate: estimateTokens(data)
+	};
+}
+function estimateSection(section) {
+	return estimateTokens(section);
+}
+function estimateTokens(value) {
+	return Math.ceil(JSON.stringify(value).length / TOKEN_CHARS);
+}
+function clampLimit(value) {
+	return Math.min(Math.max(1, Math.floor(value)), MAX_ACTIVITY_LIMIT);
+}
+function isCollectionSlug(value) {
+	return typeof value === "string" && COLLECTION_SLUG_PATTERN.test(value);
+}
+
+//#endregion
+export { ContextRepository as a, handlePluginGet as c, parseSiteBriefingScope as i, handlePluginList as l, SiteBriefingError as n, handlePluginDisable as o, formatSiteBriefingText as r, handlePluginEnable as s, SiteBriefingAssembler as t, PluginStateRepository as u };