@memoryrelay/plugin-memoryrelay-ai 0.15.6 → 0.16.0

package/src/context/namespace-router.ts

@@ -0,0 +1,19 @@
+// src/context/namespace-router.ts
+export interface NamespaceConfig {
+  isolateAgents?: boolean;
+  subagentPolicy?: "inherit" | "isolate" | "skip";
+}
+
+const DEFAULTS: Required<NamespaceConfig> = {
+  isolateAgents: false,
+  subagentPolicy: "inherit",
+};
+
+export function resolveNamespace(
+  agentId: string | null,
+  nsConfig: NamespaceConfig | undefined,
+): string {
+  const config = { ...DEFAULTS, ...nsConfig };
+  if (!config.isolateAgents || !agentId) return "default";
+  return `agent:${agentId}`;
+}

package/src/context/request-context.ts

@@ -0,0 +1,39 @@
+// src/context/request-context.ts
+import type { RequestContext, PluginConfig } from "../pipelines/types.js";
+import { resolveNamespace } from "./namespace-router.js";
+
+export interface HookEvent {
+  ctx?: {
+    sessionKey?: string;
+    trigger?: string;
+  };
+  sessionId?: string;
+  channel?: string | number;
+  prompt?: string;
+}
+
+export function buildRequestContext(event: HookEvent, config: PluginConfig): RequestContext {
+  const sessionKey = event.ctx?.sessionKey ?? event.sessionId ?? "";
+  const subagentMatch = sessionKey.match(/^agent:([^:]+):subagent:(.+)$/);
+  const agentMatch = sessionKey.match(/^agent:([^:]+):(.+)$/);
+
+  const isSubagent = !!subagentMatch;
+  const agentId = subagentMatch?.[1] ?? agentMatch?.[1] ?? config.agentId ?? null;
+  // Convention: subagent key format is agent:<agentId>:subagent:<parentSessionSuffix>
+  // The parent key is reconstructed by removing the :subagent: segment
+  const parentSessionKey = isSubagent
+    ? sessionKey.replace(/:subagent:[^:]+$/, `:${subagentMatch![2]}`)
+    : null;
+
+  return Object.freeze({
+    sessionKey,
+    agentId,
+    channel: event.channel != null ? String(event.channel) : null,
+    trigger: event.ctx?.trigger ?? null,
+    prompt: event.prompt?.trim() ?? "",
+    isSubagent,
+    parentSessionKey,
+    namespace: resolveNamespace(agentId, config.namespace),
+    timestamp: Date.now(),
+  });
+}

package/src/context/session-resolver.ts

@@ -0,0 +1,93 @@
+// src/context/session-resolver.ts
+import type { MemoryRelayClient, PluginConfig, RequestContext } from "../pipelines/types.js";
+
+const MAX_CACHE_SIZE = 1000;
+
+export interface SessionEntry {
+  readonly sessionId: string;
+  readonly externalId: string;
+  readonly createdAt: number;
+  lastActivityAt: number;
+}
+
+export class SessionResolver {
+  private readonly cache = new Map<string, SessionEntry>();
+  private readonly pending = new Map<string, Promise<SessionEntry>>();
+  private readonly client: MemoryRelayClient;
+  private readonly timeoutMs: number;
+
+  constructor(client: MemoryRelayClient, config: PluginConfig) {
+    this.client = client;
+    this.timeoutMs = (config.sessionTimeoutMinutes ?? 120) * 60_000;
+  }
+
+  async resolve(requestCtx: RequestContext): Promise<SessionEntry> {
+    const key = requestCtx.sessionKey;
+    const cached = this.cache.get(key);
+    if (cached && !this.isStale(cached)) {
+      cached.lastActivityAt = Date.now();
+      return cached;
+    }
+    const inflight = this.pending.get(key);
+    if (inflight) return inflight;
+    const promise = this.createSession(requestCtx);
+    this.pending.set(key, promise);
+    try {
+      const entry = await promise;
+      this.cache.set(key, entry);
+      if (this.cache.size > MAX_CACHE_SIZE) {
+        // Evict the entry with the oldest lastActivityAt
+        let oldestKey: string | undefined;
+        let oldestTime = Infinity;
+        for (const [k, e] of this.cache) {
+          if (e.lastActivityAt < oldestTime) {
+            oldestTime = e.lastActivityAt;
+            oldestKey = k;
+          }
+        }
+        if (oldestKey !== undefined) {
+          this.cache.delete(oldestKey);
+        }
+      }
+      return entry;
+    } finally {
+      this.pending.delete(key);
+    }
+  }
+
+  private async createSession(ctx: RequestContext): Promise<SessionEntry> {
+    const result = await this.client.getOrCreateSession(
+      ctx.sessionKey,
+      ctx.agentId ?? undefined,
+      undefined,
+      undefined,
+      { namespace: ctx.namespace },
+    );
+    return {
+      sessionId: result.id,
+      externalId: ctx.sessionKey,
+      createdAt: Date.now(),
+      lastActivityAt: Date.now(),
+    };
+  }
+
+  private isStale(entry: SessionEntry): boolean {
+    return (Date.now() - entry.lastActivityAt) > this.timeoutMs;
+  }
+
+  async endSession(key: string, summary?: string): Promise<void> {
+    const entry = this.cache.get(key);
+    if (entry) {
+      await this.client.endSession(entry.sessionId, summary);
+      this.cache.delete(key);
+    }
+  }
+
+  async cleanupStale(): Promise<void> {
+    for (const [key, entry] of this.cache) {
+      if (this.isStale(entry)) {
+        await this.endSession(key).catch(() => {});
+      }
+    }
+  }
+}

package/src/filters/content-patterns.ts

@@ -0,0 +1,32 @@
+// src/filters/content-patterns.ts
+
+const STRIP_PATTERNS = [
+  { pattern: () => /<memoryrelay-workflow>[\s\S]*?<\/memoryrelay-workflow>/g, name: "workflow-blocks" },
+  { pattern: () => /<relevant-memories>[\s\S]*?<\/relevant-memories>/g, name: "recall-blocks" },
+  { pattern: () => /<compaction-summary>[\s\S]*?<\/compaction-summary>/g, name: "compaction-blocks" },
+  { pattern: () => /<system-reminder>[\s\S]*?<\/system-reminder>/g, name: "system-reminders" },
+  { pattern: () => /\[(?:image|file|attachment):.*?\]/g, name: "media-refs" },
+  { pattern: () => /```[\s\S]{500,}?```/g, name: "large-code-blocks" },
+];
+
+export function stripContent(content: string): string {
+  let result = content;
+  for (const { pattern } of STRIP_PATTERNS) {
+    result = result.replace(pattern(), "");
+  }
+  result = result.replace(/\n{3,}/g, "\n\n").trim();
+  return result;
+}
+
+export const LONG_TERM_SIGNALS = [
+  /(?:always|never|prefer|don't like|my name is|i work at)/i,
+  /(?:remember|important|note that|keep in mind)/i,
+  /(?:api key|endpoint|server|credentials|config)/i,
+  /(?:decision|chose|decided|agreed|approved)/i,
+  /(?:pattern|convention|standard|rule)/i,
+];
+
+export function resolveScope(content: string): "session" | "long-term" {
+  if (LONG_TERM_SIGNALS.some(p => p.test(content))) return "long-term";
+  return "session";
+}

package/src/filters/noise-patterns.ts

@@ -0,0 +1,33 @@
+import type { ConversationMessage } from "../pipelines/types.js";
+
+const DROP_PATTERNS = {
+  systemTriggers: /^(HEARTBEAT_OK|NO_REPLY|HEALTH_CHECK|PING)$/,
+  timestamps: /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/,
+  acks: /^(ok|okay|sure|done|yes|no|thanks|thank you|got it|right|yep|nope|k|ty|thx|np|ack|fine|cool|great|perfect)\.?$/i,
+  routingBlocks: /^<(?:system-reminder|routing|metadata|tool-result)>/,
+  bareToolCalls: /^<tool_call>[\s\S]*<\/tool_call>$/,
+  compactionLogs: /^<compaction-audit>/,
+};
+
+export function shouldDropMessage(message: ConversationMessage): boolean {
+  const text = message.content.trim();
+  if (text.length < 10) return true;
+  return Object.values(DROP_PATTERNS).some(p => p.test(text));
+}
+
+const BOILERPLATE_SIGNALS = [
+  /^(I see|I understand|Got it|Sure|Let me|I'll|I can|Here's what)/i,
+  /how can I help/i,
+  /let me know if/i,
+  /is there anything else/i,
+  /happy to help/i,
+];
+
+export function isAssistantBoilerplate(message: ConversationMessage): boolean {
+  if (message.role !== "assistant") return false;
+  const text = message.content.trim();
+  if (text.length > 300) return false;
+  const signalCount = BOILERPLATE_SIGNALS.filter(p => p.test(text)).length;
+  const density = signalCount / (text.length / 100);
+  return density > 1.5;
+}

package/src/filters/non-interactive.ts

@@ -0,0 +1,30 @@
+// src/filters/non-interactive.ts
+
+export interface TriggerSignals {
+  trigger: string | null;
+  sessionKey: string;
+  prompt: string;
+}
+
+const NON_INTERACTIVE_TRIGGERS = new Set([
+  "cron", "heartbeat", "schedule", "automation", "health_check",
+]);
+
+const NON_INTERACTIVE_SESSION_PATTERNS = [
+  /:cron:/,
+  /:heartbeat:/,
+  /:schedule:/,
+  /:automation:/,
+];
+
+const EMPTY_PROMPTS = new Set([
+  "HEARTBEAT_OK", "NO_REPLY", "HEALTH_CHECK", "PING",
+]);
+
+export function isNonInteractive(signals: TriggerSignals): boolean {
+  if (signals.trigger && NON_INTERACTIVE_TRIGGERS.has(signals.trigger)) return true;
+  if (NON_INTERACTIVE_SESSION_PATTERNS.some(p => p.test(signals.sessionKey))) return true;
+  if (!signals.prompt || signals.prompt.length < 5) return true;
+  if (EMPTY_PROMPTS.has(signals.prompt)) return true;
+  return false;
+}

package/src/hooks/activity.ts

@@ -0,0 +1,51 @@
+// src/hooks/activity.ts
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { SessionResolver } from "../context/session-resolver.js";
+
+export interface DebugLoggerLike {
+  log(entry: {
+    timestamp: string;
+    tool: string;
+    method: string;
+    path: string;
+    duration: number;
+    status: string;
+    error?: unknown;
+  }): void;
+}
+
+export function registerActivityHooks(
+  api: OpenClawPluginApi,
+  sessionResolver: SessionResolver,
+  debugLogger?: DebugLoggerLike,
+): void {
+  // Tool observation: no-op, registered for future extensibility
+  api.on("before_tool_call", (_event, _ctx) => {
+    // Reserved for future: tool blocking, param injection, audit
+  });
+
+  // Tool observation: update session activity + log metrics
+  api.on("after_tool_call", (event, _ctx) => {
+    // Log to debug logger if enabled
+    if (debugLogger) {
+      debugLogger.log({
+        timestamp: new Date().toISOString(),
+        tool: event.toolName,
+        method: "tool_call",
+        path: "",
+        duration: event.durationMs || 0,
+        status: event.error ? "error" : "success",
+        error: event.error,
+      });
+    }
+  });
+
+  // Message processing hooks: activity tracking
+  api.on("message_received", (_event, _ctx) => {
+    // Activity tracking handled by session resolver
+  });
+
+  api.on("message_sending", (_event, _ctx) => {
+    // No-op: registered for future extensibility
+  });
+}

package/src/hooks/agent-end.ts

@@ -0,0 +1,48 @@
+// src/hooks/agent-end.ts
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { PluginConfig, MemoryRelayClient, ConversationMessage, SessionResolverLike } from "../pipelines/types.js";
+import { buildRequestContext } from "../context/request-context.js";
+import { runPipeline } from "../pipelines/runner.js";
+import { capturePipeline } from "../pipelines/capture/index.js";
+
+export function registerAgentEnd(
+  api: OpenClawPluginApi,
+  config: PluginConfig,
+  client: MemoryRelayClient,
+  sessionResolver?: SessionResolverLike,
+): void {
+  if (!config.autoCapture?.enabled) return;
+
+  api.on("agent_end", async (event) => {
+    if (!event.success || !event.messages || event.messages.length === 0) return;
+
+    try {
+      const messages: ConversationMessage[] = [];
+      for (const msg of event.messages) {
+        if (!msg || typeof msg !== "object") continue;
+        const msgObj = msg as Record<string, unknown>;
+        const role = msgObj.role as string;
+        if (role !== "user" && role !== "assistant") continue;
+
+        const content = msgObj.content;
+        if (typeof content === "string") {
+          messages.push({ role: role as "user" | "assistant", content });
+        } else if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block && typeof block === "object" && (block as any).type === "text" && (block as any).text) {
+              messages.push({ role: role as "user" | "assistant", content: (block as any).text });
+            }
+          }
+        }
+      }
+
+      if (messages.length === 0) return;
+
+      const requestCtx = buildRequestContext(event, config);
+      const pipelineCtx = { requestCtx, config, client, sessionResolver };
+      await runPipeline(capturePipeline, { messages }, pipelineCtx);
+    } catch (err) {
+      api.logger.warn?.(`memory-memoryrelay: capture failed: ${String(err)}`);
+    }
+  });
+}

package/src/hooks/before-agent-start.ts

@@ -0,0 +1,109 @@
+// src/hooks/before-agent-start.ts
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { PluginConfig } from "../pipelines/types.js";
+
+export function registerBeforeAgentStart(
+  api: OpenClawPluginApi,
+  config: PluginConfig,
+  isToolEnabled: (name: string) => boolean,
+  defaultProject: string | undefined,
+): void {
+  api.on("before_agent_start", async (event) => {
+    if (!event.prompt || event.prompt.length < 10) {
+      return;
+    }
+
+    // Check if current channel is excluded
+    if (config?.excludeChannels && event.channel) {
+      const channelId = String(event.channel);
+      if (config.excludeChannels.some((excluded) => channelId.includes(excluded))) {
+        api.logger.debug?.(
+          `memory-memoryrelay: skipping for excluded channel: ${channelId}`,
+        );
+        return;
+      }
+    }
+
+    // Build workflow instructions dynamically based on enabled tools
+    const lines: string[] = [
+      "You have MemoryRelay tools available for persistent memory across sessions.",
+    ];
+
+    if (defaultProject) {
+      lines.push(`Default project: \`${defaultProject}\` (auto-applied when you omit the project parameter).`);
+    }
+
+    lines.push("", "## Recommended Workflow", "");
+
+    // Starting work section — only include steps for enabled tools
+    const startSteps: string[] = [];
+    if (isToolEnabled("project_context")) {
+      startSteps.push(`**Load context**: Call \`project_context(${defaultProject ? `"${defaultProject}"` : "project"})\` to load hot-tier memories, active decisions, and adopted patterns`);
+    }
+    if (isToolEnabled("session_start")) {
+      startSteps.push(`**Start session**: Call \`session_start(title${defaultProject ? "" : ", project"})\` to begin tracking your work`);
+    }
+    if (isToolEnabled("decision_check")) {
+      startSteps.push(`**Check decisions**: Call \`decision_check(query${defaultProject ? "" : ", project"})\` before making architectural choices`);
+    }
+    if (isToolEnabled("pattern_search")) {
+      startSteps.push("**Find patterns**: Call `pattern_search(query)` to find established conventions before writing code");
+    }
+
+    if (startSteps.length > 0) {
+      lines.push("When starting work on a project:");
+      startSteps.forEach((step, i) => lines.push(`${i + 1}. ${step}`));
+      lines.push("");
+    }
+
+    // While working section
+    const workSteps: string[] = [];
+    if (isToolEnabled("memory_store")) {
+      workSteps.push("**Store findings**: Call `memory_store(content, metadata)` for important information worth remembering");
+    }
+    if (isToolEnabled("decision_record")) {
+      workSteps.push(`**Record decisions**: Call \`decision_record(title, rationale${defaultProject ? "" : ", project"})\` when making significant architectural choices`);
+    }
+    if (isToolEnabled("pattern_create")) {
+      workSteps.push("**Create patterns**: Call `pattern_create(title, description)` when establishing reusable conventions");
+    }
+
+    if (workSteps.length > 0) {
+      lines.push("While working:");
+      const offset = startSteps.length;
+      workSteps.forEach((step, i) => lines.push(`${offset + i + 1}. ${step}`));
+      lines.push("");
+    }
+
+    // When done section
+    if (isToolEnabled("session_end")) {
+      const offset = startSteps.length + workSteps.length;
+      lines.push("When done:");
+      lines.push(`${offset + 1}. **End session**: Call \`session_end(session_id, summary)\` with a summary of what was accomplished`);
+      lines.push("");
+    }
+
+    // First-time setup — only if project tools are enabled
+    if (isToolEnabled("project_register")) {
+      lines.push("## First-Time Setup", "");
+      lines.push("If the project is not yet registered, start with:");
+      lines.push("1. `project_register(slug, name, description, stack)` to register the project");
+      lines.push("2. Then follow the workflow above");
+      lines.push("");
+      if (isToolEnabled("project_list")) {
+        lines.push("Use `project_list()` to see existing projects before registering a new one.");
+      }
+    }
+
+    // Memory-only fallback — if no session/decision/project tools are enabled
+    if (startSteps.length === 0 && workSteps.length === 0) {
+      lines.push("Use `memory_store(content)` to save important information and `memory_recall(query)` to find relevant memories.");
+    }
+
+    const workflowInstructions = lines.join("\n");
+
+    const prependContext = `<memoryrelay-workflow>\n${workflowInstructions}\n</memoryrelay-workflow>`;
+
+    return { prependContext };
+  });
+}

package/src/hooks/before-prompt-build.ts

@@ -0,0 +1,46 @@
+// src/hooks/before-prompt-build.ts
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { PluginConfig, MemoryRelayClient, SessionResolverLike } from "../pipelines/types.js";
+import { buildRequestContext } from "../context/request-context.js";
+import { runPipeline } from "../pipelines/runner.js";
+import { recallPipeline } from "../pipelines/recall/index.js";
+
+export function registerBeforePromptBuild(
+  api: OpenClawPluginApi,
+  config: PluginConfig,
+  client: MemoryRelayClient,
+  sessionResolver?: SessionResolverLike,
+): void {
+  api.on("before_prompt_build", async (event) => {
+    if (!config.autoRecall) return;
+
+    if (!event.prompt || event.prompt.length < 10) return;
+
+    // Check if current channel is excluded
+    if (config.excludeChannels && event.channel) {
+      const channelId = String(event.channel);
+      if (config.excludeChannels.some((excluded: string) => channelId.includes(excluded))) {
+        api.logger.debug?.(
+          `memory-memoryrelay: skipping recall for excluded channel: ${channelId}`,
+        );
+        return;
+      }
+    }
+
+    try {
+      const requestCtx = buildRequestContext(event, config);
+      const pipelineCtx = { requestCtx, config, client, sessionResolver };
+      const result = await runPipeline(recallPipeline, {
+        prompt: requestCtx.prompt, memories: [], scope: "all" as const,
+      }, pipelineCtx);
+
+      if (!result || !result.formatted) return;
+
+      api.logger.info?.(`memory-memoryrelay: injecting memories into context`);
+
+      return { prependContext: result.formatted };
+    } catch (err) {
+      api.logger.warn?.(`memory-memoryrelay: recall failed: ${String(err)}`);
+    }
+  });
+}

package/src/hooks/compaction.ts

@@ -0,0 +1,51 @@
+// src/hooks/compaction.ts
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { MemoryRelayClient } from "../pipelines/types.js";
+
+export function registerCompactionHooks(
+  api: OpenClawPluginApi,
+  client: MemoryRelayClient,
+  agentId: string,
+  blocklist: string[],
+  extractRescueContent: (messages: unknown[], blocklist: string[]) => string[],
+): void {
+  // Compaction rescue: save key context before it's lost
+  api.on("before_compaction", async (event, _ctx) => {
+    if (!event.messages || event.messages.length === 0) return;
+    try {
+      const rescued = extractRescueContent(event.messages, blocklist);
+      for (const content of rescued) {
+        await client.store(content, {
+          category: "compaction-rescue",
+          source: "auto-compaction",
+          agent: agentId,
+        });
+      }
+      if (rescued.length > 0) {
+        api.logger.info?.(`memory-memoryrelay: rescued ${rescued.length} memories before compaction`);
+      }
+    } catch (err) {
+      api.logger.warn?.(`memory-memoryrelay: compaction rescue failed: ${String(err)}`);
+    }
+  });
+
+  // Session reset rescue: save key context before session is cleared
+  api.on("before_reset", async (event, _ctx) => {
+    if (!event.messages || event.messages.length === 0) return;
+    try {
+      const rescued = extractRescueContent(event.messages, blocklist);
+      for (const content of rescued) {
+        await client.store(content, {
+          category: "session-reset-rescue",
+          source: "auto-reset",
+          agent: agentId,
+        });
+      }
+      if (rescued.length > 0) {
+        api.logger.info?.(`memory-memoryrelay: rescued ${rescued.length} memories before reset`);
+      }
+    } catch (err) {
+      api.logger.warn?.(`memory-memoryrelay: reset rescue failed: ${String(err)}`);
+    }
+  });
+}

package/src/hooks/privacy.ts

@@ -0,0 +1,44 @@
+// src/hooks/privacy.ts
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+
+export function registerPrivacyHooks(
+  api: OpenClawPluginApi,
+  blocklist: string[],
+  isBlocklisted: (content: string, blocklist: string[]) => boolean,
+  redactSensitive: (content: string, blocklist: string[]) => string,
+): void {
+  api.on("before_message_write", (event, _ctx) => {
+    if (blocklist.length === 0) return;
+
+    const msg = event.message;
+    if (!msg || typeof msg !== "object") return;
+
+    const m = msg as Record<string, unknown>;
+    if (typeof m.content === "string" && isBlocklisted(m.content, blocklist)) {
+      return {
+        message: {
+          ...msg,
+          content: redactSensitive(m.content as string, blocklist),
+        } as typeof msg,
+      };
+    }
+  });
+
+  // Tool result redaction: apply privacy blocklist before persistence
+  api.on("tool_result_persist", (event, _ctx) => {
+    if (blocklist.length === 0) return;
+
+    const msg = event.message;
+    if (!msg || typeof msg !== "object") return;
+
+    const m = msg as Record<string, unknown>;
+    if (typeof m.content === "string" && isBlocklisted(m.content, blocklist)) {
+      return {
+        message: {
+          ...msg,
+          content: redactSensitive(m.content as string, blocklist),
+        } as typeof msg,
+      };
+    }
+  });
+}

package/src/hooks/session-lifecycle.ts

@@ -0,0 +1,47 @@
+// src/hooks/session-lifecycle.ts
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import type { PluginConfig, MemoryRelayClient } from "../pipelines/types.js";
+import type { SessionResolver } from "../context/session-resolver.js";
+
+export function registerSessionLifecycle(
+  api: OpenClawPluginApi,
+  config: PluginConfig,
+  client: MemoryRelayClient,
+  agentId: string,
+  defaultProject: string | undefined,
+  sessionResolver: SessionResolver,
+): void {
+  // Session sync: auto-create MemoryRelay session when OpenClaw session starts
+  api.on("session_start", async (event, _ctx) => {
+    try {
+      const externalId = event.sessionKey || event.sessionId;
+      if (!externalId) return;
+
+      const response = await client.getOrCreateSession(
+        externalId,
+        agentId,
+        `OpenClaw session ${externalId}`,
+        defaultProject || undefined,
+        { source: "openclaw-plugin", agent: agentId, trigger: "session_start_hook" },
+      );
+
+      api.logger.debug?.(`memory-memoryrelay: auto-created session ${response.id} for OpenClaw session ${externalId}`);
+    } catch (err) {
+      api.logger.warn?.(`memory-memoryrelay: session_start hook failed: ${String(err)}`);
+    }
+  });
+
+  // Session sync: auto-end MemoryRelay session when OpenClaw session ends
+  api.on("session_end", async (event, _ctx) => {
+    try {
+      const externalId = event.sessionKey || event.sessionId;
+      if (!externalId) return;
+
+      await sessionResolver.endSession(externalId, `Session ended after ${event.messageCount} messages`);
+
+      api.logger.debug?.(`memory-memoryrelay: auto-ended session for ${externalId}`);
+    } catch (err) {
+      api.logger.warn?.(`memory-memoryrelay: session_end hook failed: ${String(err)}`);
+    }
+  });
+}