@snoai/memory 0.0.0-stage → 1.0.0

package/dist/b-profile-section-dictionary-provider-BxbksLj3.d.ts

@@ -0,0 +1,62 @@
+import { g as ProductMode } from "./plugin-config-schema-C0UUbOmG.js";
+import { n as Locale } from "./locales-JxGmkG6t.js";
+import { z } from "zod";
+//#region src/engine/extraction/b-profile-section-registry.d.ts
+type BProfileSectionLocaleMap = Record<Locale, readonly string[]>;
+interface BProfileSectionDefinition {
+  name: string;
+  domain: string;
+  synonyms: BProfileSectionLocaleMap;
+}
+interface BProfileSectionRegistry {
+  schema_version: number;
+  frozen_at: string;
+  domains: readonly string[];
+  gate_prompt: {
+    instructions: string;
+    registry_header: string;
+    candidates_header: string;
+    output_contract: string;
+  };
+  active_task_shape: {
+    projection_max_items: number;
+    projection_title_max_tokens: number;
+  };
+  sections: readonly BProfileSectionDefinition[];
+  section_registry_sha256: string;
+  source_git_rev: string;
+}
+//#endregion
+//#region src/engine/extraction/b-profile-section-dictionary-provider.d.ts
+declare const bProfileSectionRegistrySchema: z.ZodType<BProfileSectionRegistry, unknown>;
+declare function computeSectionRegistryHash(registry: BProfileSectionRegistry): string;
+declare const sectionDictionaryCacheStateSchema: z.ZodType<{
+  activeRegistry: BProfileSectionRegistry;
+  fetchedForPluginVersion?: string;
+  appliedSchemaVersion?: number;
+  canonicalFormRepairVersion?: number;
+}, unknown>;
+type SectionDictionaryCacheState = z.infer<typeof sectionDictionaryCacheStateSchema>;
+interface SectionDictionaryCache {
+  read(): Promise<SectionDictionaryCacheState | undefined>;
+  write(state: SectionDictionaryCacheState): Promise<void>;
+}
+interface LoadSectionDictionaryResult {
+  registry: BProfileSectionRegistry;
+  fetched: boolean;
+}
+declare function createSectionDictionaryCache(stateDir?: string): SectionDictionaryCache;
+declare function getActiveSectionRegistry(): BProfileSectionRegistry;
+declare function normalizeTopicToSectionName(topic: string, registry?: BProfileSectionRegistry): string;
+declare function restoreCachedSectionDictionary(args: {
+  mode: ProductMode;
+  cache: SectionDictionaryCache;
+}): Promise<BProfileSectionRegistry>;
+declare function loadSectionDictionary(args: {
+  mode: ProductMode;
+  pluginVersion: string;
+  fetchFn: () => Promise<unknown>;
+  cache: SectionDictionaryCache;
+}): Promise<LoadSectionDictionaryResult>;
+//#endregion
+export { computeSectionRegistryHash as a, loadSectionDictionary as c, bProfileSectionRegistrySchema as i, normalizeTopicToSectionName as l, SectionDictionaryCache as n, createSectionDictionaryCache as o, SectionDictionaryCacheState as r, getActiveSectionRegistry as s, LoadSectionDictionaryResult as t, restoreCachedSectionDictionary as u };

package/dist/best-effort-BPZSzKk0.d.ts

@@ -0,0 +1,9 @@
+//#region src/engine/observability/best-effort.d.ts
+type ObserveLogger = {
+  warn(message: string): void;
+};
+/** Failures never reach the caller, but every one is logged at error level. */
+declare function bestEffort(label: string, fn: () => void | Promise<void>, _logger?: ObserveLogger): Promise<void>;
+declare function bestEffortSync<T>(label: string, fn: () => T, _logger?: ObserveLogger): T | undefined;
+//#endregion
+export { bestEffort as n, bestEffortSync as r, ObserveLogger as t };

package/dist/calendar-instruction-CzqZbAPG.js

@@ -0,0 +1,194 @@
+import { z } from "zod";
+import { Temporal } from "@js-temporal/polyfill";
+//#region src/engine/extraction/calendar-instruction.ts
+/** Calendar operations supplied by a model. This module never reads natural language. */
+/** Day names in ISO order; the wire carries the name because models do not share one numbering. */
+const WEEKDAYS = [
+	"monday",
+	"tuesday",
+	"wednesday",
+	"thursday",
+	"friday",
+	"saturday",
+	"sunday"
+];
+const precisionSchema = z.enum([
+	"year",
+	"month",
+	"week",
+	"day",
+	"minute"
+]);
+const clock = {
+	hour: z.number().int().min(0).max(23).optional(),
+	minute: z.number().int().min(0).max(59).optional(),
+	timezone: z.string().min(1).describe("A valid IANA time zone identifier or fixed UTC offset in +HH:MM or -HH:MM form; never a natural-language abbreviation. Keep hour and minute in that source zone.").optional()
+};
+const calendarInstructionSchema = z.discriminatedUnion("kind", [
+	z.object({ kind: z.literal("none") }).strict(),
+	z.object({ kind: z.literal("unresolved") }).strict(),
+	z.object({
+		kind: z.literal("absolute"),
+		year: z.number().int(),
+		month: z.number().int().min(1).max(12).optional(),
+		day: z.number().int().min(1).max(31).optional(),
+		precision: precisionSchema,
+		...clock
+	}).strict(),
+	z.object({
+		kind: z.literal("relative"),
+		amount: z.number().int(),
+		unit: z.enum([
+			"year",
+			"month",
+			"week",
+			"day",
+			"hour",
+			"minute"
+		]),
+		precision: precisionSchema,
+		...clock
+	}).strict(),
+	z.object({
+		kind: z.literal("weekday"),
+		day_name: z.enum(WEEKDAYS).describe("The named day as an English lowercase day name, never a number."),
+		direction: z.enum(["previous", "next"]),
+		precision: z.enum(["day", "minute"]),
+		...clock
+	}).strict()
+]);
+/** Validate only serialized calendar labels and precision, never natural-language meaning. */
+function isCalendarLabel(value, precision) {
+	if (typeof value !== "string") return false;
+	try {
+		switch (precision) {
+			case "year": return /^\d{4}$/u.test(value) && Temporal.PlainYearMonth.from(`${value}-01`).year === Number(value);
+			case "month": return Temporal.PlainYearMonth.from(value).toString() === value;
+			case "day": return Temporal.PlainDate.from(value).toString() === value;
+			case "minute": return Temporal.PlainDateTime.from(value).toString({ smallestUnit: "minute" }) === value;
+			case "week": {
+				const [from, until, extra] = value.split("/");
+				if (!from || !until || extra !== void 0) return false;
+				const start = Temporal.PlainDate.from(from);
+				return start.toString() === from && start.dayOfWeek === 1 && start.add({ days: 7 }).toString() === until;
+			}
+			default: return false;
+		}
+	} catch {
+		return false;
+	}
+}
+function sessionZoneCarriedBy(value) {
+	if (!value) return void 0;
+	try {
+		return Temporal.ZonedDateTime.from(value).timeZoneId;
+	} catch {}
+	const offset = /(Z|[+-]\d{2}:?\d{2})$/u.exec(value)?.[1];
+	return offset === "Z" ? "UTC" : offset;
+}
+function anchorDate(value, zone) {
+	if (!value) return void 0;
+	try {
+		return Temporal.Instant.from(value).toZonedDateTimeISO(zone);
+	} catch {}
+	try {
+		return Temporal.ZonedDateTime.from(value).withTimeZone(zone);
+	} catch {}
+	try {
+		return Temporal.PlainDateTime.from(value).toZonedDateTime(zone);
+	} catch {
+		return;
+	}
+}
+function calendarSessionTimestamp(value, zone) {
+	return anchorDate(value, zone ?? sessionZoneCarriedBy(value) ?? "UTC")?.epochMilliseconds;
+}
+function shift(unit, amount) {
+	switch (unit) {
+		case "year": return { years: amount };
+		case "month": return { months: amount };
+		case "week": return { weeks: amount };
+		case "day": return { days: amount };
+		case "hour": return { hours: amount };
+		case "minute": return { minutes: amount };
+		default: throw new Error("Unknown calendar unit");
+	}
+}
+function interval(date, precision) {
+	let start = date.startOfDay();
+	if (precision === "year") start = start.with({
+		month: 1,
+		day: 1
+	});
+	if (precision === "month") start = start.with({ day: 1 });
+	if (precision === "week") start = start.subtract({ days: start.dayOfWeek - 1 });
+	if (precision === "minute") start = date.with({
+		second: 0,
+		millisecond: 0,
+		microsecond: 0,
+		nanosecond: 0
+	});
+	const end = start.add(shift(precision, 1));
+	const iso = start.toPlainDate().toString();
+	const label = precision === "year" ? iso.slice(0, 4) : precision === "month" ? iso.slice(0, 7) : precision === "week" ? `${iso}/${end.toPlainDate().toString()}` : precision === "minute" ? start.toPlainDateTime().toString({ smallestUnit: "minute" }) : iso;
+	return {
+		year: start.year,
+		month: start.month,
+		day: start.day,
+		...precision === "minute" ? {
+			hour: start.hour,
+			minute: start.minute
+		} : {},
+		precision,
+		timezone: date.timeZoneId,
+		label,
+		from: start.epochMilliseconds,
+		until: end.epochMilliseconds
+	};
+}
+/** Invalid or unsupported instructions stay unresolved; no phrase parser or clock fallback. */
+function calculateCalendarTime(instruction, sessionDateTime, sessionTimezone) {
+	if (instruction.kind === "none" || instruction.kind === "unresolved") return null;
+	if ((instruction.hour !== void 0 || instruction.minute !== void 0) && instruction.precision !== "minute") return null;
+	if (instruction.minute !== void 0 && instruction.hour === void 0) return null;
+	if (instruction.kind === "weekday" && instruction.precision === "minute" && instruction.hour === void 0) return null;
+	const zone = instruction.timezone ?? sessionTimezone ?? sessionZoneCarriedBy(sessionDateTime) ?? "UTC";
+	try {
+		let date;
+		if (instruction.kind === "absolute") {
+			if (instruction.precision !== "year" && instruction.month === void 0) return null;
+			if (!["year", "month"].includes(instruction.precision) && instruction.day === void 0) return null;
+			if (instruction.precision === "minute" && instruction.hour === void 0) return null;
+			date = Temporal.ZonedDateTime.from({
+				timeZone: zone,
+				year: instruction.year,
+				month: instruction.month ?? 1,
+				day: instruction.day ?? 1,
+				hour: instruction.hour ?? 0,
+				minute: instruction.minute ?? 0
+			}, {
+				overflow: "reject",
+				disambiguation: "reject"
+			});
+		} else {
+			const anchor = anchorDate(sessionDateTime, zone);
+			if (!anchor) return null;
+			if (instruction.kind === "relative") date = anchor.add(shift(instruction.unit, instruction.amount));
+			else {
+				const forward = instruction.direction === "next";
+				const weekday = WEEKDAYS.indexOf(instruction.day_name) + 1;
+				const delta = forward ? (weekday - anchor.dayOfWeek + 7) % 7 : (anchor.dayOfWeek - weekday + 7) % 7;
+				date = anchor.add({ days: (forward ? 1 : -1) * (delta || 7) });
+			}
+			if (instruction.hour !== void 0) date = date.with({
+				hour: instruction.hour,
+				minute: instruction.minute ?? 0
+			}, { disambiguation: "reject" });
+		}
+		return interval(date, instruction.precision);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { sessionZoneCarriedBy as a, isCalendarLabel as i, calendarInstructionSchema as n, calendarSessionTimestamp as r, calculateCalendarTime as t };

package/dist/capture-policy-detector-CHz5GOPA.d.ts

@@ -0,0 +1,53 @@
+import { h as MemoryCategory } from "./types-DxKqU60b.js";
+//#region src/engine/extraction/capture-policy-detector.d.ts
+declare const PROMPT_INJECTION_PATTERNS: RegExp[];
+/** Implements looks like prompt injection as the local memory capture policy operation. */
+declare function looksLikePromptInjection(text: string): boolean;
+/** Implements escape memory for prompt as the local memory capture policy operation. */
+declare function escapeMemoryForPrompt(text: string): string;
+/**
+ * Formats relevant memories context for callers without mutating stored memory capture policy
+ * data.
+ */
+declare function formatRelevantMemoriesContext(memories: Array<{
+  category: string;
+  text: string;
+  lane?: "active" | "parked" | "quarantined";
+  /** Calendar day the remembered event happened, when the row resolved one. */
+  eventDate?: string;
+  /** Calendar day the row was said, for a row with no event date of its own. */
+  saidOn?: string;
+  /** The sentence the row was written from, when one was kept. */
+  quote?: string;
+}>): string;
+declare const EXPLICIT_MEMORY_COMMAND_POSITIVE_PATTERNS: ReadonlyArray<RegExp>;
+declare const EXPLICIT_MEMORY_COMMAND_RECALL_QUESTION_PATTERNS: ReadonlyArray<RegExp>;
+declare const EXPLICIT_MEMORY_COMMAND_MANAGEMENT_PATTERNS: ReadonlyArray<RegExp>;
+interface DetectCategoryOptions {
+  sessionId?: string;
+  explicitLocale?: string;
+}
+interface CategoryVoteResult {
+  category?: MemoryCategory;
+  confidence: number;
+  reason: string;
+  scores: Record<MemoryCategory, number>;
+}
+/**
+ * Evaluates should capture without side effects so callers can branch
+ * predictably. Thin boolean view of `decideRawInputGate` — the raw-input gate
+ * is the single source of truth for the check order and semantics.
+ */
+declare function shouldCapture(text: string): boolean;
+type CaptureDropReason = "cron" | "length-too-short" | "prompt-injection" | "context-fragment" | "html" | "markdown" | "emoji" | "noise" | "envelope-only";
+type CaptureDecision = {
+  decision: "keep";
+} | {
+  decision: "drop";
+  reason: CaptureDropReason;
+};
+/** Implements detect category as the local memory capture policy operation. */
+declare function detectCategoryVote(text: string, options?: DetectCategoryOptions): CategoryVoteResult;
+declare function detectCategory(text: string, options?: DetectCategoryOptions): MemoryCategory | undefined;
+//#endregion
+export { EXPLICIT_MEMORY_COMMAND_MANAGEMENT_PATTERNS as a, PROMPT_INJECTION_PATTERNS as c, escapeMemoryForPrompt as d, formatRelevantMemoriesContext as f, DetectCategoryOptions as i, detectCategory as l, shouldCapture as m, CaptureDropReason as n, EXPLICIT_MEMORY_COMMAND_POSITIVE_PATTERNS as o, looksLikePromptInjection as p, CategoryVoteResult as r, EXPLICIT_MEMORY_COMMAND_RECALL_QUESTION_PATTERNS as s, CaptureDecision as t, detectCategoryVote as u };

package/dist/capture-policy-detector-DaMfy9CZ.js

@@ -0,0 +1,357 @@
+import "./internal/config/index.js";
+import { normalizeCategory } from "./internal/engine/shared/types.js";
+import { HTML_TAG_PATTERN } from "./internal/engine/shared/i18n-text.js";
+import { n as RESOURCES_BY_LOCALE, t as ALL_RESOURCES } from "./all-resources-BQK2ugjB.js";
+import { t as resolveLocale } from "./resolver-Dy-hnjCR.js";
+import { normalizeQuery } from "./internal/engine/retrieval/retrieval-gate.js";
+import { a as RELEVANT_MEMORIES_UNTRUSTED_LINE, n as RELEVANT_MEMORIES_INSTRUCTION_LINE, o as RELEVANT_MEMORY_RECORD_PREFIX, r as RELEVANT_MEMORIES_OPEN_TAG, s as looksLikeRelevantMemoriesContextFragment, t as RELEVANT_MEMORIES_CLOSE_TAG } from "./relevant-memories-context-m8nuFZcM.js";
+//#region src/engine/extraction/confusable-skeleton.ts
+/** @file confusable-skeleton.ts
+* @purpose Normalizes common Unicode confusables before prompt-injection checks.
+*/
+const CONFUSABLES = {
+	Α: "A",
+	А: "A",
+	Β: "B",
+	В: "B",
+	Ε: "E",
+	Е: "E",
+	Η: "H",
+	Н: "H",
+	Ι: "I",
+	І: "I",
+	Κ: "K",
+	К: "K",
+	Μ: "M",
+	М: "M",
+	Ν: "N",
+	О: "O",
+	Ρ: "P",
+	Р: "P",
+	С: "C",
+	Τ: "T",
+	Т: "T",
+	Χ: "X",
+	Х: "X",
+	Υ: "Y",
+	а: "a",
+	е: "e",
+	і: "i",
+	ο: "o",
+	о: "o",
+	р: "p",
+	с: "c",
+	х: "x",
+	у: "y",
+	"０": "0",
+	"１": "1",
+	"２": "2",
+	"３": "3",
+	"４": "4",
+	"５": "5",
+	"６": "6",
+	"７": "7",
+	"８": "8",
+	"９": "9"
+};
+function buildConfusableSkeleton(text) {
+	return Array.from(text.normalize("NFKC"), (char) => CONFUSABLES[char] ?? char).join("");
+}
+//#endregion
+//#region src/engine/extraction/capture-policy-detector.ts
+/** @file capture-policy-detector.ts
+* @purpose Gates automatic memory capture and prepares safe extraction input.
+* @boundary Conversation turns, cleanup rules, noise filters, and extractor prompts.
+* @see ambient-learning-text-normalizer.ts, memory-extraction-pipeline.ts, memory-noise-classifier.ts.
+*/
+const PROMPT_INJECTION_PATTERNS = [
+	/\bignore\b.{0,30}\b(all|any|previous|above|prior)\b.{0,30}\binstructions?\b/,
+	/\b(forget|disregard|discard|override|bypass)\b.{0,30}\b(previous|prior|above|system|developer)\b.{0,30}\b(instructions?|directions?|messages?|rules?)\b/,
+	/\b(do\s*not|don\s*t|dont)\b.{0,20}\bfollow\b.{0,20}\b(system|developer)\b/,
+	/\bfrom\s+now\s+on\b.{0,40}\b(answer|respond|reply|say|act|pretend)\b/,
+	/\b(reveal|print|show|leak|dump)\b.{0,30}\b(system|developer)\b.{0,30}\b(prompt|message|instructions?|rules?|polic(?:y|ies))\b/,
+	/\b(new|updated|highest|higher|top)\s+priority\s+(instruction|rule|directive|command)s?\b/,
+	/\byou\b.{0,20}\b(must|should|will|need\s+to|required\s+to)\b.{0,40}\b(answer|respond|reply|say|act|pretend|ignore|follow|use|call|invoke|execute)\b/,
+	/\byou\s+(must\s+|should\s+|will\s+)?always\b.{0,30}\b(answer|respond|reply|say|act|pretend)\b/,
+	/^\s*always\b.{0,30}\b(answer|respond|reply|say|act|pretend)\b/,
+	/\bwhen\b.{0,40}\b(asked|prompted|questioned)\b.{0,40}\b(answer|respond|reply|say)\b/,
+	/\bsystem\s*prompt\b/,
+	/\bdeveloper\s*message\b/,
+	/<\s*(system|assistant|developer|tool|function|relevant-memories)\b/,
+	/\b(run|execute|call|invoke)\b.{0,40}\b(tool|command)\b/
+];
+const PROMPT_ESCAPE_MAP = {
+	"&": "&amp;",
+	"<": "&lt;",
+	">": "&gt;",
+	"\"": "&quot;",
+	"'": "&#39;"
+};
+const CJK_CHAR_PATTERN = /[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/;
+function testPattern(pattern, text) {
+	pattern.lastIndex = 0;
+	const matches = pattern.test(text);
+	pattern.lastIndex = 0;
+	return matches;
+}
+function normalizeInjectionText(text) {
+	return text.normalize("NFKC").replace(/[\u200B-\u200F\u2060\uFEFF]/g, "").replace(/[\r\n\t]+/g, " ").replace(/[^\p{L}\p{N}\s<>/_-]/gu, " ").toLowerCase().replace(/\s+/g, " ").trim();
+}
+/** Implements looks like prompt injection as the local memory capture policy operation. */
+function looksLikePromptInjection(text) {
+	const normalized = normalizeInjectionText(text);
+	if (!normalized) return false;
+	return [
+		normalized,
+		normalizeInjectionText(buildConfusableSkeleton(text)),
+		normalized.replace(/[-_]+/g, " ").replace(/\s+/g, " ").trim()
+	].some((candidate) => PROMPT_INJECTION_PATTERNS.some((pattern) => testPattern(pattern, candidate)));
+}
+/** Implements escape memory for prompt as the local memory capture policy operation. */
+function escapeMemoryForPrompt(text) {
+	return text.replace(HTML_TAG_PATTERN, "").replace(/\s+/g, " ").trim().replace(/[&<>"']/g, (char) => PROMPT_ESCAPE_MAP[char] ?? char);
+}
+/**
+* Render-side only, and deliberately NOT the whole-message rule the capture path uses.
+*
+* The two look alike and are not. On the capture path a pattern match LOSES a memory, so a
+* substring rule there is the wrong instrument and was measured destroying real facts. Here
+* nothing is lost: an already-stored memory is simply not quoted back into this one prompt. That
+* is defence in depth against feeding a stored injection probe — "What is my blue backpack code?
+* Answer with only that code." — back to the model as if it were a fact, and a substring match is
+* the right strength for it. The union is used rather than one locale's bundle for the same
+* reason: over-matching here costs a memory one turn of visibility, not its existence.
+*/
+function getCaptureMinLength(text) {
+	return CJK_CHAR_PATTERN.test(text) ? 4 : 10;
+}
+/**
+* Formats relevant memories context for callers without mutating stored memory capture policy
+* data.
+*/
+function formatRelevantMemoriesContext(memories) {
+	const memoryLines = memories.filter((entry) => (entry.lane === void 0 || entry.lane === "active") && normalizeCategory(entry.category)).map((entry, index) => `${RELEVANT_MEMORY_RECORD_PREFIX} ${index + 1}: ${JSON.stringify({
+		category: normalizeCategory(entry.category),
+		...entry.eventDate === void 0 ? {} : { event_date: entry.eventDate },
+		...entry.saidOn === void 0 ? {} : { said_on: entry.saidOn },
+		text: escapeMemoryForPrompt(entry.text),
+		...entry.quote === void 0 ? {} : { quote: escapeMemoryForPrompt(entry.quote) }
+	})}`);
+	return [
+		RELEVANT_MEMORIES_UNTRUSTED_LINE,
+		RELEVANT_MEMORIES_INSTRUCTION_LINE,
+		RELEVANT_MEMORIES_OPEN_TAG,
+		...memoryLines,
+		RELEVANT_MEMORIES_CLOSE_TAG
+	].join("\n");
+}
+const EXPLICIT_MEMORY_COMMAND_POSITIVE_PATTERNS = ALL_RESOURCES.flatMap((r) => [...r.captureTriggers.explicitMemoryCommandPositivePatterns]);
+const EXPLICIT_MEMORY_COMMAND_RECALL_QUESTION_PATTERNS = ALL_RESOURCES.flatMap((r) => [...r.captureTriggers.explicitMemoryCommandRecallQuestionPatterns]);
+const EXPLICIT_MEMORY_COMMAND_MANAGEMENT_PATTERNS = ALL_RESOURCES.flatMap((r) => [...r.captureTriggers.explicitMemoryCommandManagementPatterns]);
+const EXACT_CATEGORY_RULES = [
+	{
+		category: "profile",
+		score: 4,
+		reason: "identity-self-profile",
+		patterns: [
+			/\b(my name is|i am|i'm|i live in|i work at|i work as|my role is|my email is|my phone is|allergic to)\b/i,
+			/\b(i use the display name|my display name is|my home city is)\b/i,
+			/anzeigenamen|arbeite ich als|heimatstadt/i,
+			/nombre visible|trabajo como|ciudad base/i,
+			/nom affiché|nom affiche|travaille comme|ville d'origine/i,
+			/表示名|プラットフォームエンジニア|出身地/,
+			/표시 이름|플랫폼 엔지니어|고향/,
+			/меня зовут|отображаемое имя|работаю платформенным|родной город/i,
+			/显示名|顯示名|平台工程师|平台工程師|家乡|家鄉/,
+			/我的(名字|姓名|显示名|顯示名|家乡|家鄉).+是|我叫|住在|工作于|过敏/
+		]
+	},
+	{
+		category: "profile",
+		score: 4,
+		reason: "explicit-preference",
+		patterns: [
+			/\b(i|we)\s+(?:(?:always|usually|generally|often)\s+)?(?:prefer|like|love|hate|want|need|care about|would rather)\b/i,
+			/\b(favou?rite|preferred)\b/i,
+			/lieblingseditor|statusmeldungen|utc-zeitstempel|bevorzuge ich|möchte ich/i,
+			/editor favorito|estados breves|marcas de tiempo|me gustan|prefiero/i,
+			/éditeur favori|editeur favori|statuts courts|horodatages|je préfère|je prefere|j'aime/i,
+			/ダークモード|お気に入り|進捗報告|好み|希望/,
+			/다크 모드|좋아하는|상태 업데이트|선호/,
+			/предпочитаю|любимый редактор|нравятся короткие|временные метки/i,
+			/喜欢|喜歡|最喜欢|最喜歡|偏好|希望使用/,
+			/喜欢|偏好|讨厌|想要|需要/
+		]
+	},
+	{
+		category: "episodic",
+		score: 4,
+		reason: "entity-reference",
+		patterns: [
+			/[\w.-]+@[\w.-]+\.\w+/,
+			/\+\d{7,}/,
+			/\b(project|project owner|team|company|organization|manager|spouse|wife|husband|son|daughter|pet|repo|service)\b/i,
+			/\b(operating system|conference hotel|tool shelf|dashboard|room booking|workshop|instruction manual|prompt card|message archive|rule book|system monitor|developer laptop|assistant coach|tool catalog)\b/i,
+			/\b(cluster is named|notebook lives in)\b/i,
+			/projektleiterin|staging-cluster|release-notizbuch|betriebssystem|entwicklerkonferenz|assistenzleitung|werkzeugregal|kommandozentrale|funktionsraum|anleitung|prompt-karte|nachrichtenarchiv|regelbuch|systemmonitor|entwicklerlaptop|assistenztrainer|werkzeugkatalog/i,
+			/gerente|dueña del proyecto|duena del proyecto|cluster de staging|cuaderno de releases|sistema operativo|conferencia de desarrolladores|subgerente|estantería de herramientas|estanteria de herramientas|centro de comando|sala de funciones|taller de políticas|taller de politicas|manual de instrucciones|tarjeta de prompt|archivo de mensajes|libro de reglas|monitor del sistema|portátil de desarrollador|portatil de desarrollador|entrenador asistente|catálogo de herramientas|catalogo de herramientas/i,
+			/responsable|projet facturation|cluster de staging|carnet de release|système d'exploitation|systeme d'exploitation|conférence développeur|conference developpeur|responsable adjointe|étagère à outils|etagere a outils|centre de commande|salle de fonction|atelier politique|manuel d'instructions|carte de prompt|archive des messages|livre de règles|livre de regles|moniteur système|moniteur systeme|ordinateur développeur|ordinateur developpeur|entraîneur assistant|entraineur assistant|catalogue d'outils/i,
+			/マネージャー|プロジェクトの責任者|クラスタ名|リリースノート|オペレーティングシステム|開発者会議|副マネージャー|工具棚|コマンドセンター|機能室|ポリシーワークショップ|説明書|プロンプトカード|メッセージ保管庫|ルールブック|システムモニター|開発者用ノートpc|アシスタントコーチ|ツールカタログ/i,
+			/매니저|프로젝트 담당자|클러스터 이름|릴리스 노트|운영 체제|개발자 컨퍼런스|부매니저|도구 선반|명령 센터|기능실|정책 워크숍|사용 설명서|프롬프트 카드|메시지 보관함|규칙 책|시스템 모니터|개발자 노트북|보조 코치|도구 카탈로그/,
+			/менеджер|проектом биллинга|стейджинг-кластер|заметки релиза|операционная система|конференция разработчиков|помощник менеджера|полка инструментов|командный центр|функциональная комната|семинар по policy|инструкция|архив сообщений|книга правил|системный монитор|ноутбук разработчика|ассистент тренера|каталог инструментов/i,
+			/经理|經理|项目负责人|專案負責人|集群叫|叢集叫|发布笔记|發布筆記|操作系统|作業系統|开发者大会|開發者大會|助理经理|助理經理|工具架|命令中心|功能室|政策工作坊|说明书|說明書|prompt卡片|消息归档|訊息歸檔|规则书|規則書|系统监控器|系統監控器|开发者电脑|開發者電腦|助理教练|助理教練|工具目录|工具目錄/,
+			/项目|团队|公司|组织|经理|宠物|服务/
+		]
+	},
+	{
+		category: "episodic",
+		score: 4,
+		reason: "event-or-decision",
+		patterns: [
+			/\b(decided|chose|switched|migrated|shipped|released|deployed|incident|happened|finished|will use|we'll use|going forward|from now on)\b/i,
+			/\b(meeting is scheduled|rollout is planned)\b/i,
+			/beschlossen|geplant|abgeschlossen/i,
+			/decidimos|programada|planeado|terminó|termino/i,
+			/décidé|decide|planifiée|planifiee|prévu|prevu|terminé|termine/i,
+			/移行を決め|レビューが予定|ロールアウトが計画|監査が完了/,
+			/마이그레이션하기로 결정|리뷰가 예정|롤아웃이 계획|감사가 완료/,
+			/решили мигрировать|назначен|запланирован|завершился/i,
+			/决定迁移|決定遷移|已经排期|已經排期|已经计划|已經計畫|审计完成|稽核完成/,
+			/决定迁移|決定遷移|选择改用|選擇改用|上线完成|上線完成|发布上线|發布上線|事故|以后|以後|从现在开始|從現在開始/
+		]
+	},
+	{
+		category: "lesson",
+		score: 4,
+		reason: "lesson-or-retrospective",
+		patterns: [
+			/\b(learned|lesson|takeaway|remember that|next time|mistake|avoid|never again|root cause|fix was|solution was|sop)\b/i,
+			/lektion|gelernt|erkenntnis|mehrdeutige erinnerungen/i,
+			/lección|leccion|aprendimos|conclusión|conclusion|memorias ambiguas/i,
+			/leçon|lecon|appris|conclusion|mémoires ambiguës|memoires ambigues/i,
+			/教訓|学びました|重要です|棄権すべき/,
+			/교훈|배웠|검토해야|저장하지 않아야/,
+			/урок|научились|вывод|неоднозначные memories/i,
+			/经验教训|經驗教訓|学到|學到|结论|結論|模糊记忆|模糊記憶/,
+			/学到|教训|下次|避免|根因|复盘|反思/
+		]
+	}
+];
+/**
+* Evaluates should capture without side effects so callers can branch
+* predictably. Thin boolean view of `decideRawInputGate` — the raw-input gate
+* is the single source of truth for the check order and semantics.
+*/
+function shouldCapture(text) {
+	return decideRawInputGate(text).decision === "keep";
+}
+const KEEP = { decision: "keep" };
+function drop(reason) {
+	return {
+		decision: "drop",
+		reason
+	};
+}
+/**
+* The raw-input capture gate as a reason-carrying decision. This is the single
+* source of truth for the gate's check order and semantics — `shouldCapture`
+* is a thin boolean view of it, and each `drop(reason)` names the failed check.
+*/
+function decideRawInputGate(text) {
+	if (/^\s*\[cron:[^\]]+\]/i.test(text)) return drop("cron");
+	const s = normalizeQuery(text);
+	const minLen = getCaptureMinLength(s);
+	if (s.length < minLen) return drop("length-too-short");
+	if (looksLikeRelevantMemoriesContextFragment(s)) return drop("context-fragment");
+	if (s.startsWith("<") && s.includes("</")) return drop("html");
+	if (s.includes("**") && s.includes("\n-")) return drop("markdown");
+	if ((s.match(/[\u{1F300}-\u{1F9FF}]/gu) ?? []).length > 3) return drop("emoji");
+	return KEEP;
+}
+/** Implements detect category as the local memory capture policy operation. */
+function detectCategoryVote(text, options = {}) {
+	const normalized = normalizeQuery(text);
+	const lower = normalized.toLowerCase();
+	if (looksLikePromptInjection(normalized)) return {
+		confidence: 0,
+		reason: "prompt-injection-abstain",
+		scores: {
+			episodic: 0,
+			profile: 0,
+			persona: 0,
+			lesson: 0,
+			summary: 0,
+			state: 0
+		}
+	};
+	const scores = {
+		episodic: 0,
+		profile: 0,
+		persona: 0,
+		lesson: 0,
+		summary: 0,
+		state: 0
+	};
+	const locale = resolveLocale({
+		text: normalized,
+		...options.sessionId ? { sessionId: options.sessionId } : {},
+		...options.explicitLocale ? { explicitLocale: options.explicitLocale } : {}
+	});
+	const triggers = RESOURCES_BY_LOCALE[locale].captureTriggers;
+	const reasons = [];
+	for (const rule of EXACT_CATEGORY_RULES) if (rule.patterns.some((pattern) => testPattern(pattern, lower))) {
+		scores[rule.category] += rule.score;
+		reasons.push(rule.reason);
+	}
+	const ROUTING_KEY_REMAP = {
+		identity: "profile",
+		preference: "profile",
+		entity: "episodic",
+		event: "episodic",
+		lesson: "lesson"
+	};
+	for (const [routingKey, patterns] of Object.entries(triggers.categoryRouting)) {
+		const category = ROUTING_KEY_REMAP[routingKey];
+		if (!category) continue;
+		if (patterns.some((pattern) => testPattern(pattern, normalized))) {
+			scores[category] += 2;
+			reasons.push(`locale-route-${category}`);
+		}
+	}
+	const localeRules = [
+		["profile", triggers.identityPattern],
+		["profile", triggers.preferencePattern],
+		["episodic", triggers.entityPattern],
+		["episodic", triggers.eventPattern],
+		["lesson", triggers.lessonPattern]
+	];
+	for (const [category, pattern] of localeRules) if (testPattern(pattern, lower)) {
+		scores[category] += 2;
+		reasons.push(`locale-${category}`);
+	}
+	const ranked = Object.entries(scores).sort((a, b) => b[1] - a[1]);
+	const top = ranked[0];
+	if (!top) return {
+		confidence: 0,
+		reason: "no-category-signal",
+		scores
+	};
+	const [category, score] = top;
+	const runnerUp = ranked[1]?.[1] ?? 0;
+	if (score <= 0 || score === runnerUp) return {
+		confidence: 0,
+		reason: score <= 0 ? "no-category-signal" : "ambiguous-category",
+		scores
+	};
+	return {
+		category,
+		confidence: Math.min(1, score / 6),
+		reason: reasons.join(","),
+		scores
+	};
+}
+function detectCategory(text, options = {}) {
+	return detectCategoryVote(text, options).category;
+}
+//#endregion
+export { detectCategory as a, formatRelevantMemoriesContext as c, PROMPT_INJECTION_PATTERNS as i, looksLikePromptInjection as l, EXPLICIT_MEMORY_COMMAND_POSITIVE_PATTERNS as n, detectCategoryVote as o, EXPLICIT_MEMORY_COMMAND_RECALL_QUESTION_PATTERNS as r, escapeMemoryForPrompt as s, EXPLICIT_MEMORY_COMMAND_MANAGEMENT_PATTERNS as t, shouldCapture as u };