@frontmcp/plugin-remember 1.7.2 → 1.8.1

package/esm/index.mjs

@@ -20,887 +20,1084 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
 // plugins/plugin-remember/src/remember.plugin.ts
 import {
   DynamicPlugin,
-  Plugin,
-  ProviderScope as ProviderScope5,
+  FRONTMCP_CONTEXT,
   FrontMcpConfig,
-  FRONTMCP_CONTEXT as FRONTMCP_CONTEXT2,
+  FrontMcpLogger,
   getGlobalStoreConfig,
-  isVercelKvProvider
+  isVercelKvProvider,
+  Plugin,
+  ProviderScope as ProviderScope5
 } from "@frontmcp/sdk";
 
-// plugins/plugin-remember/src/remember.symbols.ts
-var RememberStoreToken = /* @__PURE__ */ Symbol(
-  "plugin:remember:store"
-);
-var RememberConfigToken = /* @__PURE__ */ Symbol(
-  "plugin:remember:config"
-);
-var RememberAccessorToken = /* @__PURE__ */ Symbol(
-  "plugin:remember:accessor"
-);
+// plugins/plugin-remember/src/providers/remember-accessor.provider.ts
+import {
+  Provider,
+  ProviderScope,
+  STATELESS_SESSION_ID
+} from "@frontmcp/sdk";
 
-// plugins/plugin-remember/src/providers/remember-memory.provider.ts
-import { Provider, ProviderScope } from "@frontmcp/sdk";
-var MAX_TIMEOUT_MS = 2 ** 31 - 1;
-var RememberMemoryProvider = class {
-  memory = /* @__PURE__ */ new Map();
-  sweeper;
-  constructor(sweepIntervalSeconds = 60) {
-    this.sweeper = setInterval(() => this.sweep(), sweepIntervalSeconds * 1e3);
-    this.sweeper.unref?.();
+// plugins/plugin-remember/src/remember.crypto.ts
+import {
+  base64urlDecode,
+  base64urlEncode as base64urlEncode2,
+  decryptAesGcm,
+  encryptAesGcm,
+  hkdfSha256,
+  randomBytes as randomBytes2
+} from "@frontmcp/utils";
+
+// plugins/plugin-remember/src/remember.secret-persistence.ts
+import * as path from "path";
+import { z } from "@frontmcp/lazy-zod";
+import { base64urlEncode, mkdir, randomBytes, readFile, rename, unlink, writeFile } from "@frontmcp/utils";
+var DEFAULT_SECRET_FILE_PATH = ".frontmcp/remember-secret.json";
+var SECRET_BYTES = 32;
+var rememberSecretDataSchema = z.object({
+  secret: z.string().min(32),
+  // base64url of 32 bytes is ~43 chars
+  createdAt: z.number().positive().int(),
+  version: z.literal(1)
+});
+function validateSecretData(data) {
+  const result = rememberSecretDataSchema.safeParse(data);
+  if (!result.success) {
+    return { valid: false, error: result.error.issues[0]?.message ?? "Invalid secret structure" };
   }
-  /**
-   * Store a value with optional TTL.
-   * Always JSON-serializes the value for consistent storage/retrieval.
-   */
-  async setValue(key, value, ttlSeconds) {
-    const strValue = JSON.stringify(value);
-    const existing = this.memory.get(key);
-    if (existing?.timeout) clearTimeout(existing.timeout);
-    const entry = { value: strValue };
-    if (ttlSeconds && ttlSeconds > 0) {
-      const ttlMs = ttlSeconds * 1e3;
-      entry.expiresAt = Date.now() + ttlMs;
-      if (ttlMs <= MAX_TIMEOUT_MS) {
-        entry.timeout = setTimeout(() => {
-          const e = this.memory.get(key);
-          if (e && e.expiresAt && e.expiresAt <= Date.now()) {
-            this.memory.delete(key);
-          }
-        }, ttlMs);
-        entry.timeout.unref?.();
-      }
-    }
-    this.memory.set(key, entry);
+  const parsed = result.data;
+  const now = Date.now();
+  if (parsed.createdAt > now + 6e4) {
+    return { valid: false, error: "createdAt is in the future" };
   }
-  /**
-   * Retrieve a value by key.
-   * JSON-parses the stored value to match the setValue serialization.
-   */
-  async getValue(key, defaultValue) {
-    const entry = this.memory.get(key);
-    if (!entry) return defaultValue;
-    if (this.isExpired(entry)) {
-      await this.delete(key);
-      return defaultValue;
-    }
-    try {
-      return JSON.parse(entry.value);
-    } catch {
-      return entry.value;
-    }
+  const hundredYearsMs = 100 * 365 * 24 * 60 * 60 * 1e3;
+  if (parsed.createdAt < now - hundredYearsMs) {
+    return { valid: false, error: "createdAt is too old" };
   }
-  /**
-   * Delete a key.
-   */
-  async delete(key) {
-    const entry = this.memory.get(key);
-    if (entry?.timeout) clearTimeout(entry.timeout);
-    this.memory.delete(key);
+  return { valid: true };
+}
+function isSecretPersistenceEnabled(options) {
+  const isProduction = process.env["NODE_ENV"] === "production";
+  if (isProduction) {
+    return options?.forceEnable === true;
   }
-  /**
-   * Check if a key exists (and is not expired).
-   */
-  async exists(key) {
-    const entry = this.memory.get(key);
-    if (!entry) return false;
-    if (this.isExpired(entry)) {
-      await this.delete(key);
-      return false;
-    }
-    return true;
+  return true;
+}
+function resolveSecretPath(options) {
+  const secretPath = options?.secretPath ?? DEFAULT_SECRET_FILE_PATH;
+  if (path.isAbsolute(secretPath)) {
+    return secretPath;
   }
-  /**
-   * List keys matching a glob-style pattern.
-   * Supports * and ? wildcards.
-   */
-  async keys(pattern) {
-    const result = [];
-    const regex = pattern ? this.patternToRegex(pattern) : null;
-    const expiredKeys = [];
-    for (const [key, entry] of this.memory) {
-      if (this.isExpired(entry)) {
-        expiredKeys.push(key);
-      }
-    }
-    for (const key of expiredKeys) {
-      await this.delete(key);
+  return path.resolve(process.cwd(), secretPath);
+}
+async function loadRememberSecret(options) {
+  if (!isSecretPersistenceEnabled(options)) {
+    return null;
+  }
+  const secretPath = resolveSecretPath(options);
+  try {
+    const content = await readFile(secretPath, "utf8");
+    const data = JSON.parse(content);
+    const validation = validateSecretData(data);
+    if (!validation.valid) {
+      console.warn(
+        `[RememberSecretPersistence] Invalid secret file format at ${secretPath}: ${validation.error}, will regenerate`
+      );
+      return null;
     }
-    for (const [key, entry] of this.memory) {
-      if (this.isExpired(entry)) {
-        continue;
-      }
-      if (regex && !regex.test(key)) {
-        continue;
-      }
-      result.push(key);
+    return data;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
     }
-    return result;
+    console.warn(`[RememberSecretPersistence] Failed to load secret from ${secretPath}: ${error.message}`);
+    return null;
   }
-  /**
-   * Gracefully close the provider.
-   */
-  async close() {
-    if (this.sweeper) clearInterval(this.sweeper);
-    for (const [, entry] of this.memory) {
-      if (entry.timeout) clearTimeout(entry.timeout);
+}
+async function saveRememberSecret(secretData, options) {
+  if (!isSecretPersistenceEnabled(options)) {
+    return true;
+  }
+  const secretPath = resolveSecretPath(options);
+  const dir = path.dirname(secretPath);
+  const tempPath = `${secretPath}.tmp.${Date.now()}.${base64urlEncode(randomBytes(8))}`;
+  try {
+    await mkdir(dir, { recursive: true, mode: 448 });
+    const content = JSON.stringify(secretData, null, 2);
+    await writeFile(tempPath, content, { mode: 384 });
+    await rename(tempPath, secretPath);
+    return true;
+  } catch (error) {
+    console.error(`[RememberSecretPersistence] Failed to save secret to ${secretPath}: ${error.message}`);
+    try {
+      await unlink(tempPath);
+    } catch {
     }
-    this.memory.clear();
+    return false;
   }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Private Methods
-  // ─────────────────────────────────────────────────────────────────────────────
-  isExpired(entry) {
-    return entry.expiresAt !== void 0 && entry.expiresAt <= Date.now();
+}
+var cachedSecret = null;
+var secretGenerationPromise = null;
+function generateSecret() {
+  return base64urlEncode(randomBytes(SECRET_BYTES));
+}
+async function getOrCreatePersistedSecret(options) {
+  if (cachedSecret) {
+    return cachedSecret;
   }
-  /**
-   * Periodically remove expired keys to keep memory tidy.
-   */
-  sweep() {
-    const now = Date.now();
-    for (const [key, entry] of this.memory) {
-      if (entry.expiresAt !== void 0 && entry.expiresAt <= now) {
-        if (entry.timeout) clearTimeout(entry.timeout);
-        this.memory.delete(key);
+  if (secretGenerationPromise) {
+    return secretGenerationPromise;
+  }
+  secretGenerationPromise = (async () => {
+    try {
+      const loaded = await loadRememberSecret(options);
+      if (loaded) {
+        cachedSecret = loaded.secret;
+        return cachedSecret;
+      }
+      const newSecret = generateSecret();
+      const secretData = {
+        secret: newSecret,
+        createdAt: Date.now(),
+        version: 1
+      };
+      if (isSecretPersistenceEnabled(options)) {
+        await saveRememberSecret(secretData, options);
+      } else {
+        console.warn(
+          "[RememberSecretPersistence] No REMEMBER_SECRET (or MCP_MEMORY_SECRET / MCP_SESSION_SECRET) is set in production, so a random in-memory secret is used. Encrypted memory will be unreadable after a restart and by other instances sharing the store. Set REMEMBER_SECRET to the same value on every instance."
+        );
       }
+      cachedSecret = newSecret;
+      return cachedSecret;
+    } finally {
+      secretGenerationPromise = null;
     }
+  })();
+  return secretGenerationPromise;
+}
+
+// plugins/plugin-remember/src/remember.crypto.ts
+async function getBaseSecret() {
+  const envSecret = process.env["REMEMBER_SECRET"] || process.env["MCP_MEMORY_SECRET"] || process.env["MCP_SESSION_SECRET"];
+  if (envSecret) {
+    return envSecret;
   }
-  /**
-   * Convert a glob-style pattern to a RegExp.
-   * * matches any sequence of characters
-   * ? matches any single character
-   *
-   * Includes ReDoS protection: validates pattern length and wildcard count.
-   */
-  patternToRegex(pattern) {
-    if (pattern.length > RememberMemoryProvider.MAX_PATTERN_LENGTH) {
-      throw new Error(`Pattern too long: ${pattern.length} chars (max ${RememberMemoryProvider.MAX_PATTERN_LENGTH})`);
-    }
-    const wildcardCount = (pattern.match(/[*?]/g) || []).length;
-    if (wildcardCount > RememberMemoryProvider.MAX_WILDCARDS) {
-      throw new Error(`Too many wildcards in pattern: ${wildcardCount} (max ${RememberMemoryProvider.MAX_WILDCARDS})`);
+  return getOrCreatePersistedSecret();
+}
+var textEncoder = new TextEncoder();
+async function deriveEncryptionKey(source) {
+  const salt = textEncoder.encode("remember-plugin-v1");
+  let ikm;
+  let context;
+  switch (source.type) {
+    case "session":
+      ikm = await getBaseSecret() + source.sessionId;
+      context = `remember:session:${source.sessionId}`;
+      break;
+    case "tool":
+      ikm = await getBaseSecret() + source.sessionId;
+      context = `remember:tool:${source.toolName}:${source.sessionId}`;
+      break;
+    case "user":
+      ikm = await getBaseSecret() + source.userId;
+      context = `remember:user:${source.userId}`;
+      break;
+    case "global":
+      ikm = await getBaseSecret();
+      context = "remember:global";
+      break;
+    case "custom":
+      ikm = source.key;
+      context = `remember:custom:${source.key}`;
+      break;
+  }
+  const ikmBytes = textEncoder.encode(ikm);
+  const info = textEncoder.encode(context);
+  return hkdfSha256(ikmBytes, salt, info, 32);
+}
+function getKeySourceForScope(scope, context) {
+  switch (scope) {
+    case "session":
+      return { type: "session", sessionId: context.sessionId };
+    case "user":
+      return { type: "user", userId: context.userId ?? "anonymous" };
+    case "tool":
+      return {
+        type: "tool",
+        toolName: context.toolName ?? "unknown",
+        sessionId: context.sessionId
+      };
+    case "global":
+      return { type: "global" };
+  }
+}
+var textDecoder = new TextDecoder();
+async function encryptValue(data, keySource) {
+  const key = await deriveEncryptionKey(keySource);
+  const plaintext = textEncoder.encode(JSON.stringify(data));
+  const iv = randomBytes2(12);
+  const { ciphertext, tag } = encryptAesGcm(key, plaintext, iv);
+  return {
+    alg: "A256GCM",
+    iv: base64urlEncode2(iv),
+    tag: base64urlEncode2(tag),
+    data: base64urlEncode2(ciphertext)
+  };
+}
+async function decryptValue(blob, keySource) {
+  try {
+    const key = await deriveEncryptionKey(keySource);
+    const iv = base64urlDecode(blob.iv);
+    const tag = base64urlDecode(blob.tag);
+    const ciphertext = base64urlDecode(blob.data);
+    const decrypted = decryptAesGcm(key, ciphertext, iv, tag);
+    return JSON.parse(textDecoder.decode(decrypted));
+  } catch {
+    return null;
+  }
+}
+function serializeBlob(blob) {
+  return JSON.stringify(blob);
+}
+function deserializeBlob(str) {
+  try {
+    const parsed = JSON.parse(str);
+    if (parsed && typeof parsed === "object" && parsed.alg === "A256GCM" && typeof parsed.iv === "string" && typeof parsed.tag === "string" && typeof parsed.data === "string") {
+      return parsed;
     }
-    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-    return new RegExp(`^${escaped}$`);
+    return null;
+  } catch {
+    return null;
+  }
+}
+async function encryptAndSerialize(data, keySource) {
+  const blob = await encryptValue(data, keySource);
+  return serializeBlob(blob);
+}
+async function deserializeAndDecrypt(str, keySource) {
+  const blob = deserializeBlob(str);
+  if (!blob) return null;
+  return decryptValue(blob, keySource);
+}
+
+// plugins/plugin-remember/src/remember.errors.ts
+var RememberIdentityError = class extends Error {
+  name = "RememberIdentityError";
+  constructor(message) {
+    super(message);
   }
 };
-// ReDoS protection constants
-// Pattern length allows for long prefixes (e.g., remember:session:{uuid}:user:*)
-__publicField(RememberMemoryProvider, "MAX_PATTERN_LENGTH", 500);
-__publicField(RememberMemoryProvider, "MAX_WILDCARDS", 20);
-RememberMemoryProvider = __decorateClass([
-  Provider({
-    name: "provider:remember:memory",
-    description: "In-memory storage provider for RememberPlugin",
-    scope: ProviderScope.GLOBAL
-  })
-], RememberMemoryProvider);
 
-// plugins/plugin-remember/src/providers/remember-redis.provider.ts
-import Redis from "ioredis";
-import { Provider as Provider2, ProviderScope as ProviderScope2 } from "@frontmcp/sdk";
-var RememberRedisProvider = class {
-  client;
-  /**
-   * Prefix prepended to all Redis keys.
-   * Include any separator (e.g., "myapp:" or "user:123:") as part of the prefix.
-   */
-  keyPrefix;
-  /** True if this provider created the client (and should close it), false if externally provided */
-  ownsClient;
-  constructor(options) {
-    this.keyPrefix = options.keyPrefix ?? "";
-    if (options.type === "redis-client") {
-      this.client = options.client;
-      this.ownsClient = false;
-      return;
-    }
-    this.ownsClient = true;
-    this.client = new Redis({
-      lazyConnect: false,
-      maxRetriesPerRequest: 3,
-      ...options.config
-    });
-    this.client.on("connect", () => {
-      if (process.env["DEBUG"] === "true") {
-        console.log("[RememberPlugin:Redis] Connected");
-      }
-    });
-    this.client.on("error", (err) => {
-      console.error("[RememberPlugin:Redis] Error:", err.message);
-    });
+// plugins/plugin-remember/src/remember.legacy-purge.ts
+var LEGACY_SCOPES = ["session", "tool", "user"];
+var DEFAULT_LEGACY_PURGE_DELAY_MS = 864e5;
+var LAYOUT_MARKER_KEY = "__layout__";
+var LAYOUT_VERSION = 2;
+var MAX_TIMER_MS = 2147483647;
+var scheduled = /* @__PURE__ */ new WeakSet();
+function parseFirstSeenAt(raw) {
+  if (!raw) return void 0;
+  try {
+    const parsed = typeof raw === "string" ? JSON.parse(raw) : raw;
+    const firstSeenAt = parsed?.firstSeenAt;
+    return typeof firstSeenAt === "number" && Number.isFinite(firstSeenAt) ? firstSeenAt : void 0;
+  } catch {
+    return void 0;
   }
-  /**
-   * Store a value with optional TTL.
-   *
-   * @param key - The key to store under
-   * @param value - The value to store (must not be undefined)
-   * @param ttlSeconds - Optional TTL in seconds (must be positive integer if provided)
-   * @throws Error if value is undefined or ttlSeconds is invalid
-   */
-  async setValue(key, value, ttlSeconds) {
-    if (value === void 0) {
-      throw new Error("Cannot store undefined value. Use null or delete the key instead.");
+}
+async function readLayoutFirstSeenAt(store, keyPrefix, logger) {
+  const key = `${keyPrefix}${LAYOUT_MARKER_KEY}`;
+  const standDown = (reason, extra = {}) => {
+    logger?.debug?.(`remember: ${reason}, legacy purge stood down`, { key, ...extra });
+    return void 0;
+  };
+  try {
+    const existing = await store.getValue(key);
+    if (existing) {
+      return parseFirstSeenAt(existing) ?? standDown("layout marker is unreadable");
     }
-    if (ttlSeconds !== void 0) {
-      if (typeof ttlSeconds !== "number" || !Number.isFinite(ttlSeconds)) {
-        throw new Error(`Invalid TTL: expected a number, got ${typeof ttlSeconds}`);
-      }
-      if (ttlSeconds <= 0) {
-        throw new Error(`Invalid TTL: must be positive, got ${ttlSeconds}`);
-      }
-      if (!Number.isInteger(ttlSeconds)) {
-        throw new Error(`Invalid TTL: must be an integer, got ${ttlSeconds}`);
-      }
+    const marker = { version: LAYOUT_VERSION, firstSeenAt: Date.now() };
+    const serialized = JSON.stringify(marker);
+    if (!store.setIfAbsent) {
+      await store.setValue(key, serialized);
+      return marker.firstSeenAt;
     }
-    const fullKey = this.keyPrefix + key;
-    const strValue = typeof value === "string" ? value : JSON.stringify(value);
-    if (ttlSeconds !== void 0 && ttlSeconds > 0) {
-      await this.client.set(fullKey, strValue, "EX", ttlSeconds);
-    } else {
-      await this.client.set(fullKey, strValue);
+    if (await store.setIfAbsent(key, serialized)) {
+      return marker.firstSeenAt;
     }
+    const winner = await store.getValue(key);
+    return parseFirstSeenAt(winner) ?? standDown("layout marker vanished after a lost race");
+  } catch (error) {
+    return standDown("could not establish the layout marker", {
+      error: error instanceof Error ? error.message : String(error)
+    });
   }
-  /**
-   * Retrieve a value by key.
-   *
-   * Returns the parsed JSON value if successful, or `defaultValue` if:
-   * - The key does not exist
-   * - The stored value is not valid JSON (malformed or legacy data)
-   *
-   * @param key - The key to retrieve
-   * @param defaultValue - Value to return if key doesn't exist or parsing fails
-   * @returns The parsed value as T, or defaultValue/undefined
-   */
-  async getValue(key, defaultValue) {
-    const fullKey = this.keyPrefix + key;
-    const raw = await this.client.get(fullKey);
-    if (raw === null) return defaultValue;
+}
+async function purgeLegacyRememberEntries(store, keyPrefix, logger) {
+  let deleted = 0;
+  for (const scope of LEGACY_SCOPES) {
+    const pattern = `${keyPrefix}${scope}:*`;
+    let keys;
     try {
-      return JSON.parse(raw);
-    } catch {
-      return defaultValue;
+      keys = await store.keys(pattern);
+    } catch (error) {
+      logger?.debug?.("remember: legacy purge skipped, store could not list keys", {
+        pattern,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      continue;
     }
-  }
-  /**
-   * Delete a key.
-   */
-  async delete(key) {
-    const fullKey = this.keyPrefix + key;
-    await this.client.del(fullKey);
-  }
-  /**
-   * Check if a key exists.
-   */
-  async exists(key) {
-    const fullKey = this.keyPrefix + key;
-    return await this.client.exists(fullKey) === 1;
-  }
-  /**
-   * List keys matching a pattern.
-   * Uses Redis SCAN for efficient iteration.
-   */
-  async keys(pattern) {
-    const searchPattern = this.keyPrefix + (pattern ?? "*");
-    const result = [];
-    let cursor = "0";
-    do {
-      const [nextCursor, keys] = await this.client.scan(cursor, "MATCH", searchPattern, "COUNT", 100);
-      cursor = nextCursor;
-      for (const key of keys) {
-        result.push(key.slice(this.keyPrefix.length));
+    for (const key of keys) {
+      try {
+        await store.delete(key);
+        deleted += 1;
+      } catch {
       }
-    } while (cursor !== "0");
-    return result;
-  }
-  /**
-   * Gracefully close the Redis connection.
-   * Only closes if this provider owns the client (created it internally).
-   * Externally-provided clients are left open for the caller to manage.
-   */
-  async close() {
-    if (this.ownsClient) {
-      await this.client.quit();
     }
   }
-};
-RememberRedisProvider = __decorateClass([
-  Provider2({
-    name: "provider:remember:redis",
-    description: "Redis-based storage provider for RememberPlugin",
-    scope: ProviderScope2.GLOBAL
-  })
-], RememberRedisProvider);
+  if (deleted > 0) {
+    logger?.warn?.(
+      `remember: purged ${deleted} entr${deleted === 1 ? "y" : "ies"} left unreadable by the session/tool key-derivation change and the namespace encoding. This is a one-time upgrade step; set skipLegacyPurge to handle the migration yourself.`
+    );
+  }
+  return deleted;
+}
+function scheduleLegacyRememberPurge(store, keyPrefix, options = {}) {
+  if (scheduled.has(store)) return;
+  scheduled.add(store);
+  const delayMs = options.delayMs ?? DEFAULT_LEGACY_PURGE_DELAY_MS;
+  const arm = (waitMs) => {
+    const timer = setTimeout(
+      () => {
+        void attempt().catch(() => void 0);
+      },
+      Math.min(waitMs, MAX_TIMER_MS)
+    );
+    timer.unref?.();
+  };
+  const attempt = async () => {
+    const firstSeenAt = await readLayoutFirstSeenAt(store, keyPrefix, options.logger);
+    if (firstSeenAt === void 0) return;
+    const remainingMs = firstSeenAt + delayMs - Date.now();
+    if (remainingMs > 0) {
+      arm(remainingMs);
+      return;
+    }
+    await purgeLegacyRememberEntries(store, keyPrefix, options.logger);
+  };
+  void attempt().catch(() => void 0);
+}
 
-// plugins/plugin-remember/src/providers/remember-vercel-kv.provider.ts
-import { Provider as Provider3, ProviderScope as ProviderScope3 } from "@frontmcp/sdk";
-var RememberVercelKvProvider = class {
-  kv;
+// plugins/plugin-remember/src/providers/remember-accessor.provider.ts
+var STORAGE_LAYOUT_VERSION = "v2";
+function encodeKeyPart(value) {
+  return encodeURIComponent(value);
+}
+var RememberAccessor = class {
+  store;
+  ctx;
+  config;
   keyPrefix;
-  defaultTTL;
-  constructor(options = {}) {
-    const vercelKv = __require("@vercel/kv");
-    const hasUrl = options.url !== void 0;
-    const hasToken = options.token !== void 0;
-    if (hasUrl !== hasToken) {
-      throw new Error(
-        `RememberVercelKvProvider: Both 'url' and 'token' must be provided together, or neither. Received: url=${hasUrl ? "provided" : "missing"}, token=${hasToken ? "provided" : "missing"}`
-      );
-    }
-    if (options.url && options.token) {
-      this.kv = vercelKv.createClient({
-        url: options.url,
-        token: options.token
-      });
-    } else {
-      this.kv = vercelKv.kv;
+  encryptionEnabled;
+  constructor(store, ctx, config, logger) {
+    this.store = store;
+    this.ctx = ctx;
+    this.config = config;
+    this.keyPrefix = config.keyPrefix ?? "remember:";
+    this.encryptionEnabled = config.encryption?.enabled !== false;
+    if (!config.skipLegacyPurge) {
+      scheduleLegacyRememberPurge(store, this.keyPrefix, { delayMs: config.legacyPurgeDelayMs, logger });
     }
-    this.keyPrefix = options.keyPrefix ?? "remember:";
-    this.defaultTTL = options.defaultTTL;
   }
-  prefixKey(key) {
-    return `${this.keyPrefix}${key}`;
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Public API
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Store a value in memory.
+   *
+   * @param key - The key to store under
+   * @param value - The value to store (any JSON-serializable data)
+   * @param options - Storage options (scope, ttl, brand, metadata)
+   */
+  async set(key, value, options = {}) {
+    const scope = options.scope ?? "session";
+    const storageKey = this.buildStorageKey(key, scope);
+    const entry = {
+      value,
+      brand: options.brand,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      expiresAt: options.ttl ? Date.now() + options.ttl * 1e3 : void 0,
+      metadata: options.metadata
+    };
+    const serialized = this.encryptionEnabled ? await encryptAndSerialize(entry, this.getKeySource(scope)) : JSON.stringify(entry);
+    await this.store.setValue(storageKey, serialized, options.ttl);
   }
   /**
-   * Store a value with optional TTL.
+   * Retrieve a value from memory.
+   *
+   * @param key - The key to retrieve
+   * @param options - Retrieval options (scope, defaultValue)
+   * @returns The stored value or defaultValue if not found
    */
-  async setValue(key, value, ttlSeconds) {
-    const fullKey = this.prefixKey(key);
-    const strValue = typeof value === "string" ? value : JSON.stringify(value);
-    const ttl = ttlSeconds ?? this.defaultTTL;
-    if (ttl && ttl > 0) {
-      await this.kv.set(fullKey, strValue, { ex: ttl });
-    } else {
-      await this.kv.set(fullKey, strValue);
+  async get(key, options = {}) {
+    const scope = options.scope ?? "session";
+    const storageKey = this.buildStorageKey(key, scope);
+    const raw = await this.store.getValue(storageKey);
+    if (!raw) return options.defaultValue;
+    const entry = this.encryptionEnabled ? await deserializeAndDecrypt(raw, this.getKeySource(scope)) : this.parseEntry(raw);
+    if (!entry) return options.defaultValue;
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      await this.forget(key, { scope });
+      return options.defaultValue;
     }
+    return entry.value;
   }
   /**
-   * Retrieve a value by key.
+   * Get the full entry including metadata.
+   *
+   * @param key - The key to retrieve
+   * @param options - Retrieval options (scope)
+   * @returns The full entry or undefined if not found
    */
-  async getValue(key, defaultValue) {
-    const fullKey = this.prefixKey(key);
-    const raw = await this.kv.get(fullKey);
-    if (raw === null || raw === void 0) return defaultValue;
-    if (typeof raw === "string") {
-      try {
-        return JSON.parse(raw);
-      } catch {
-        return raw;
-      }
+  async getEntry(key, options = {}) {
+    const scope = options.scope ?? "session";
+    const storageKey = this.buildStorageKey(key, scope);
+    const raw = await this.store.getValue(storageKey);
+    if (!raw) return void 0;
+    const entry = this.encryptionEnabled ? await deserializeAndDecrypt(raw, this.getKeySource(scope)) : this.parseEntry(raw);
+    if (!entry) return void 0;
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      await this.forget(key, { scope });
+      return void 0;
     }
-    return raw;
+    return entry;
   }
   /**
-   * Delete a key.
+   * Forget (delete) a value from memory.
+   *
+   * @param key - The key to forget
+   * @param options - Options (scope)
    */
-  async delete(key) {
-    const fullKey = this.prefixKey(key);
-    await this.kv.del(fullKey);
+  async forget(key, options = {}) {
+    const scope = options.scope ?? "session";
+    const storageKey = this.buildStorageKey(key, scope);
+    await this.store.delete(storageKey);
   }
   /**
-   * Check if a key exists.
+   * Check if a key is remembered (exists and not expired).
+   *
+   * @param key - The key to check
+   * @param options - Options (scope)
+   * @returns true if the key exists
    */
-  async exists(key) {
-    const fullKey = this.prefixKey(key);
-    return await this.kv.exists(fullKey) === 1;
+  async knows(key, options = {}) {
+    const scope = options.scope ?? "session";
+    const storageKey = this.buildStorageKey(key, scope);
+    return this.store.exists(storageKey);
   }
   /**
-   * List keys matching a pattern.
-   * Uses SCAN for efficient iteration.
+   * List all remembered keys for a scope.
+   *
+   * @param options - Options (scope, pattern)
+   * @returns Array of keys (without the scope prefix)
    */
-  async keys(pattern) {
-    const searchPattern = this.prefixKey(pattern ?? "*");
-    const result = [];
-    try {
-      let cursor = 0;
-      do {
-        const [nextCursor, keys] = await this.kv.scan(cursor, {
-          match: searchPattern,
-          count: 100
-        });
-        cursor = nextCursor;
-        for (const key of keys) {
-          result.push(key.slice(this.keyPrefix.length));
-        }
-      } while (cursor !== 0);
-    } catch {
-      try {
-        const keys = await this.kv.keys(searchPattern);
-        for (const key of keys) {
-          result.push(key.slice(this.keyPrefix.length));
-        }
-      } catch {
-        console.warn("[RememberPlugin:VercelKV] keys() operation not supported");
-      }
-    }
-    return result;
+  async list(options = {}) {
+    const scope = options.scope ?? "session";
+    const scopePrefix = this.buildScopePrefix(scope);
+    const fullPattern = scopePrefix + (options.pattern ?? "*");
+    const keys = await this.store.keys(fullPattern);
+    return keys.map((k) => k.slice(scopePrefix.length));
   }
   /**
-   * Gracefully close the provider.
-   * No-op for Vercel KV as it uses stateless REST API.
+   * Update an existing entry's value while preserving metadata.
+   *
+   * @param key - The key to update
+   * @param value - The new value
+   * @param options - Options (scope, ttl)
    */
-  async close() {
-  }
-};
-RememberVercelKvProvider = __decorateClass([
-  Provider3({
-    name: "provider:remember:vercel-kv",
-    description: "Vercel KV-based storage provider for RememberPlugin",
-    scope: ProviderScope3.GLOBAL
-  })
-], RememberVercelKvProvider);
-
-// plugins/plugin-remember/src/providers/remember-accessor.provider.ts
-import { Provider as Provider4, ProviderScope as ProviderScope4 } from "@frontmcp/sdk";
-
-// plugins/plugin-remember/src/remember.crypto.ts
-import {
-  hkdfSha256,
-  encryptAesGcm,
-  decryptAesGcm,
-  randomBytes as randomBytes2,
-  base64urlEncode as base64urlEncode2,
-  base64urlDecode
-} from "@frontmcp/utils";
-
-// plugins/plugin-remember/src/remember.secret-persistence.ts
-import * as path from "path";
-import { z } from "@frontmcp/lazy-zod";
-import { base64urlEncode, mkdir, randomBytes, readFile, rename, unlink, writeFile } from "@frontmcp/utils";
-var DEFAULT_SECRET_FILE_PATH = ".frontmcp/remember-secret.json";
-var SECRET_BYTES = 32;
-var rememberSecretDataSchema = z.object({
-  secret: z.string().min(32),
-  // base64url of 32 bytes is ~43 chars
-  createdAt: z.number().positive().int(),
-  version: z.literal(1)
-});
-function validateSecretData(data) {
-  const result = rememberSecretDataSchema.safeParse(data);
-  if (!result.success) {
-    return { valid: false, error: result.error.issues[0]?.message ?? "Invalid secret structure" };
-  }
-  const parsed = result.data;
-  const now = Date.now();
-  if (parsed.createdAt > now + 6e4) {
-    return { valid: false, error: "createdAt is in the future" };
-  }
-  const hundredYearsMs = 100 * 365 * 24 * 60 * 60 * 1e3;
-  if (parsed.createdAt < now - hundredYearsMs) {
-    return { valid: false, error: "createdAt is too old" };
+  async update(key, value, options = {}) {
+    const scope = options.scope ?? "session";
+    const existing = await this.getEntry(key, { scope });
+    if (!existing) return false;
+    const entry = {
+      ...existing,
+      value,
+      updatedAt: Date.now(),
+      expiresAt: options.ttl ? Date.now() + options.ttl * 1e3 : existing.expiresAt
+    };
+    const storageKey = this.buildStorageKey(key, scope);
+    const serialized = this.encryptionEnabled ? await encryptAndSerialize(entry, this.getKeySource(scope)) : JSON.stringify(entry);
+    await this.store.setValue(storageKey, serialized, options.ttl);
+    return true;
   }
-  return { valid: true };
-}
-function isSecretPersistenceEnabled(options) {
-  const isProduction = process.env["NODE_ENV"] === "production";
-  if (isProduction) {
-    return options?.forceEnable === true;
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Convenience Methods
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Get the session ID from context.
+   */
+  get sessionId() {
+    return this.ctx.sessionId;
   }
-  return true;
-}
-function resolveSecretPath(options) {
-  const secretPath = options?.secretPath ?? DEFAULT_SECRET_FILE_PATH;
-  if (path.isAbsolute(secretPath)) {
-    return secretPath;
+  /**
+   * Get the user ID from context (if available).
+   */
+  get userId() {
+    const authInfo = this.ctx.authInfo;
+    return authInfo?.extra?.["userId"] ?? authInfo?.extra?.["sub"] ?? authInfo?.clientId ?? void 0;
   }
-  return path.resolve(process.cwd(), secretPath);
-}
-async function loadRememberSecret(options) {
-  if (!isSecretPersistenceEnabled(options)) {
-    return null;
+  // ─────────────────────────────────────────────────────────────────────────────
+  // Private Methods
+  // ─────────────────────────────────────────────────────────────────────────────
+  /**
+   * Build the full storage key including scope prefix.
+   */
+  buildStorageKey(key, scope) {
+    return this.buildScopePrefix(scope) + key;
   }
-  const secretPath = resolveSecretPath(options);
-  try {
-    const content = await readFile(secretPath, "utf8");
-    const data = JSON.parse(content);
-    const validation = validateSecretData(data);
-    if (!validation.valid) {
-      console.warn(
-        `[RememberSecretPersistence] Invalid secret file format at ${secretPath}: ${validation.error}, will regenerate`
-      );
-      return null;
+  /**
+   * The identity that namespaces session- and tool-scoped storage
+   * (GHSA-225p-f8jh-f3rh).
+   *
+   * In stateless mode the transport injects the literal session id `__stateless__` into every
+   * request, so using it as a namespace put every client's memory under the same keys. A
+   * stateless request carries no session identity: the authenticated principal is the only
+   * per-client identity available, and where there is none the request has no business
+   * reading or writing per-client memory at all.
+   */
+  resolveSessionIdentity() {
+    const sessionId = this.ctx.sessionId;
+    if (sessionId !== STATELESS_SESSION_ID) {
+      return sessionId;
     }
-    return data;
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return null;
+    const userId = this.userId;
+    if (userId) {
+      return `stateless-user:${userId}`;
     }
-    console.warn(`[RememberSecretPersistence] Failed to load secret from ${secretPath}: ${error.message}`);
-    return null;
+    throw new RememberIdentityError(
+      `Remember cannot use session or tool scope for an unauthenticated stateless request: every such request shares the session id "${STATELESS_SESSION_ID}", so the data would be shared across all clients. Authenticate the request, use a stateful transport, or choose the 'global' scope if the data really is shared.`
+    );
   }
-}
-async function saveRememberSecret(secretData, options) {
-  if (!isSecretPersistenceEnabled(options)) {
-    return true;
+  /**
+   * Build the scope-specific prefix.
+   *
+   * Every variable component is encoded, because the separator is also a legal character in
+   * a user id, a tool name and a memory key. Left raw, identity `a` with key `b:c` produces
+   * the same storage key as identity `a:b` with key `c` — one client reading or overwriting
+   * another's value through nothing more exotic than a colon in a name.
+   */
+  buildScopePrefix(scope) {
+    switch (scope) {
+      case "session":
+        return `${this.keyPrefix}${STORAGE_LAYOUT_VERSION}:session:${encodeKeyPart(this.resolveSessionIdentity())}:`;
+      case "user": {
+        const userId = this.userId;
+        if (!userId) {
+          throw new RememberIdentityError(
+            "Remember cannot use user scope without an authenticated user: all unauthenticated callers would share one namespace. Authenticate the request or use the 'global' scope."
+          );
+        }
+        return `${this.keyPrefix}${STORAGE_LAYOUT_VERSION}:user:${encodeKeyPart(userId)}:`;
+      }
+      case "tool": {
+        const toolName = this.ctx.flow?.name ?? "unknown";
+        return `${this.keyPrefix}${STORAGE_LAYOUT_VERSION}:tool:${encodeKeyPart(toolName)}:${encodeKeyPart(this.resolveSessionIdentity())}:`;
+      }
+      case "global":
+        return `${this.keyPrefix}global:`;
+    }
   }
-  const secretPath = resolveSecretPath(options);
-  const dir = path.dirname(secretPath);
-  const tempPath = `${secretPath}.tmp.${Date.now()}.${base64urlEncode(randomBytes(8))}`;
-  try {
-    await mkdir(dir, { recursive: true, mode: 448 });
-    const content = JSON.stringify(secretData, null, 2);
-    await writeFile(tempPath, content, { mode: 384 });
-    await rename(tempPath, secretPath);
-    return true;
-  } catch (error) {
-    console.error(`[RememberSecretPersistence] Failed to save secret to ${secretPath}: ${error.message}`);
+  /**
+   * Get the encryption key source for a scope.
+   */
+  getKeySource(scope) {
+    const needsSessionIdentity = scope === "session" || scope === "tool";
+    return getKeySourceForScope(scope, {
+      sessionId: needsSessionIdentity ? this.resolveSessionIdentity() : this.ctx.sessionId,
+      userId: this.userId,
+      toolName: this.ctx.flow?.name
+    });
+  }
+  /**
+   * Parse a JSON entry (when encryption is disabled).
+   */
+  parseEntry(raw) {
     try {
-      await unlink(tempPath);
+      return JSON.parse(raw);
     } catch {
+      return null;
     }
-    return false;
   }
+};
+RememberAccessor = __decorateClass([
+  Provider({
+    name: "provider:remember:accessor",
+    description: "Context-scoped accessor for RememberPlugin storage",
+    scope: ProviderScope.CONTEXT
+  })
+], RememberAccessor);
+function createRememberAccessor(store, ctx, config, logger) {
+  return new RememberAccessor(store, ctx, config, logger);
 }
-var cachedSecret = null;
-var secretGenerationPromise = null;
-function generateSecret() {
-  return base64urlEncode(randomBytes(SECRET_BYTES));
-}
-async function getOrCreatePersistedSecret(options) {
-  if (cachedSecret) {
-    return cachedSecret;
-  }
-  if (secretGenerationPromise) {
-    return secretGenerationPromise;
+
+// plugins/plugin-remember/src/providers/remember-memory.provider.ts
+import { Provider as Provider2, ProviderScope as ProviderScope2 } from "@frontmcp/sdk";
+var MAX_TIMEOUT_MS = 2 ** 31 - 1;
+var RememberMemoryProvider = class {
+  memory = /* @__PURE__ */ new Map();
+  sweeper;
+  constructor(sweepIntervalSeconds = 60) {
+    this.sweeper = setInterval(() => this.sweep(), sweepIntervalSeconds * 1e3);
+    this.sweeper.unref?.();
   }
-  secretGenerationPromise = (async () => {
-    try {
-      const loaded = await loadRememberSecret(options);
-      if (loaded) {
-        cachedSecret = loaded.secret;
-        return cachedSecret;
-      }
-      const newSecret = generateSecret();
-      const secretData = {
-        secret: newSecret,
-        createdAt: Date.now(),
-        version: 1
-      };
-      if (isSecretPersistenceEnabled(options)) {
-        await saveRememberSecret(secretData, options);
+  /**
+   * Store a value with optional TTL.
+   * Always JSON-serializes the value for consistent storage/retrieval.
+   */
+  async setValue(key, value, ttlSeconds) {
+    const strValue = JSON.stringify(value);
+    const existing = this.memory.get(key);
+    if (existing?.timeout) clearTimeout(existing.timeout);
+    const entry = { value: strValue };
+    if (ttlSeconds && ttlSeconds > 0) {
+      const ttlMs = ttlSeconds * 1e3;
+      entry.expiresAt = Date.now() + ttlMs;
+      if (ttlMs <= MAX_TIMEOUT_MS) {
+        entry.timeout = setTimeout(() => {
+          const e = this.memory.get(key);
+          if (e && e.expiresAt && e.expiresAt <= Date.now()) {
+            this.memory.delete(key);
+          }
+        }, ttlMs);
+        entry.timeout.unref?.();
       }
-      cachedSecret = newSecret;
-      return cachedSecret;
-    } finally {
-      secretGenerationPromise = null;
     }
-  })();
-  return secretGenerationPromise;
-}
-
-// plugins/plugin-remember/src/remember.crypto.ts
-async function getBaseSecret() {
-  const envSecret = process.env["REMEMBER_SECRET"] || process.env["MCP_MEMORY_SECRET"] || process.env["MCP_SESSION_SECRET"];
-  if (envSecret) {
-    return envSecret;
+    this.memory.set(key, entry);
   }
-  return getOrCreatePersistedSecret();
-}
-var textEncoder = new TextEncoder();
-async function deriveEncryptionKey(source) {
-  const salt = textEncoder.encode("remember-plugin-v1");
-  let ikm;
-  let context;
-  switch (source.type) {
-    case "session":
-      ikm = source.sessionId;
-      context = `remember:session:${source.sessionId}`;
-      break;
-    case "tool":
-      ikm = source.sessionId;
-      context = `remember:tool:${source.toolName}:${source.sessionId}`;
-      break;
-    case "user":
-      ikm = await getBaseSecret() + source.userId;
-      context = `remember:user:${source.userId}`;
-      break;
-    case "global":
-      ikm = await getBaseSecret();
-      context = "remember:global";
-      break;
-    case "custom":
-      ikm = source.key;
-      context = `remember:custom:${source.key}`;
-      break;
+  /**
+   * Store a value only if the key is absent.
+   *
+   * A single-threaded runtime makes the check-then-set indivisible; an expired entry counts as
+   * absent, matching what `getValue` would report.
+   */
+  async setIfAbsent(key, value, ttlSeconds) {
+    const existing = this.memory.get(key);
+    if (existing && !this.isExpired(existing)) return false;
+    await this.setValue(key, value, ttlSeconds);
+    return true;
   }
-  const ikmBytes = textEncoder.encode(ikm);
-  const info = textEncoder.encode(context);
-  return hkdfSha256(ikmBytes, salt, info, 32);
-}
-function getKeySourceForScope(scope, context) {
-  switch (scope) {
-    case "session":
-      return { type: "session", sessionId: context.sessionId };
-    case "user":
-      return { type: "user", userId: context.userId ?? "anonymous" };
-    case "tool":
-      return {
-        type: "tool",
-        toolName: context.toolName ?? "unknown",
-        sessionId: context.sessionId
-      };
-    case "global":
-      return { type: "global" };
+  /**
+   * Retrieve a value by key.
+   * JSON-parses the stored value to match the setValue serialization.
+   */
+  async getValue(key, defaultValue) {
+    const entry = this.memory.get(key);
+    if (!entry) return defaultValue;
+    if (this.isExpired(entry)) {
+      await this.delete(key);
+      return defaultValue;
+    }
+    try {
+      return JSON.parse(entry.value);
+    } catch {
+      return entry.value;
+    }
+  }
+  /**
+   * Delete a key.
+   */
+  async delete(key) {
+    const entry = this.memory.get(key);
+    if (entry?.timeout) clearTimeout(entry.timeout);
+    this.memory.delete(key);
   }
-}
-var textDecoder = new TextDecoder();
-async function encryptValue(data, keySource) {
-  const key = await deriveEncryptionKey(keySource);
-  const plaintext = textEncoder.encode(JSON.stringify(data));
-  const iv = randomBytes2(12);
-  const { ciphertext, tag } = encryptAesGcm(key, plaintext, iv);
-  return {
-    alg: "A256GCM",
-    iv: base64urlEncode2(iv),
-    tag: base64urlEncode2(tag),
-    data: base64urlEncode2(ciphertext)
-  };
-}
-async function decryptValue(blob, keySource) {
-  try {
-    const key = await deriveEncryptionKey(keySource);
-    const iv = base64urlDecode(blob.iv);
-    const tag = base64urlDecode(blob.tag);
-    const ciphertext = base64urlDecode(blob.data);
-    const decrypted = decryptAesGcm(key, ciphertext, iv, tag);
-    return JSON.parse(textDecoder.decode(decrypted));
-  } catch {
-    return null;
+  /**
+   * Check if a key exists (and is not expired).
+   */
+  async exists(key) {
+    const entry = this.memory.get(key);
+    if (!entry) return false;
+    if (this.isExpired(entry)) {
+      await this.delete(key);
+      return false;
+    }
+    return true;
   }
-}
-function serializeBlob(blob) {
-  return JSON.stringify(blob);
-}
-function deserializeBlob(str) {
-  try {
-    const parsed = JSON.parse(str);
-    if (parsed && typeof parsed === "object" && parsed.alg === "A256GCM" && typeof parsed.iv === "string" && typeof parsed.tag === "string" && typeof parsed.data === "string") {
-      return parsed;
+  /**
+   * List keys matching a glob-style pattern.
+   * Supports * and ? wildcards.
+   */
+  async keys(pattern) {
+    const result = [];
+    const regex = pattern ? this.patternToRegex(pattern) : null;
+    const expiredKeys = [];
+    for (const [key, entry] of this.memory) {
+      if (this.isExpired(entry)) {
+        expiredKeys.push(key);
+      }
     }
-    return null;
-  } catch {
-    return null;
+    for (const key of expiredKeys) {
+      await this.delete(key);
+    }
+    for (const [key, entry] of this.memory) {
+      if (this.isExpired(entry)) {
+        continue;
+      }
+      if (regex && !regex.test(key)) {
+        continue;
+      }
+      result.push(key);
+    }
+    return result;
   }
-}
-async function encryptAndSerialize(data, keySource) {
-  const blob = await encryptValue(data, keySource);
-  return serializeBlob(blob);
-}
-async function deserializeAndDecrypt(str, keySource) {
-  const blob = deserializeBlob(str);
-  if (!blob) return null;
-  return decryptValue(blob, keySource);
-}
-
-// plugins/plugin-remember/src/providers/remember-accessor.provider.ts
-var RememberAccessor = class {
-  store;
-  ctx;
-  config;
-  keyPrefix;
-  encryptionEnabled;
-  constructor(store, ctx, config) {
-    this.store = store;
-    this.ctx = ctx;
-    this.config = config;
-    this.keyPrefix = config.keyPrefix ?? "remember:";
-    this.encryptionEnabled = config.encryption?.enabled !== false;
+  /**
+   * Gracefully close the provider.
+   */
+  async close() {
+    if (this.sweeper) clearInterval(this.sweeper);
+    for (const [, entry] of this.memory) {
+      if (entry.timeout) clearTimeout(entry.timeout);
+    }
+    this.memory.clear();
   }
   // ─────────────────────────────────────────────────────────────────────────────
-  // Public API
+  // Private Methods
   // ─────────────────────────────────────────────────────────────────────────────
+  isExpired(entry) {
+    return entry.expiresAt !== void 0 && entry.expiresAt <= Date.now();
+  }
   /**
-   * Store a value in memory.
-   *
-   * @param key - The key to store under
-   * @param value - The value to store (any JSON-serializable data)
-   * @param options - Storage options (scope, ttl, brand, metadata)
+   * Periodically remove expired keys to keep memory tidy.
    */
-  async set(key, value, options = {}) {
-    const scope = options.scope ?? "session";
-    const storageKey = this.buildStorageKey(key, scope);
-    const entry = {
-      value,
-      brand: options.brand,
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-      expiresAt: options.ttl ? Date.now() + options.ttl * 1e3 : void 0,
-      metadata: options.metadata
-    };
-    const serialized = this.encryptionEnabled ? await encryptAndSerialize(entry, this.getKeySource(scope)) : JSON.stringify(entry);
-    await this.store.setValue(storageKey, serialized, options.ttl);
+  sweep() {
+    const now = Date.now();
+    for (const [key, entry] of this.memory) {
+      if (entry.expiresAt !== void 0 && entry.expiresAt <= now) {
+        if (entry.timeout) clearTimeout(entry.timeout);
+        this.memory.delete(key);
+      }
+    }
   }
   /**
-   * Retrieve a value from memory.
+   * Convert a glob-style pattern to a RegExp.
+   * * matches any sequence of characters
+   * ? matches any single character
    *
-   * @param key - The key to retrieve
-   * @param options - Retrieval options (scope, defaultValue)
-   * @returns The stored value or defaultValue if not found
+   * Includes ReDoS protection: validates pattern length and wildcard count.
    */
-  async get(key, options = {}) {
-    const scope = options.scope ?? "session";
-    const storageKey = this.buildStorageKey(key, scope);
-    const raw = await this.store.getValue(storageKey);
-    if (!raw) return options.defaultValue;
-    const entry = this.encryptionEnabled ? await deserializeAndDecrypt(raw, this.getKeySource(scope)) : this.parseEntry(raw);
-    if (!entry) return options.defaultValue;
-    if (entry.expiresAt && Date.now() > entry.expiresAt) {
-      await this.forget(key, { scope });
-      return options.defaultValue;
+  patternToRegex(pattern) {
+    if (pattern.length > RememberMemoryProvider.MAX_PATTERN_LENGTH) {
+      throw new Error(`Pattern too long: ${pattern.length} chars (max ${RememberMemoryProvider.MAX_PATTERN_LENGTH})`);
     }
-    return entry.value;
+    const wildcardCount = (pattern.match(/[*?]/g) || []).length;
+    if (wildcardCount > RememberMemoryProvider.MAX_WILDCARDS) {
+      throw new Error(`Too many wildcards in pattern: ${wildcardCount} (max ${RememberMemoryProvider.MAX_WILDCARDS})`);
+    }
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    return new RegExp(`^${escaped}$`);
   }
+};
+// ReDoS protection constants
+// Pattern length allows for long prefixes (e.g., remember:session:{uuid}:user:*)
+__publicField(RememberMemoryProvider, "MAX_PATTERN_LENGTH", 500);
+__publicField(RememberMemoryProvider, "MAX_WILDCARDS", 20);
+RememberMemoryProvider = __decorateClass([
+  Provider2({
+    name: "provider:remember:memory",
+    description: "In-memory storage provider for RememberPlugin",
+    scope: ProviderScope2.GLOBAL
+  })
+], RememberMemoryProvider);
+
+// plugins/plugin-remember/src/providers/remember-redis.provider.ts
+import Redis from "ioredis";
+import { Provider as Provider3, ProviderScope as ProviderScope3 } from "@frontmcp/sdk";
+var RememberRedisProvider = class {
+  client;
   /**
-   * Get the full entry including metadata.
+   * Prefix prepended to all Redis keys.
+   * Include any separator (e.g., "myapp:" or "user:123:") as part of the prefix.
+   */
+  keyPrefix;
+  /** True if this provider created the client (and should close it), false if externally provided */
+  ownsClient;
+  constructor(options) {
+    this.keyPrefix = options.keyPrefix ?? "";
+    if (options.type === "redis-client") {
+      this.client = options.client;
+      this.ownsClient = false;
+      return;
+    }
+    this.ownsClient = true;
+    this.client = new Redis({
+      lazyConnect: false,
+      maxRetriesPerRequest: 3,
+      ...options.config
+    });
+    this.client.on("connect", () => {
+      if (process.env["DEBUG"] === "true") {
+        console.log("[RememberPlugin:Redis] Connected");
+      }
+    });
+    this.client.on("error", (err) => {
+      console.error("[RememberPlugin:Redis] Error:", err.message);
+    });
+  }
+  /**
+   * Store a value with optional TTL.
    *
-   * @param key - The key to retrieve
-   * @param options - Retrieval options (scope)
-   * @returns The full entry or undefined if not found
+   * @param key - The key to store under
+   * @param value - The value to store (must not be undefined)
+   * @param ttlSeconds - Optional TTL in seconds (must be positive integer if provided)
+   * @throws Error if value is undefined or ttlSeconds is invalid
    */
-  async getEntry(key, options = {}) {
-    const scope = options.scope ?? "session";
-    const storageKey = this.buildStorageKey(key, scope);
-    const raw = await this.store.getValue(storageKey);
-    if (!raw) return void 0;
-    const entry = this.encryptionEnabled ? await deserializeAndDecrypt(raw, this.getKeySource(scope)) : this.parseEntry(raw);
-    if (!entry) return void 0;
-    if (entry.expiresAt && Date.now() > entry.expiresAt) {
-      await this.forget(key, { scope });
-      return void 0;
+  async setValue(key, value, ttlSeconds) {
+    if (value === void 0) {
+      throw new Error("Cannot store undefined value. Use null or delete the key instead.");
+    }
+    if (ttlSeconds !== void 0) {
+      if (typeof ttlSeconds !== "number" || !Number.isFinite(ttlSeconds)) {
+        throw new Error(`Invalid TTL: expected a number, got ${typeof ttlSeconds}`);
+      }
+      if (ttlSeconds <= 0) {
+        throw new Error(`Invalid TTL: must be positive, got ${ttlSeconds}`);
+      }
+      if (!Number.isInteger(ttlSeconds)) {
+        throw new Error(`Invalid TTL: must be an integer, got ${ttlSeconds}`);
+      }
+    }
+    const fullKey = this.keyPrefix + key;
+    const strValue = typeof value === "string" ? value : JSON.stringify(value);
+    if (ttlSeconds !== void 0 && ttlSeconds > 0) {
+      await this.client.set(fullKey, strValue, "EX", ttlSeconds);
+    } else {
+      await this.client.set(fullKey, strValue);
     }
-    return entry;
   }
   /**
-   * Forget (delete) a value from memory.
+   * Store a value only if the key is absent, via Redis `SET ... NX`.
    *
-   * @param key - The key to forget
-   * @param options - Options (scope)
+   * `set` resolves to `'OK'` when it created the key and `null` when the key already existed,
+   * so the whole check-and-write is one round trip and two callers racing cannot both win.
    */
-  async forget(key, options = {}) {
-    const scope = options.scope ?? "session";
-    const storageKey = this.buildStorageKey(key, scope);
-    await this.store.delete(storageKey);
+  async setIfAbsent(key, value, ttlSeconds) {
+    const fullKey = this.keyPrefix + key;
+    const strValue = typeof value === "string" ? value : JSON.stringify(value);
+    const result = ttlSeconds !== void 0 && ttlSeconds > 0 ? await this.client.set(fullKey, strValue, "EX", ttlSeconds, "NX") : await this.client.set(fullKey, strValue, "NX");
+    return result === "OK";
   }
   /**
-   * Check if a key is remembered (exists and not expired).
+   * Retrieve a value by key.
    *
-   * @param key - The key to check
-   * @param options - Options (scope)
-   * @returns true if the key exists
+   * Returns the parsed JSON value if successful, or `defaultValue` if:
+   * - The key does not exist
+   * - The stored value is not valid JSON (malformed or legacy data)
+   *
+   * @param key - The key to retrieve
+   * @param defaultValue - Value to return if key doesn't exist or parsing fails
+   * @returns The parsed value as T, or defaultValue/undefined
    */
-  async knows(key, options = {}) {
-    const scope = options.scope ?? "session";
-    const storageKey = this.buildStorageKey(key, scope);
-    return this.store.exists(storageKey);
+  async getValue(key, defaultValue) {
+    const fullKey = this.keyPrefix + key;
+    const raw = await this.client.get(fullKey);
+    if (raw === null) return defaultValue;
+    try {
+      return JSON.parse(raw);
+    } catch {
+      return defaultValue;
+    }
   }
   /**
-   * List all remembered keys for a scope.
-   *
-   * @param options - Options (scope, pattern)
-   * @returns Array of keys (without the scope prefix)
+   * Delete a key.
    */
-  async list(options = {}) {
-    const scope = options.scope ?? "session";
-    const scopePrefix = this.buildScopePrefix(scope);
-    const fullPattern = scopePrefix + (options.pattern ?? "*");
-    const keys = await this.store.keys(fullPattern);
-    return keys.map((k) => k.slice(scopePrefix.length));
+  async delete(key) {
+    const fullKey = this.keyPrefix + key;
+    await this.client.del(fullKey);
   }
   /**
-   * Update an existing entry's value while preserving metadata.
-   *
-   * @param key - The key to update
-   * @param value - The new value
-   * @param options - Options (scope, ttl)
+   * Check if a key exists.
    */
-  async update(key, value, options = {}) {
-    const scope = options.scope ?? "session";
-    const existing = await this.getEntry(key, { scope });
-    if (!existing) return false;
-    const entry = {
-      ...existing,
-      value,
-      updatedAt: Date.now(),
-      expiresAt: options.ttl ? Date.now() + options.ttl * 1e3 : existing.expiresAt
-    };
-    const storageKey = this.buildStorageKey(key, scope);
-    const serialized = this.encryptionEnabled ? await encryptAndSerialize(entry, this.getKeySource(scope)) : JSON.stringify(entry);
-    await this.store.setValue(storageKey, serialized, options.ttl);
-    return true;
+  async exists(key) {
+    const fullKey = this.keyPrefix + key;
+    return await this.client.exists(fullKey) === 1;
   }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Convenience Methods
-  // ─────────────────────────────────────────────────────────────────────────────
   /**
-   * Get the session ID from context.
+   * List keys matching a pattern.
+   * Uses Redis SCAN for efficient iteration.
    */
-  get sessionId() {
-    return this.ctx.sessionId;
+  async keys(pattern) {
+    const searchPattern = this.keyPrefix + (pattern ?? "*");
+    const result = [];
+    let cursor = "0";
+    do {
+      const [nextCursor, keys] = await this.client.scan(cursor, "MATCH", searchPattern, "COUNT", 100);
+      cursor = nextCursor;
+      for (const key of keys) {
+        result.push(key.slice(this.keyPrefix.length));
+      }
+    } while (cursor !== "0");
+    return result;
   }
   /**
-   * Get the user ID from context (if available).
+   * Gracefully close the Redis connection.
+   * Only closes if this provider owns the client (created it internally).
+   * Externally-provided clients are left open for the caller to manage.
    */
-  get userId() {
-    const authInfo = this.ctx.authInfo;
-    return authInfo?.extra?.["userId"] ?? authInfo?.extra?.["sub"] ?? authInfo?.clientId ?? void 0;
+  async close() {
+    if (this.ownsClient) {
+      await this.client.quit();
+    }
+  }
+};
+RememberRedisProvider = __decorateClass([
+  Provider3({
+    name: "provider:remember:redis",
+    description: "Redis-based storage provider for RememberPlugin",
+    scope: ProviderScope3.GLOBAL
+  })
+], RememberRedisProvider);
+
+// plugins/plugin-remember/src/providers/remember-vercel-kv.provider.ts
+import { Provider as Provider4, ProviderScope as ProviderScope4 } from "@frontmcp/sdk";
+var RememberVercelKvProvider = class {
+  kv;
+  keyPrefix;
+  defaultTTL;
+  constructor(options = {}) {
+    const vercelKv = __require("@vercel/kv");
+    const hasUrl = options.url !== void 0;
+    const hasToken = options.token !== void 0;
+    if (hasUrl !== hasToken) {
+      throw new Error(
+        `RememberVercelKvProvider: Both 'url' and 'token' must be provided together, or neither. Received: url=${hasUrl ? "provided" : "missing"}, token=${hasToken ? "provided" : "missing"}`
+      );
+    }
+    if (options.url && options.token) {
+      this.kv = vercelKv.createClient({
+        url: options.url,
+        token: options.token
+      });
+    } else {
+      this.kv = vercelKv.kv;
+    }
+    this.keyPrefix = options.keyPrefix ?? "remember:";
+    this.defaultTTL = options.defaultTTL;
+  }
+  prefixKey(key) {
+    return `${this.keyPrefix}${key}`;
   }
-  // ─────────────────────────────────────────────────────────────────────────────
-  // Private Methods
-  // ─────────────────────────────────────────────────────────────────────────────
   /**
-   * Build the full storage key including scope prefix.
+   * Store a value with optional TTL.
    */
-  buildStorageKey(key, scope) {
-    return this.buildScopePrefix(scope) + key;
+  async setValue(key, value, ttlSeconds) {
+    const fullKey = this.prefixKey(key);
+    const strValue = typeof value === "string" ? value : JSON.stringify(value);
+    const ttl = ttlSeconds ?? this.defaultTTL;
+    if (ttl && ttl > 0) {
+      await this.kv.set(fullKey, strValue, { ex: ttl });
+    } else {
+      await this.kv.set(fullKey, strValue);
+    }
   }
   /**
-   * Build the scope-specific prefix.
+   * Store a value only if the key is absent, via the `nx` option.
+   *
+   * Resolves to `'OK'` when it created the key and `null` when the key already existed, so two
+   * callers racing cannot both win.
    */
-  buildScopePrefix(scope) {
-    switch (scope) {
-      case "session":
-        return `${this.keyPrefix}session:${this.ctx.sessionId}:`;
-      case "user":
-        return `${this.keyPrefix}user:${this.userId ?? "anonymous"}:`;
-      case "tool": {
-        const toolName = this.ctx.flow?.name ?? "unknown";
-        return `${this.keyPrefix}tool:${toolName}:${this.ctx.sessionId}:`;
+  async setIfAbsent(key, value, ttlSeconds) {
+    const fullKey = this.prefixKey(key);
+    const strValue = typeof value === "string" ? value : JSON.stringify(value);
+    const ttl = ttlSeconds ?? this.defaultTTL;
+    const result = ttl && ttl > 0 ? await this.kv.set(fullKey, strValue, { nx: true, ex: ttl }) : await this.kv.set(fullKey, strValue, { nx: true });
+    return result === "OK";
+  }
+  /**
+   * Retrieve a value by key.
+   */
+  async getValue(key, defaultValue) {
+    const fullKey = this.prefixKey(key);
+    const raw = await this.kv.get(fullKey);
+    if (raw === null || raw === void 0) return defaultValue;
+    if (typeof raw === "string") {
+      try {
+        return JSON.parse(raw);
+      } catch {
+        return raw;
       }
-      case "global":
-        return `${this.keyPrefix}global:`;
     }
+    return raw;
   }
   /**
-   * Get the encryption key source for a scope.
+   * Delete a key.
    */
-  getKeySource(scope) {
-    return getKeySourceForScope(scope, {
-      sessionId: this.ctx.sessionId,
-      userId: this.userId,
-      toolName: this.ctx.flow?.name
-    });
+  async delete(key) {
+    const fullKey = this.prefixKey(key);
+    await this.kv.del(fullKey);
   }
   /**
-   * Parse a JSON entry (when encryption is disabled).
+   * Check if a key exists.
    */
-  parseEntry(raw) {
+  async exists(key) {
+    const fullKey = this.prefixKey(key);
+    return await this.kv.exists(fullKey) === 1;
+  }
+  /**
+   * List keys matching a pattern.
+   * Uses SCAN for efficient iteration.
+   */
+  async keys(pattern) {
+    const searchPattern = this.prefixKey(pattern ?? "*");
+    const result = [];
     try {
-      return JSON.parse(raw);
+      let cursor = 0;
+      do {
+        const [nextCursor, keys] = await this.kv.scan(cursor, {
+          match: searchPattern,
+          count: 100
+        });
+        cursor = nextCursor;
+        for (const key of keys) {
+          result.push(key.slice(this.keyPrefix.length));
+        }
+      } while (cursor !== 0);
     } catch {
-      return null;
+      try {
+        const keys = await this.kv.keys(searchPattern);
+        for (const key of keys) {
+          result.push(key.slice(this.keyPrefix.length));
+        }
+      } catch {
+        console.warn("[RememberPlugin:VercelKV] keys() operation not supported");
+      }
     }
+    return result;
+  }
+  /**
+   * Gracefully close the provider.
+   * No-op for Vercel KV as it uses stateless REST API.
+   */
+  async close() {
   }
 };
-RememberAccessor = __decorateClass([
+RememberVercelKvProvider = __decorateClass([
   Provider4({
-    name: "provider:remember:accessor",
-    description: "Context-scoped accessor for RememberPlugin storage",
-    scope: ProviderScope4.CONTEXT
+    name: "provider:remember:vercel-kv",
+    description: "Vercel KV-based storage provider for RememberPlugin",
+    scope: ProviderScope4.GLOBAL
   })
-], RememberAccessor);
-function createRememberAccessor(store, ctx, config) {
-  return new RememberAccessor(store, ctx, config);
-}
+], RememberVercelKvProvider);
+
+// plugins/plugin-remember/src/remember.symbols.ts
+var RememberStoreToken = /* @__PURE__ */ Symbol(
+  "plugin:remember:store"
+);
+var RememberConfigToken = /* @__PURE__ */ Symbol(
+  "plugin:remember:config"
+);
+var RememberAccessorToken = /* @__PURE__ */ Symbol(
+  "plugin:remember:accessor"
+);
 
 // plugins/plugin-remember/src/remember.plugin.ts
 var RememberPlugin = class extends DynamicPlugin {
@@ -1015,8 +1212,8 @@ __publicField(RememberPlugin, "dynamicProviders", (options) => {
     name: "remember:accessor",
     provide: RememberAccessorToken,
     scope: ProviderScope5.CONTEXT,
-    inject: () => [RememberStoreToken, FRONTMCP_CONTEXT2, RememberConfigToken],
-    useFactory: (store, ctx, cfg) => createRememberAccessor(store, ctx, cfg)
+    inject: () => [RememberStoreToken, FRONTMCP_CONTEXT, RememberConfigToken, FrontMcpLogger],
+    useFactory: (store, ctx, cfg, logger) => createRememberAccessor(store, ctx, cfg, logger)
   });
   return providers;
 });
@@ -1276,6 +1473,7 @@ export {
   RememberAccessor,
   RememberAccessorToken,
   RememberConfigToken,
+  RememberIdentityError,
   RememberMemoryProvider,
   RememberPlugin,
   RememberRedisProvider,