@snoai/memory 0.0.0-stage → 1.0.0

package/dist/all-resources-Dij6l5h0.d.ts

@@ -0,0 +1,18 @@
+import { n as Locale } from "./locales-JxGmkG6t.js";
+import { a as LocaleResources } from "./_types-CUKHSRkS.js";
+//#region src/engine/i18n/all-resources.d.ts
+/**
+ * Static union of every supported-locale's resource bundle.
+ *
+ * Step B re-exports source-file constants (capture/noise/adaptive/intent)
+ * as the union over this list so legacy callers see the merged regex of
+ * all 9 locales without an async `t(locale, ns)` call. Imports are static
+ * so `MEMORY_TRIGGERS` etc. remain top-level constants.
+ *
+ * Order is canonical (en first, then alphabetical) but call sites must NOT
+ * depend on order — `.some(p => p.test(s))` is the only contract.
+ */
+declare const ALL_RESOURCES: ReadonlyArray<LocaleResources>;
+declare const RESOURCES_BY_LOCALE: Record<Locale, LocaleResources>;
+//#endregion
+export { RESOURCES_BY_LOCALE as n, ALL_RESOURCES as t };

package/dist/ambient-learning-text-normalizer-CxjATmMp.js

@@ -0,0 +1,170 @@
+import { i as RELEVANT_MEMORIES_PREAMBLE_LINES, r as RELEVANT_MEMORIES_OPEN_TAG, t as RELEVANT_MEMORIES_CLOSE_TAG } from "./relevant-memories-context-m8nuFZcM.js";
+//#region src/engine/extraction/runtime-wrapper-sanitizer.ts
+/** @file runtime-wrapper-sanitizer.ts
+* @purpose Single source of truth for stripping `[Subagent Context|Task]` wrappers
+*          and the boilerplate that follows them from the lead-in of captured text.
+* @boundary Used by both `memory-extraction-pipeline.ts` (envelope path) and
+*           `ambient-learning-text-normalizer.ts` (ambient-learning normalization path) so the same
+*           input always produces the same stripped output regardless of entry point.
+* @see memory-extraction-pipeline.ts, ambient-learning-text-normalizer.ts.
+*/
+const RUNTIME_WRAPPER_LINE_RE = /^\[(?:Subagent Context|Subagent Task)\]\s*/i;
+const RUNTIME_WRAPPER_PREFIX_RE = /^\[(?:Subagent Context|Subagent Task)\]/i;
+const RUNTIME_WRAPPER_BOILERPLATE_RE = /(?:You are running as a subagent\b[.,;:!?]*\s*|Results auto-announce to your requester\.?\s*|do not busy-poll for status\.?\s*|Reply with a brief acknowledgment only\.?\s*|Do not use any memory tools\.?\s*)/gi;
+const RUNTIME_WRAPPER_BOILERPLATE_PROBE_RE = /(?:You are running as a subagent\b|Results auto-announce to your requester|do not busy-poll for status|Reply with a brief acknowledgment only|Do not use any memory tools)/i;
+/**
+* Strip every occurrence of runtime-wrapper boilerplate phrases from a single
+* text fragment, collapse internal whitespace, and trim. Used both for cleaning
+* the remainder of a wrapper line and for cleaning post-wrapper content lines
+* whose prefix looks like boilerplate but whose tail is real user content.
+*/
+function stripRuntimeWrapperBoilerplate(text) {
+	return text.replace(RUNTIME_WRAPPER_BOILERPLATE_RE, "").replace(/\s{2,}/g, " ").trim();
+}
+/**
+* Strip `[Subagent Context|Task]` wrapper lines and the boilerplate noise that
+* follows them from the leading edge of `text`. Anything past the first real
+* user content line is preserved untouched.
+*
+* Algorithm (single canonical impl):
+*   1. Skip leading blank lines.
+*   2. If the first non-blank line is a wrapper marker, strip its prefix and
+*      any inline boilerplate. Mark wrapper-encountered. Push only the cleaned
+*      remainder if non-empty; either way exit the leading wrapper region.
+*   3. After a wrapper has been seen, while still in the lead-in:
+*        - If the line contains boilerplate (full or prefix), strip it.
+*          - If the result is empty → drop the whole line.
+*          - If non-empty → push the cleaned text, exit lead-in.
+*        - If no boilerplate matches, push the line unchanged, exit lead-in.
+*   4. All subsequent lines pass through unchanged.
+*/
+function stripLeadingRuntimeWrappers(text) {
+	const trimmed = text.trim();
+	if (!trimmed) return trimmed;
+	const lines = trimmed.split("\n");
+	const cleanedLines = [];
+	let strippingLeadIn = true;
+	let encounteredWrapperYet = false;
+	for (const line of lines) {
+		const current = line.trim();
+		if (strippingLeadIn && current === "") continue;
+		if (strippingLeadIn && RUNTIME_WRAPPER_PREFIX_RE.test(current)) {
+			encounteredWrapperYet = true;
+			const remainder = current.replace(RUNTIME_WRAPPER_LINE_RE, "").trim();
+			const cleaned = remainder ? stripRuntimeWrapperBoilerplate(remainder) : "";
+			if (cleaned) {
+				cleanedLines.push(cleaned);
+				strippingLeadIn = false;
+			}
+			continue;
+		}
+		if (strippingLeadIn && encounteredWrapperYet && RUNTIME_WRAPPER_BOILERPLATE_PROBE_RE.test(line)) {
+			const cleaned = stripRuntimeWrapperBoilerplate(line);
+			if (cleaned) {
+				cleanedLines.push(cleaned);
+				strippingLeadIn = false;
+			}
+			continue;
+		}
+		strippingLeadIn = false;
+		cleanedLines.push(line);
+	}
+	return cleanedLines.join("\n").trim();
+}
+//#endregion
+//#region src/engine/extraction/ambient-learning-text-normalizer.ts
+/** @file ambient-learning-text-normalizer.ts
+* @purpose Normalizes Ambient Learning conversation text before extraction and storage.
+* @boundary Capture filters, prompt-injection boundaries, and Insight Distill input quality.
+* @see capture-policy-detector.ts, memory-extraction-pipeline.ts, memory-noise-classifier.ts.
+*/
+/**
+* Ambient Learning text cleanup utilities.
+*
+* Strips platform envelope metadata, session reset prefixes, addressing
+* prefixes, and runtime wrapper boilerplate from user messages before
+* they reach Insight Distill or deterministic storage.
+*/
+const AMBIENT_LEARNING_INBOUND_META_SENTINELS = [
+	"Conversation info (untrusted metadata):",
+	"Sender (untrusted metadata):",
+	"Thread starter (untrusted, for context):",
+	"Replied message (untrusted, for context):",
+	"Forwarded message context (untrusted metadata):",
+	"Chat history since last reply (untrusted, for context):"
+];
+const AMBIENT_LEARNING_SESSION_RESET_PREFIX = "A new session was started via /new or /reset. Execute your Session Startup sequence now";
+const AMBIENT_LEARNING_ADDRESSING_PREFIX_RE = /^(?:<@!?[0-9]+>|@[A-Za-z0-9_.-]+)[,:\s]*/;
+const AMBIENT_LEARNING_SYSTEM_EVENT_LINE_RE = /^System:\s*\[[^\n]*?\]\s*Exec\s+(?:completed|failed|started)\b.*$/gim;
+/** Implements escape reg exp as the local Ambient Learning normalization operation. */
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+const RELEVANT_MEMORIES_PREAMBLE_RE = RELEVANT_MEMORIES_PREAMBLE_LINES.map((line) => `${escapeRegExp(line)}\\s*\\n\\s*`).join("");
+const RELEVANT_MEMORIES_BLOCK_RE = new RegExp(`(?:${RELEVANT_MEMORIES_PREAMBLE_RE})?${escapeRegExp(RELEVANT_MEMORIES_OPEN_TAG)}\\s*[\\s\\S]*?${escapeRegExp(RELEVANT_MEMORIES_CLOSE_TAG)}\\s*`, "gi");
+const RELEVANT_MEMORIES_PREAMBLE_ONLY_RE = new RegExp(`^(?:${RELEVANT_MEMORIES_PREAMBLE_RE})`);
+const AMBIENT_LEARNING_INBOUND_META_BLOCK_RE = new RegExp(String.raw`(?:^|\n)\s*(?:${AMBIENT_LEARNING_INBOUND_META_SENTINELS.map((sentinel) => escapeRegExp(sentinel)).join("|")})\s*\n\`\`\`json[\s\S]*?\n\`\`\`\s*`, "g");
+/**
+* Implements strip leading inbound metadata as the local Ambient Learning normalization operation.
+*/
+function stripLeadingInboundMetadata(text) {
+	if (!text) return text;
+	let normalized = text;
+	for (let i = 0; i < 6; i++) {
+		const before = normalized;
+		normalized = normalized.replace(AMBIENT_LEARNING_SYSTEM_EVENT_LINE_RE, "\n");
+		normalized = normalized.replace(AMBIENT_LEARNING_INBOUND_META_BLOCK_RE, "\n");
+		normalized = normalized.replace(/\n{3,}/g, "\n\n").trim();
+		if (normalized === before.trim()) break;
+	}
+	return normalized.trim();
+}
+/**
+* Removes session reset boilerplate so Ambient Learning stores the user's actual message,
+* not lifecycle instructions injected by the host runtime.
+*/
+function stripAmbientLearningSessionResetPrefix(text) {
+	const trimmed = text.trim();
+	if (!trimmed.startsWith(AMBIENT_LEARNING_SESSION_RESET_PREFIX)) return trimmed;
+	const blankLineIndex = trimmed.indexOf("\n\n");
+	if (blankLineIndex >= 0) return trimmed.slice(blankLineIndex + 2).trim();
+	const lines = trimmed.split("\n");
+	if (lines.length <= 2) return "";
+	return lines.slice(2).join("\n").trim();
+}
+/**
+* Removes direct mention/addressing prefixes that help route a chat message but do not
+* belong in persisted long-term context.
+*/
+function stripAmbientLearningAddressingPrefix(text) {
+	return text.replace(AMBIENT_LEARNING_ADDRESSING_PREFIX_RE, "").trim();
+}
+/**
+* Removes retrieval context and runtime wrapper text before Ambient Learning evaluates
+* what the user actually said.
+*/
+function stripAmbientLearningInjectedPrefix(role, text) {
+	if (role !== "user") return text.trim();
+	let normalized = text.trim();
+	normalized = normalized.replace(RELEVANT_MEMORIES_BLOCK_RE, "");
+	normalized = normalized.replace(RELEVANT_MEMORIES_PREAMBLE_ONLY_RE, "");
+	normalized = normalized.replace(/\[UNTRUSTED DATA[^\n]*\][\s\S]*?\[END UNTRUSTED DATA\]\s*/gi, "");
+	normalized = stripAmbientLearningSessionResetPrefix(normalized);
+	normalized = stripLeadingInboundMetadata(normalized);
+	normalized = stripAmbientLearningAddressingPrefix(normalized);
+	normalized = stripLeadingRuntimeWrappers(normalized);
+	normalized = stripLeadingInboundMetadata(normalized);
+	normalized = normalized.replace(/\n{3,}/g, "\n\n");
+	return normalized.trim();
+}
+/** Normalizes conversation text at the boundary before Ambient Learning uses it. */
+function normalizeAmbientLearningText(role, text, shouldSkipMessage) {
+	if (typeof role !== "string") return null;
+	if (typeof text !== "string") return null;
+	const normalized = stripAmbientLearningInjectedPrefix(role, text);
+	if (!normalized) return null;
+	if (shouldSkipMessage?.(role, normalized)) return null;
+	return normalized;
+}
+//#endregion
+export { stripAmbientLearningInjectedPrefix as n, stripLeadingRuntimeWrappers as r, normalizeAmbientLearningText as t };

package/dist/ambient-learning-text-normalizer-_fH3LeuK.d.ts

@@ -0,0 +1,10 @@
+//#region src/engine/extraction/ambient-learning-text-normalizer.d.ts
+/**
+ * Removes retrieval context and runtime wrapper text before Ambient Learning evaluates
+ * what the user actually said.
+ */
+declare function stripAmbientLearningInjectedPrefix(role: string, text: string): string;
+/** Normalizes conversation text at the boundary before Ambient Learning uses it. */
+declare function normalizeAmbientLearningText(role: unknown, text: unknown, shouldSkipMessage?: (role: string, text: string) => boolean): string | null;
+//#endregion
+export { stripAmbientLearningInjectedPrefix as n, normalizeAmbientLearningText as t };