@snoai/memory 0.0.0-stage → 1.0.0

package/dist/internal/engine/provider/provider-registration.d.ts

@@ -0,0 +1,39 @@
+import { t as PluginConfig } from "../../../plugin-config-schema-C0UUbOmG.js";
+import "../../../types-DxKqU60b.js";
+import { n as SnoStationMemMemoryRuntime, t as ProviderHostConfig } from "../../../provider-runtime-types-DFhtdA6d.js";
+import { C as MemoryStore } from "../../../memory-store-base-XRA4S9Xl.js";
+import "../../../store-2pM0-dZg.js";
+import { r as ProviderIdentity } from "../../../provider-types-CZGm6v88.js";
+//#region src/engine/provider/provider-registration.d.ts
+type AgentEntry = {
+  id?: unknown;
+  workspace?: unknown;
+};
+/** The configured provider.userId, else this machine's identity (the same id every skin sees). */
+export declare function readTrustedUserId(config: PluginConfig): string;
+export declare function readConfiguredAgents(cfg: ProviderHostConfig): AgentEntry[];
+export declare function readAgentWorkspace(cfg: ProviderHostConfig, agentId: string): string;
+export declare function resolveProviderIdentity(params: {
+  cfg: ProviderHostConfig;
+  config: PluginConfig;
+  store: MemoryStore;
+  agentId: string;
+}): Promise<{
+  identity: ProviderIdentity;
+  workspaceDir: string;
+}>;
+export declare function readProviderIdentity(params: {
+  cfg: ProviderHostConfig;
+  config: PluginConfig;
+  store: MemoryStore;
+  agentId: string;
+}): Promise<{
+  identity: ProviderIdentity;
+  workspaceDir: string;
+}>;
+export declare function createMemoryRuntime(params: {
+  config: PluginConfig;
+  store: MemoryStore;
+  stateDir: string;
+}): SnoStationMemMemoryRuntime;
+//#endregion

package/dist/internal/engine/provider/provider-registration.js

@@ -0,0 +1,2 @@
+import { a as readTrustedUserId, i as readProviderIdentity, n as readAgentWorkspace, o as resolveProviderIdentity, r as readConfiguredAgents, t as createMemoryRuntime } from "../../../provider-registration-CF1tg8Xy.js";
+export { createMemoryRuntime, readAgentWorkspace, readConfiguredAgents, readProviderIdentity, readTrustedUserId, resolveProviderIdentity };

package/dist/internal/engine/provider/provider-row-renderer.d.ts

@@ -0,0 +1,7 @@
+import { g as MemoryEntry } from "../../../types-DxKqU60b.js";
+//#region src/engine/provider/provider-row-renderer.d.ts
+export declare function isProviderRowId(id: string): boolean;
+export declare function isProviderRowArtifactFileName(name: string): boolean;
+export declare function providerRowPath(id: string): string;
+export declare function renderProviderRowMemory(entry: MemoryEntry): string;
+//#endregion

package/dist/internal/engine/provider/provider-row-renderer.js

@@ -0,0 +1,53 @@
+import { gt as FIXED_PROTOCOL_VALUE_77 } from "../../../signed-registry-constants-yq3DlG3B.js";
+//#region src/engine/provider/provider-row-renderer.ts
+const PROVIDER_ROW_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+const PROVIDER_ROW_ARTIFACT_FILE_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.md$/;
+function sortJson(value) {
+	if (Array.isArray(value)) return value.map(sortJson);
+	if (!value || typeof value !== "object") return value;
+	const sorted = {};
+	for (const key of Object.keys(value).sort()) sorted[key] = sortJson(value[key]);
+	return sorted;
+}
+function formatMetadata(raw) {
+	try {
+		return JSON.stringify(sortJson(JSON.parse(raw)), null, 2);
+	} catch {
+		return JSON.stringify({ raw }, null, 2);
+	}
+}
+function isProviderRowId(id) {
+	return PROVIDER_ROW_ID_RE.test(id);
+}
+function isProviderRowArtifactFileName(name) {
+	return PROVIDER_ROW_ARTIFACT_FILE_RE.test(name);
+}
+function providerRowPath(id) {
+	if (!isProviderRowId(id)) throw new Error("Provider row id must be a lowercase UUID");
+	return `${FIXED_PROTOCOL_VALUE_77}${id}.md`;
+}
+function renderProviderRowMemory(entry) {
+	const metadata = formatMetadata(entry.metadata);
+	return [
+		`# ${providerRowPath(entry.id)}`,
+		"",
+		`- Memory ID: ${entry.id}`,
+		`- Category: ${entry.category}`,
+		`- Project ID: ${entry.projectId}`,
+		`- Timestamp: ${new Date(entry.timestamp).toISOString()}`,
+		`- Importance: ${entry.importance}`,
+		"",
+		"## Memory",
+		"",
+		entry.text,
+		"",
+		"## Metadata",
+		"",
+		"```json",
+		metadata,
+		"```",
+		""
+	].join("\n");
+}
+//#endregion
+export { isProviderRowArtifactFileName, isProviderRowId, providerRowPath, renderProviderRowMemory };

package/dist/internal/engine/provider/provider-types.d.ts

@@ -0,0 +1,2 @@
+import { i as ProviderMembershipGrantInput, n as ProviderExternalSystem, r as ProviderIdentity, t as ProviderAuthorityInput } from "../../../provider-types-CZGm6v88.js";
+export { ProviderAuthorityInput, ProviderExternalSystem, ProviderIdentity, ProviderMembershipGrantInput };

package/dist/internal/engine/provider/provider-types.js

@@ -0,0 +1 @@
+export {};

package/dist/internal/engine/reflection/daily-log-generator.d.ts

@@ -0,0 +1,2 @@
+import { a as buildReflectionFallbackText, c as generateReflectionText, d as shouldSkipReflectionMessage, f as writeReflectionToFilesystem, i as WriteReflectionFsParams, l as readSessionConversationForReflection, n as ReflectionGenerator, o as buildReflectionPrompt, p as extractTextContent, r as ReflectionResult, s as ensureDailyLogFile, t as REFLECTION_FALLBACK_MARKER, u as readSessionConversationWithResetFallback } from "../../../daily-log-generator-CsQPHl4A.js";
+export { REFLECTION_FALLBACK_MARKER, ReflectionGenerator, ReflectionResult, WriteReflectionFsParams, buildReflectionFallbackText, buildReflectionPrompt, ensureDailyLogFile, extractTextContent, generateReflectionText, readSessionConversationForReflection, readSessionConversationWithResetFallback, shouldSkipReflectionMessage, writeReflectionToFilesystem };

package/dist/internal/engine/reflection/daily-log-generator.js

@@ -0,0 +1,2 @@
+import { a as generateReflectionText, c as shouldSkipReflectionMessage, i as ensureDailyLogFile, l as writeReflectionToFilesystem, n as buildReflectionFallbackText, o as readSessionConversationForReflection, r as buildReflectionPrompt, s as readSessionConversationWithResetFallback, t as REFLECTION_FALLBACK_MARKER, u as extractTextContent } from "../../../daily-log-generator-CH_KuWHs.js";
+export { REFLECTION_FALLBACK_MARKER, buildReflectionFallbackText, buildReflectionPrompt, ensureDailyLogFile, extractTextContent, generateReflectionText, readSessionConversationForReflection, readSessionConversationWithResetFallback, shouldSkipReflectionMessage, writeReflectionToFilesystem };

package/dist/internal/engine/reflection/reflection-command-hooks.d.ts

@@ -0,0 +1,2 @@
+import { n as createRunMemoryReflection, t as ReflectionCommandParams } from "../../../reflection-command-hooks-C1Vxgb-O.js";
+export { ReflectionCommandParams, createRunMemoryReflection };

package/dist/internal/engine/reflection/reflection-command-hooks.js

@@ -0,0 +1,2 @@
+import { t as createRunMemoryReflection } from "../../../reflection-command-hooks-BeQiJI9-.js";
+export { createRunMemoryReflection };

package/dist/internal/engine/reflection/reflection-deps.d.ts

@@ -0,0 +1,2 @@
+import { t as ReflectionDeps } from "../../../reflection-deps-RpLPFrSc.js";
+export { ReflectionDeps };

package/dist/internal/engine/reflection/reflection-deps.js

@@ -0,0 +1 @@
+export {};

package/dist/internal/engine/reflection/reflection-embedded-generator.d.ts

@@ -0,0 +1,2 @@
+import { a as resolveWorkspaceDirFromEvent, i as pruneReflectionState, n as createReflectionGenerator, r as isInternalReflectionSessionKey, t as DEFAULT_MEMORY_LLM_CONFIG } from "../../../reflection-embedded-generator-CxOex5xK.js";
+export { DEFAULT_MEMORY_LLM_CONFIG, createReflectionGenerator, isInternalReflectionSessionKey, pruneReflectionState, resolveWorkspaceDirFromEvent };

package/dist/internal/engine/reflection/reflection-embedded-generator.js

@@ -0,0 +1,2 @@
+import { a as resolveWorkspaceDirFromEvent, i as pruneReflectionState, n as createReflectionGenerator, r as isInternalReflectionSessionKey, t as DEFAULT_MEMORY_LLM_CONFIG } from "../../../reflection-embedded-generator-CDUhgV96.js";
+export { DEFAULT_MEMORY_LLM_CONFIG, createReflectionGenerator, isInternalReflectionSessionKey, pruneReflectionState, resolveWorkspaceDirFromEvent };

package/dist/internal/engine/reflection/reflection-injection-hooks.d.ts

@@ -0,0 +1,2 @@
+import { i as createReflectionInjectionHandler3, n as createReflectionInjectionHandler1, r as createReflectionInjectionHandler2, t as ReflectionInjectionParams } from "../../../reflection-injection-hooks-DfUgqu8f.js";
+export { ReflectionInjectionParams, createReflectionInjectionHandler1, createReflectionInjectionHandler2, createReflectionInjectionHandler3 };

package/dist/internal/engine/reflection/reflection-injection-hooks.js

@@ -0,0 +1,219 @@
+import { vt as FIXED_PROTOCOL_VALUE_79 } from "../../../signed-registry-constants-yq3DlG3B.js";
+import { c as getReflectionDerivedSuppression, d as getReflectionDerivedCacheEntry, r as isInternalReflectionSessionKey, s as deleteReflectionDerivedSuppression } from "../../../reflection-embedded-generator-CDUhgV96.js";
+import { createLogger, privateLogReference } from "@snoai/utils/logger";
+//#region src/engine/reflection/reflection-injection-hooks.ts
+const diagnosticLog = createLogger("sno-station-mem:reflection-injection-hooks");
+function appendPendingErrorBlock(params, sessionKey, blocks) {
+	if (!sessionKey) return;
+	const pending = params.errorTracker.getPendingSignals(sessionKey, params.reflectionCfg.errorReminderMaxEntries);
+	if (pending.length === 0) return;
+	blocks.push([
+		"<error-detected>",
+		"A tool error was detected. Consider logging this to `.learnings/ERRORS.md` if it is non-trivial or likely to recur.",
+		"Recent error signals:",
+		...pending.map((e, i) => `${i + 1}. [${e.toolName}] ${e.summary}`),
+		"</error-detected>"
+	].join("\n"));
+}
+function recordReflectionInjectUsage(params, input) {
+	if (!params.telemetryUsage) return;
+	for (const source of selectRenderedSources(input.renderedLines, input.sources)) params.telemetryUsage.tryAcceptUsage({
+		eventType: "inject",
+		factId: source.factId,
+		memoryKind: source.memoryKind,
+		projectId: source.projectId,
+		agentId: input.agentId,
+		sessionUuid: input.sessionKey || void 0,
+		turnId: input.turnId,
+		retrievalRank: source.rank,
+		retrievalScore: source.score,
+		metadata: {
+			injection_surface: input.surface,
+			retrieval_rank: source.rank,
+			retrieval_score: source.score,
+			...source.sourceAgentId !== input.agentId && { source_agent_id: source.sourceAgentId }
+		}
+	});
+}
+function selectRenderedSources(renderedLines, sources) {
+	const remaining = /* @__PURE__ */ new Map();
+	for (const line of renderedLines) remaining.set(line, (remaining.get(line) ?? 0) + 1);
+	const selected = [];
+	for (const source of sources) {
+		const count = remaining.get(source.line) ?? 0;
+		if (count <= 0) continue;
+		selected.push(source);
+		if (count === 1) remaining.delete(source.line);
+		else remaining.set(source.line, count - 1);
+	}
+	return selected;
+}
+function readTurnId(ctx) {
+	if (typeof ctx.turnId === "string" && ctx.turnId.trim()) return ctx.turnId.trim();
+	if (typeof ctx.sessionId === "string" && ctx.sessionId.trim()) return ctx.sessionId.trim();
+}
+function createReflectionInjectionHandler1(params) {
+	return async (_event, ctx) => {
+		const sessionKey = typeof ctx.sessionKey === "string" ? ctx.sessionKey : "";
+		if (sessionKey.includes(":subagent:")) return;
+		if (isInternalReflectionSessionKey(sessionKey)) return;
+		try {
+			params.doPrune();
+			const agentId = typeof ctx.agentId === "string" && ctx.agentId.trim() ? ctx.agentId.trim() : "main";
+			const scopes = params.scopePolicy.getAccessibleScopes(agentId);
+			const slices = await params.sliceLoader.loadAgentReflectionSlices(agentId, scopes);
+			if (slices.invariants.length === 0) return;
+			const renderedLines = slices.invariants.slice(0, 6);
+			const body = renderedLines.map((line, i) => `${i + 1}. ${line}`).join("\n");
+			recordReflectionInjectUsage(params, {
+				agentId,
+				sessionKey,
+				turnId: readTurnId(ctx),
+				surface: "reflection_inherited_rules",
+				renderedLines,
+				sources: slices.invariantSources
+			});
+			return { prependContext: [
+				"<inherited-rules>",
+				FIXED_PROTOCOL_VALUE_79,
+				body,
+				"</inherited-rules>"
+			].join("\n") };
+		} catch (err) {
+			diagnosticLog.warn("Reflection inheritance injection failed", { error: err }, {
+				event_name: "memory.reflection_injection_hooks.reflection.inheritance.injection.failed",
+				file: "packages/memory/src/engine/reflection/reflection-injection-hooks.ts",
+				function: "registerInheritedRulesHook",
+				site_id: "reflection.reflection-injection-hooks.registerInheritedRulesHook.43c14eb8b9"
+			});
+		}
+	};
+}
+function createReflectionInjectionHandler2(params) {
+	return async (_event, ctx) => {
+		const sessionKey = typeof ctx.sessionKey === "string" ? ctx.sessionKey : "";
+		if (sessionKey.includes(":subagent:")) return;
+		if (isInternalReflectionSessionKey(sessionKey)) return;
+		const agentId = typeof ctx.agentId === "string" && ctx.agentId.trim() ? ctx.agentId.trim() : "main";
+		params.doPrune();
+		const blocks = [];
+		try {
+			const now = Date.now();
+			const suppressionKey = sessionKey ? params.derivedKey(sessionKey) : "";
+			const suppression = suppressionKey ? getReflectionDerivedSuppression(params.derivedSuppressionCache, suppressionKey, now) : void 0;
+			if (suppression) diagnosticLog.debug("Reflection derived injection suppressed", {
+				reason_code: suppression.reason,
+				session_reference: privateLogReference(sessionKey)
+			}, {
+				event_name: "memory.reflection_injection_hooks.reflection.derived.injection.suppressed",
+				file: "packages/memory/src/engine/reflection/reflection-injection-hooks.ts",
+				function: "registerDerivedFocusHook",
+				site_id: "reflection.reflection-injection-hooks.registerDerivedFocusHook.d23bb07c04"
+			});
+			else {
+				if (suppressionKey) deleteReflectionDerivedSuppression(params.derivedSuppressionCache, suppressionKey);
+				const scopes = params.scopePolicy.getAccessibleScopes(agentId);
+				const cachedDerived = sessionKey ? getReflectionDerivedCacheEntry(params.derivedCache, params.derivedKey(sessionKey)) : void 0;
+				const loadedSlices = cachedDerived?.derived?.length ? void 0 : await params.sliceLoader.loadAgentReflectionSlices(agentId, scopes);
+				const derivedLines = cachedDerived?.derived?.length ? cachedDerived.derived : loadedSlices?.derived ?? [];
+				if (derivedLines.length > 0) {
+					const renderedLines = derivedLines.slice(0, 6);
+					blocks.push([
+						"<derived-focus>",
+						"Latest derived execution deltas from reflection memory:",
+						...renderedLines.map((line, i) => `${i + 1}. ${line}`),
+						"</derived-focus>"
+					].join("\n"));
+					recordReflectionInjectUsage(params, {
+						agentId,
+						sessionKey,
+						turnId: readTurnId(ctx),
+						surface: "reflection_derived_focus",
+						renderedLines,
+						sources: cachedDerived?.derivedSources ?? loadedSlices?.derivedSources ?? []
+					});
+				}
+			}
+		} catch (err) {
+			diagnosticLog.warn("Reflection derived injection failed", { error: err }, {
+				event_name: "memory.reflection_injection_hooks.reflection.derived.injection.failed",
+				file: "packages/memory/src/engine/reflection/reflection-injection-hooks.ts",
+				function: "registerDerivedFocusHook",
+				site_id: "reflection.reflection-injection-hooks.registerDerivedFocusHook.bbe1a0ae1e"
+			});
+		}
+		appendPendingErrorBlock(params, sessionKey, blocks);
+		if (blocks.length === 0) return;
+		return { prependContext: blocks.join("\n\n") };
+	};
+}
+function createReflectionInjectionHandler3(params) {
+	return async (_event, ctx) => {
+		const sessionKey = typeof ctx.sessionKey === "string" ? ctx.sessionKey : "";
+		if (sessionKey.includes(":subagent:")) return;
+		if (isInternalReflectionSessionKey(sessionKey)) return;
+		const agentId = typeof ctx.agentId === "string" && ctx.agentId.trim() ? ctx.agentId.trim() : "main";
+		try {
+			params.doPrune();
+			const scopes = params.scopePolicy.getAccessibleScopes(agentId);
+			const slices = await params.sliceLoader.loadAgentReflectionSlices(agentId, scopes);
+			const blocks = [];
+			if (slices.invariants.length > 0) {
+				blocks.push([
+					"<reflection-invariants>",
+					...slices.invariants.map((line) => `- ${line}`),
+					"</reflection-invariants>"
+				].join("\n"));
+				recordReflectionInjectUsage(params, {
+					agentId,
+					sessionKey,
+					turnId: readTurnId(ctx),
+					surface: "reflection_v3_slice",
+					renderedLines: slices.invariants,
+					sources: slices.invariantSources
+				});
+			}
+			const now = Date.now();
+			const suppressionKey = sessionKey ? params.derivedKey(sessionKey) : "";
+			const suppression = suppressionKey ? getReflectionDerivedSuppression(params.derivedSuppressionCache, suppressionKey, now) : void 0;
+			if (suppression) diagnosticLog.debug("Reflection derived injection suppressed", {
+				reason_code: suppression.reason,
+				session_reference: privateLogReference(sessionKey)
+			}, {
+				event_name: "memory.reflection_injection_hooks.reflection.derived.injection.suppressed",
+				file: "packages/memory/src/engine/reflection/reflection-injection-hooks.ts",
+				function: "registerV3SliceHook",
+				site_id: "reflection.reflection-injection-hooks.registerV3SliceHook.d23bb07c04"
+			});
+			else {
+				if (suppressionKey) deleteReflectionDerivedSuppression(params.derivedSuppressionCache, suppressionKey);
+				if (slices.derived.length > 0) {
+					blocks.push([
+						"<reflection-derived>",
+						...slices.derived.map((line) => `- ${line}`),
+						"</reflection-derived>"
+					].join("\n"));
+					recordReflectionInjectUsage(params, {
+						agentId,
+						sessionKey,
+						turnId: readTurnId(ctx),
+						surface: "reflection_v3_slice",
+						renderedLines: slices.derived,
+						sources: slices.derivedSources
+					});
+				}
+			}
+			if (blocks.length === 0) return;
+			return { prependContext: blocks.join("\n\n") };
+		} catch (err) {
+			diagnosticLog.warn("Reflection slice injection failed", { error: err }, {
+				event_name: "memory.reflection_injection_hooks.reflection.slice.injection.failed",
+				file: "packages/memory/src/engine/reflection/reflection-injection-hooks.ts",
+				function: "registerV3SliceHook",
+				site_id: "reflection.reflection-injection-hooks.registerV3SliceHook.1800747d30"
+			});
+		}
+	};
+}
+//#endregion
+export { createReflectionInjectionHandler1, createReflectionInjectionHandler2, createReflectionInjectionHandler3 };

package/dist/internal/engine/reflection/reflection-lifecycle-hooks.d.ts

@@ -0,0 +1,2 @@
+import { n as createReflectionLifecycleHandler1, r as createReflectionLifecycleHandler2, t as ReflectionLifecycleParams } from "../../../reflection-lifecycle-hooks-Ct5HBdSG.js";
+export { ReflectionLifecycleParams, createReflectionLifecycleHandler1, createReflectionLifecycleHandler2 };

package/dist/internal/engine/reflection/reflection-lifecycle-hooks.js

@@ -0,0 +1,63 @@
+import { DEFAULT_REFLECTION_ERROR_SCAN_MAX_CHARS } from "../../config/index.js";
+import { a as sha256Hex, i as normalizeErrorSignature, o as summarizeErrorText, r as extractTextFromToolResult, t as containsErrorSignal } from "../../../error-signals-lMH2uAdV.js";
+import { r as isInternalReflectionSessionKey, s as deleteReflectionDerivedSuppression } from "../../../reflection-embedded-generator-CDUhgV96.js";
+//#region src/engine/reflection/reflection-lifecycle-hooks.ts
+/** @file reflection-lifecycle-hooks.ts
+* @purpose Tracks reflection error signals and clears per-session state.
+*/
+function createReflectionLifecycleHandler1(params) {
+	return (event, ctx) => {
+		const sessionKey = typeof ctx.sessionKey === "string" ? ctx.sessionKey : "";
+		if (isInternalReflectionSessionKey(sessionKey)) return;
+		if (!sessionKey) return;
+		params.doPrune();
+		if (event.toolName === "exec") {
+			const captured = (extractTextFromToolResult(event.result) || (typeof event.error === "string" ? event.error : "")).match(/(?:\bexit(?:\s+code)?|Command\s+exited)\s*[;:\s](\d+)\b/i)?.[1];
+			if (captured !== void 0 && Number.parseInt(captured, 10) === 0) return;
+		}
+		if (typeof event.error === "string" && event.error.trim().length > 0) {
+			const signature = normalizeErrorSignature(event.error);
+			params.errorTracker.addSignal(sessionKey, {
+				at: Date.now(),
+				toolName: event.toolName || "unknown",
+				summary: summarizeErrorText(event.error),
+				source: "tool_error",
+				signature,
+				signatureHash: sha256Hex(signature).slice(0, 16)
+			}, params.reflectionCfg.dedupeErrorSignals);
+			return;
+		}
+		const resultTextRaw = extractTextFromToolResult(event.result);
+		const resultText = resultTextRaw.length > 8e3 ? resultTextRaw.slice(0, DEFAULT_REFLECTION_ERROR_SCAN_MAX_CHARS) : resultTextRaw;
+		if (!resultText || !containsErrorSignal(resultText)) return;
+		const signature = normalizeErrorSignature(resultText);
+		params.errorTracker.addSignal(sessionKey, {
+			at: Date.now(),
+			toolName: event.toolName || "unknown",
+			summary: summarizeErrorText(resultText),
+			source: "tool_output",
+			signature,
+			signatureHash: sha256Hex(signature).slice(0, 16)
+		}, params.reflectionCfg.dedupeErrorSignals);
+	};
+}
+function createReflectionLifecycleHandler2(params) {
+	return (_event, ctx) => {
+		const ctxRecord = ctx;
+		const sessionKey = typeof ctxRecord.sessionKey === "string" ? ctxRecord.sessionKey.trim() : "";
+		const sessionId = typeof ctx.sessionId === "string" ? ctx.sessionId.trim() : "";
+		if (sessionKey) {
+			params.errorTracker.clearSession(sessionKey);
+			params.derivedCache.delete(params.derivedKey(sessionKey));
+			deleteReflectionDerivedSuppression(params.derivedSuppressionCache, params.derivedKey(sessionKey));
+		}
+		if (sessionId && sessionId !== sessionKey) {
+			params.errorTracker.clearSession(sessionId);
+			params.derivedCache.delete(params.derivedKey(sessionId));
+			deleteReflectionDerivedSuppression(params.derivedSuppressionCache, params.derivedKey(sessionId));
+		}
+		params.doPrune();
+	};
+}
+//#endregion
+export { createReflectionLifecycleHandler1, createReflectionLifecycleHandler2 };

package/dist/internal/engine/reflection/strategy-hook-runner.d.ts

@@ -0,0 +1,4 @@
+import { r as isInternalReflectionSessionKey } from "../../../reflection-embedded-generator-CxOex5xK.js";
+import { t as ReflectionDeps } from "../../../reflection-deps-RpLPFrSc.js";
+import { n as createReflectionStrategyState, t as ReflectionStrategyState } from "../../../strategy-hook-runner-gBtU47tX.js";
+export { type ReflectionDeps, ReflectionStrategyState, createReflectionStrategyState, isInternalReflectionSessionKey };

package/dist/internal/engine/reflection/strategy-hook-runner.js

@@ -0,0 +1,3 @@
+import { r as isInternalReflectionSessionKey } from "../../../reflection-embedded-generator-CDUhgV96.js";
+import { t as createReflectionStrategyState } from "../../../strategy-hook-runner-zmdIYOmQ.js";
+export { createReflectionStrategyState, isInternalReflectionSessionKey };

package/dist/internal/engine/rem/classifier.d.ts

@@ -0,0 +1,2 @@
+import { a as REM_PURE_NEGATION_PATTERN_SHA256, c as RemClassifierClaims, d as RemClassifierReport, f as classifyRemRow, i as REM_HISTORICAL_FACT_PATTERN_SHA256, l as RemClassifierCounts, m as runVerdictClassifierEntry, n as REM_AMBIGUOUS_PATTERN_SHA256, o as REM_TRANSITION_GRAMMAR_SHA256, p as runRestateClassifierEntry, r as REM_CURRENT_PROGRESSIVE_PATTERN_SHA256, s as RemClassifiedRow, t as REM_ADDITIONAL_TRANSITION_PATTERN_SHA256, u as RemClassifierPersistence } from "../../../classifier-C96uH9OF.js";
+export { REM_ADDITIONAL_TRANSITION_PATTERN_SHA256, REM_AMBIGUOUS_PATTERN_SHA256, REM_CURRENT_PROGRESSIVE_PATTERN_SHA256, REM_HISTORICAL_FACT_PATTERN_SHA256, REM_PURE_NEGATION_PATTERN_SHA256, REM_TRANSITION_GRAMMAR_SHA256, RemClassifiedRow, RemClassifierClaims, RemClassifierCounts, RemClassifierPersistence, RemClassifierReport, classifyRemRow, runRestateClassifierEntry, runVerdictClassifierEntry };

package/dist/internal/engine/rem/classifier.js

@@ -0,0 +1,180 @@
+import { z } from "zod";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/engine/rem/classifier.ts
+const REM_TRANSITION_GRAMMAR_SHA256 = "8fd5439ec2b85ca27bfa462600869973f991a6f44f956c734596ee9c9d44153d";
+const REM_ADDITIONAL_TRANSITION_PATTERN_SHA256 = "cb42c6a25ccd51b16da6a3de7d931f1165af284a89cdc365860bd359ae84bd9f";
+const REM_CURRENT_PROGRESSIVE_PATTERN_SHA256 = "ddc1c0119c1f9c4e5178dc0e6eec9ca8a7594ed10e2dd8305646f5363e9d24ad";
+const REM_HISTORICAL_FACT_PATTERN_SHA256 = "c5a9cdc0bc2936e6c0252e7c785accf1e3cef646921b92e736d01811c92838ff";
+const REM_PURE_NEGATION_PATTERN_SHA256 = "610118ddf1ba956d7082b7f0b7e265f1fcbf81655a9f0e3f6ce753c0df2cbc1d";
+const REM_AMBIGUOUS_PATTERN_SHA256 = "ba3ac7245cd7c6d9178989b4d8f95b000467244b028308916354a0fa653f954a";
+const REM_TRANSITION_PATTERN = "\\b(no longer|not longer|removed|remove[ds]?|deleted|dropped|used to|previously|formerly|past|already (?:done|completed|finished)|completed|finished|grew out of|grown out of|moved (?:(?:away|on) )?from|switched (?:from|away)|replaced|instead of|rather than|has been|was )\\b";
+const REM_ADDITIONAL_TRANSITION_PATTERN = "(?:\\b(?:(?:shifted|switched|moved|changed|transitioned)\\b[\\s\\S]{0,120}?\\bfrom\\b[\\s\\S]{0,120}?\\bto\\b|(?:a|the)\\s+(?:shift|switch|move|change|transition)\\s+from\\b|(?:is|are|was|were)\\s+not\\s+included\\b|exclud(?:e|es|ed|ing)\\b|(?:updated|revised)\\s+from\\b|instead\\b|wechselte\\b[\\s\\S]{0,120}?\\bvon\\b[\\s\\S]{0,120}?\\bzu\\b)|cambió[\\s\\S]{0,120}?\\sde\\s[\\s\\S]{0,120}?\\sa\\s|est\\s+passé[\\s\\S]{0,120}?\\sdu\\s[\\s\\S]{0,120}?\\sau\\s|переш[её]л[\\s\\S]{0,120}?\\sс\\s[\\s\\S]{0,120}?\\sна\\s|从[\\s\\S]{0,120}?改为|從[\\s\\S]{0,120}?改為|から[\\s\\S]{0,120}?に切り替えた|에서[\\s\\S]{0,120}?로\\s+바꾸었다)";
+const REM_CURRENT_PROGRESSIVE_PATTERN = "\\bhas\\s+been\\s+[a-z]+ing\\b";
+const REM_HISTORICAL_FACT_PATTERN = "^\\s*On\\s+\\d{4}-\\d{2}-\\d{2}\\b[\\s\\S]*\\b(?:was|were)\\b";
+const REM_PURE_NEGATION_PATTERN = "^\\s*(?![\\s\\S]*\\b(?:instead|rather\\s+than|(?:shift|switch|move|change|transition)(?:ed|es|ing)?\\s+(?:from|to|away\\s+from))\\b)(?![\\s\\S]*\\b(?:remove|delete|drop)\\b[\\s\\S]*\\b(?:from|in|on)\\b)(?:The user\\s+)?(?:(?:has\\s+)?(?:grown|grew)\\s+out\\s+of|no\\s+longer\\s+[^\\s.!?;,:]+|(?:does|do)\\s+not\\s+[^\\s.!?;,:]+|(?:gave|give)\\s+up|(?:stopped|stop)\\s+[^\\s.!?;,:]+)[\\s\\S]*$";
+const REM_AMBIGUOUS_PATTERN = "\\b(?:no\\s+longer|(?:do|does|did)\\s+not|(?:gave|give)\\s+up|(?:stopped|stop)\\s+\\S+|(?:grew|grown)\\s+out\\s+of|(?:lost|lose)\\s+interest)\\b";
+const classifierPopulationSchema = z.object({
+	grammar: z.object({
+		pattern: z.string().min(1),
+		flags: z.literal("IGNORECASE"),
+		sha256: z.string().regex(/^[0-9a-f]{64}$/)
+	}).passthrough(),
+	router: z.object({
+		version: z.literal(2),
+		flags: z.literal("IGNORECASE"),
+		additionalTransitionPattern: z.string().min(1),
+		additionalTransitionPatternSha256: z.string().regex(/^[0-9a-f]{64}$/),
+		currentProgressivePattern: z.string().min(1),
+		currentProgressivePatternSha256: z.string().regex(/^[0-9a-f]{64}$/),
+		historicalFactPattern: z.string().min(1),
+		historicalFactPatternSha256: z.string().regex(/^[0-9a-f]{64}$/),
+		pureNegationPattern: z.string().min(1),
+		pureNegationPatternSha256: z.string().regex(/^[0-9a-f]{64}$/),
+		ambiguousPattern: z.string().min(1),
+		ambiguousPatternSha256: z.string().regex(/^[0-9a-f]{64}$/)
+	}).passthrough(),
+	rows: z.array(z.object({
+		rowId: z.string().min(1),
+		text: z.string().min(1),
+		contentHash: z.string().regex(/^[0-9a-f]{64}$/).optional()
+	}).passthrough()).min(1)
+}).passthrough();
+/** Classifies one live database row with the same pinned router used by the conformance entry. */
+function classifyRemRow(row) {
+	assertProductionPatternPins();
+	return classifyRow(row, new RegExp(REM_TRANSITION_PATTERN, "i"), new RegExp(REM_ADDITIONAL_TRANSITION_PATTERN, "i"), new RegExp(REM_CURRENT_PROGRESSIVE_PATTERN, "i"), new RegExp(REM_HISTORICAL_FACT_PATTERN, "i"), new RegExp(REM_PURE_NEGATION_PATTERN, "i"), new RegExp(REM_AMBIGUOUS_PATTERN, "i"));
+}
+function runVerdictClassifierEntry(populationValue, persistence) {
+	return runClassifierEntry(populationValue, "verdict", persistence);
+}
+function runRestateClassifierEntry(populationValue, persistence) {
+	return runClassifierEntry(populationValue, "restate", persistence);
+}
+function runClassifierEntry(populationValue, actionOwner, persistence) {
+	const population = classifierPopulationSchema.parse(populationValue);
+	assertGrammarPin(population.grammar.pattern, population.grammar.sha256);
+	assertRouterPin(population.router);
+	assertUniqueRowIds(population.rows);
+	const transitionPattern = new RegExp(population.grammar.pattern, "i");
+	const additionalTransitionPattern = new RegExp(population.router.additionalTransitionPattern, "i");
+	const currentProgressivePattern = new RegExp(population.router.currentProgressivePattern, "i");
+	const historicalFactPattern = new RegExp(population.router.historicalFactPattern, "i");
+	const pureNegationPattern = new RegExp(population.router.pureNegationPattern, "i");
+	const ambiguousPattern = new RegExp(population.router.ambiguousPattern, "i");
+	const rows = population.rows.map((row) => classifyRow(row, transitionPattern, additionalTransitionPattern, currentProgressivePattern, historicalFactPattern, pureNegationPattern, ambiguousPattern));
+	const report = {
+		counts: countRows(rows),
+		rows
+	};
+	if (!persistence) return report;
+	if (population.rows.some((row) => row.contentHash === void 0)) throw new Error("persisted classifier populations require stored contentHash values");
+	for (const row of rows) persistence.repository.recordClassification({
+		rowId: row.rowId,
+		contentHash: row.contentHash,
+		state: row.state,
+		classifiedAt: persistence.classifiedAt
+	});
+	const claims = {
+		claimed: [],
+		skipped: [],
+		refused: []
+	};
+	for (const row of rows) {
+		if (row.owner !== actionOwner) {
+			claims.skipped.push(row.rowId);
+			continue;
+		}
+		const result = persistence.repository.claimRow({
+			rowId: row.rowId,
+			contentHash: row.contentHash,
+			owner: actionOwner,
+			claimToken: randomUUID(),
+			claimTs: persistence.claimTs,
+			holderPid: process.pid
+		});
+		if (result.claimed) claims.claimed.push(row.rowId);
+		else claims.refused.push({
+			rowId: row.rowId,
+			reason: result.reason
+		});
+	}
+	return {
+		...report,
+		claims
+	};
+}
+function classifyRow(row, transitionPattern, additionalTransitionPattern, currentProgressivePattern, historicalFactPattern, pureNegationPattern, ambiguousPattern) {
+	const isPureNegation = pureNegationPattern.test(row.text);
+	const historicalCopulaIsOnlyTransition = historicalFactPattern.test(row.text) && !withoutHistoricalCopulaBranch(transitionPattern).test(row.text);
+	const isTransition = additionalTransitionPattern.test(row.text) || transitionPattern.test(row.text) && !currentProgressivePattern.test(row.text) && !historicalCopulaIsOnlyTransition;
+	const ambiguous = !isPureNegation && !isTransition && ambiguousPattern.test(row.text);
+	const state = isPureNegation ? "pure-negation" : ambiguous ? "ambiguous" : isTransition ? "transition" : "stale-current";
+	return {
+		rowId: row.rowId,
+		text: row.text,
+		contentHash: row.contentHash ?? createHash("sha256").update(row.text).digest("hex"),
+		state,
+		owner: ownerForState(state),
+		ambiguous
+	};
+}
+function assertProductionPatternPins() {
+	assertPatternPin(REM_TRANSITION_PATTERN, REM_TRANSITION_GRAMMAR_SHA256, REM_TRANSITION_GRAMMAR_SHA256, "transition grammar");
+	assertPatternPin(REM_ADDITIONAL_TRANSITION_PATTERN, REM_ADDITIONAL_TRANSITION_PATTERN_SHA256, REM_ADDITIONAL_TRANSITION_PATTERN_SHA256, "additional transition pattern");
+	assertPatternPin(REM_CURRENT_PROGRESSIVE_PATTERN, REM_CURRENT_PROGRESSIVE_PATTERN_SHA256, REM_CURRENT_PROGRESSIVE_PATTERN_SHA256, "current-progressive pattern");
+	assertPatternPin(REM_HISTORICAL_FACT_PATTERN, REM_HISTORICAL_FACT_PATTERN_SHA256, REM_HISTORICAL_FACT_PATTERN_SHA256, "historical fact pattern");
+	assertPatternPin(REM_PURE_NEGATION_PATTERN, REM_PURE_NEGATION_PATTERN_SHA256, REM_PURE_NEGATION_PATTERN_SHA256, "pure-negation pattern");
+	assertPatternPin(REM_AMBIGUOUS_PATTERN, REM_AMBIGUOUS_PATTERN_SHA256, REM_AMBIGUOUS_PATTERN_SHA256, "ambiguous pattern");
+}
+function ownerForState(state) {
+	if (state === "transition" || state === "ambiguous") return "restate";
+	if (state === "stale-current") return "verdict";
+	return "none";
+}
+function countRows(rows) {
+	const counts = {
+		total: rows.length,
+		transition: 0,
+		staleCurrent: 0,
+		pureNegation: 0,
+		ambiguous: 0
+	};
+	for (const row of rows) {
+		if (row.state === "transition") counts.transition += 1;
+		else if (row.state === "stale-current") counts.staleCurrent += 1;
+		else if (row.state === "pure-negation") counts.pureNegation += 1;
+		if (row.ambiguous) counts.ambiguous += 1;
+	}
+	return counts;
+}
+function assertGrammarPin(pattern, declaredSha256) {
+	const observedSha256 = createHash("sha256").update(pattern).digest("hex");
+	if (observedSha256 !== declaredSha256) throw new Error(`transition grammar digest mismatch: declared ${declaredSha256}, observed ${observedSha256}`);
+	if (observedSha256 !== "8fd5439ec2b85ca27bfa462600869973f991a6f44f956c734596ee9c9d44153d") throw new Error(`transition grammar is not pinned: expected ${REM_TRANSITION_GRAMMAR_SHA256}, observed ${observedSha256}`);
+}
+function assertRouterPin(router) {
+	assertPatternPin(router.additionalTransitionPattern, router.additionalTransitionPatternSha256, REM_ADDITIONAL_TRANSITION_PATTERN_SHA256, "additional transition pattern");
+	assertPatternPin(router.currentProgressivePattern, router.currentProgressivePatternSha256, REM_CURRENT_PROGRESSIVE_PATTERN_SHA256, "current-progressive pattern");
+	assertPatternPin(router.historicalFactPattern, router.historicalFactPatternSha256, REM_HISTORICAL_FACT_PATTERN_SHA256, "historical fact pattern");
+	assertPatternPin(router.pureNegationPattern, router.pureNegationPatternSha256, REM_PURE_NEGATION_PATTERN_SHA256, "pure-negation pattern");
+	assertPatternPin(router.ambiguousPattern, router.ambiguousPatternSha256, REM_AMBIGUOUS_PATTERN_SHA256, "ambiguous pattern");
+}
+function withoutHistoricalCopulaBranch(pattern) {
+	const source = pattern.source.replace("|was ", "");
+	if (source === pattern.source) throw new Error("transition grammar is missing the historical copula branch");
+	return new RegExp(source, pattern.flags);
+}
+function assertPatternPin(pattern, declaredSha256, expectedSha256, name) {
+	const observedSha256 = createHash("sha256").update(pattern).digest("hex");
+	if (observedSha256 !== declaredSha256) throw new Error(`${name} digest mismatch: declared ${declaredSha256}, observed ${observedSha256}`);
+	if (observedSha256 !== expectedSha256) throw new Error(`${name} is not pinned: expected ${expectedSha256}, observed ${observedSha256}`);
+}
+function assertUniqueRowIds(rows) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const row of rows) {
+		if (seen.has(row.rowId)) throw new Error(`duplicate classifier row id: ${row.rowId}`);
+		seen.add(row.rowId);
+	}
+}
+//#endregion
+export { REM_ADDITIONAL_TRANSITION_PATTERN_SHA256, REM_AMBIGUOUS_PATTERN_SHA256, REM_CURRENT_PROGRESSIVE_PATTERN_SHA256, REM_HISTORICAL_FACT_PATTERN_SHA256, REM_PURE_NEGATION_PATTERN_SHA256, REM_TRANSITION_GRAMMAR_SHA256, classifyRemRow, runRestateClassifierEntry, runVerdictClassifierEntry };