talon-agent 1.39.0 → 1.40.1

package/README.md

@@ -184,7 +184,22 @@ GitHub API access via the official GitHub MCP server. Gives the agent access to
 
 The token is optional --- defaults to the output of `gh auth token` if the GitHub CLI is authenticated.
 
-### MemPalace
+### Long-term Memory
+
+Talon supports two long-term memory backends, selected via the unified `memory` section:
+
+```json
+{
+  "memory": {
+    "enabled": true,
+    "backend": "mempalace"
+  }
+}
+```
+
+Set `"backend"` to `"mempalace"` (local, vector search + knowledge graph) or `"mem0"` ([mem0](https://github.com/mem0ai/mem0) hosted platform or self-hosted server). Backend-specific settings go in a matching `memory.mempalace` / `memory.mem0` sub-object. The legacy top-level `mempalace` section is still honored when `memory` is absent.
+
+#### MemPalace backend
 
 Structured long-term memory with vector search. The agent can store, search, and retrieve memories semantically. Integrates with Dream mode for automatic memory consolidation and personal diary entries.
 
@@ -199,16 +214,40 @@ python -m venv ~/.talon/mempalace-venv
 
 ```json
 {
-  "mempalace": {
+  "memory": {
     "enabled": true,
-    "palacePath": "~/.talon/workspace/palace",
-    "pythonPath": "~/.talon/mempalace-venv/bin/python"
+    "backend": "mempalace",
+    "mempalace": {
+      "palacePath": "~/.talon/workspace/palace",
+      "pythonPath": "~/.talon/mempalace-venv/bin/python"
+    }
   }
 }
 ```
 
 Both paths are optional --- defaults to `~/.talon/workspace/palace/` and the venv Python respectively.
 
+#### mem0 backend
+
+Long-term memory via [mem0](https://mem0.ai) --- mem0 extracts durable facts from what the agent stores and retrieves them by semantic search. Works against the hosted platform (API key) or a self-hosted mem0 server.
+
+**Requirements:** None --- the `mem0ai` SDK is bundled with Talon.
+
+```json
+{
+  "memory": {
+    "enabled": true,
+    "backend": "mem0",
+    "mem0": {
+      "apiKey": "m0-...",
+      "userId": "talon"
+    }
+  }
+}
+```
+
+`apiKey` defaults to the `MEM0_API_KEY` env var. For a self-hosted server set `"host"` instead --- the key is then optional. `userId` is the entity id memories are filed under (default `"talon"`).
+
 ### Playwright
 
 Headless browser automation via the Playwright MCP server. The agent can browse websites, take screenshots, generate PDFs, fill forms, and scrape content.
@@ -320,7 +359,8 @@ Config file: `~/.talon/config.json`
 | `allowedUsers`             | ---          | Whitelist of Telegram user IDs                                                                                          |
 | `apiId` / `apiHash`        | ---          | Telegram API credentials for full message history                                                                       |
 | `github`                   | ---          | GitHub plugin config (see above)                                                                                        |
-| `mempalace`                | ---          | MemPalace plugin config (see above)                                                                                     |
+| `memory`                   | ---          | Long-term memory backend selection: `mempalace` or `mem0` (see above)                                                   |
+| `mempalace`                | ---          | Legacy MemPalace plugin config (prefer `memory`)                                                                        |
 | `playwright`               | ---          | Playwright plugin config (see above)                                                                                    |
 
 ---

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "1.39.0",
+  "version": "1.40.1",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",
@@ -113,6 +113,7 @@
     "grammy": "^1.42.0",
     "liquidjs": "^10.27.0",
     "marked": "^18.0.0",
+    "mem0ai": "^3.0.13",
     "p-retry": "^8.0.0",
     "picocolors": "^1.1.1",
     "pino": "^10.3.1",

package/prompts/mem0.md

@@ -0,0 +1,18 @@
+# mem0 — Long-term Memory
+
+You have access to mem0 long-term memory via MCP tools. mem0 extracts durable facts from what you store and retrieves them by semantic search. All memories are filed under the entity id `{{userId}}`.
+
+### Protocol — FOLLOW EVERY SESSION
+
+1. **BEFORE RESPONDING** about any person, project, or past event: call `mem0_search_memory` FIRST. Never guess — verify from memory.
+2. **IF UNSURE** about a fact (name, age, relationship, preference): search memory. Wrong is worse than slow.
+3. **WHEN FACTS CHANGE**: store the new fact with `mem0_add_memory` (mem0 supersedes contradicted memories itself); delete plainly wrong entries with `mem0_delete_memory`.
+4. **AFTER LEARNING** something important: store it with `mem0_add_memory`. Pass natural conversational text — mem0 extracts the durable facts.
+
+### Tools
+
+- `mem0_search_memory` — Semantic search. Short keyword queries, not full sentences. Optional `limit`, `threshold`.
+- `mem0_add_memory` — Store information. `role` marks who it came from; optional `metadata` tags.
+- `mem0_list_memories` — Paginated browse for inventory/cleanup, not search.
+- `mem0_get_memory` — Fetch one memory by id with full content and metadata.
+- `mem0_delete_memory` — Remove a memory by id when it is wrong or stale.

package/src/bootstrap.ts

@@ -135,11 +135,12 @@ export async function bootstrap(
 ): Promise<BootstrapResult> {
   const config = loadConfig();
 
-  // Load plugins (external tool packages + built-in GitHub, MemPalace, Playwright)
+  // Load plugins (external tool packages + built-in GitHub, MemPalace, mem0, Playwright)
   const hasPlugins =
     config.plugins.length > 0 ||
     config.github?.enabled === true ||
     config.mempalace?.enabled === true ||
+    config.mem0?.enabled === true ||
     config.playwright?.enabled === true;
   if (hasPlugins) {
     const { loadPlugins, loadBuiltinPlugins, getPluginPromptAdditions } =
@@ -153,7 +154,7 @@ export async function bootstrap(
       await loadPlugins(config.plugins, frontends);
     }
 
-    // Built-in plugins (GitHub, MemPalace, Playwright) — shared with hot-reload
+    // Built-in plugins (GitHub, MemPalace, mem0, Playwright) — shared with hot-reload
     await loadBuiltinPlugins(config);
 
     rebuildSystemPrompt(config, getPluginPromptAdditions());

package/src/core/background/heartbeat/scheduler.ts

@@ -22,6 +22,65 @@ import { HeartbeatTimeoutError, runHeartbeatAgent } from "./agent.js";
 const STARTUP_DELAY_MS = 5 * 60 * 1000; // 5-minute delay before first run
 const DUE_CHECK_INTERVAL_MS = 60 * 1000;
 
+// Failure backoff. A failed run does NOT advance last_run, so without a
+// backoff the every-minute due check re-fires the heartbeat 60×/hour against
+// the same error (observed live: a session-limit night produced hundreds of
+// identical failures a minute apart). Generic failures back off
+// exponentially; session/rate-limit errors that state their own reset time
+// wait for it instead of guessing.
+const FAILURE_BACKOFF_BASE_MS = 5 * 60 * 1000;
+const FAILURE_BACKOFF_MAX_MS = 60 * 60 * 1000;
+/** Safety margin added past a parsed limit-reset time (clock skew, rollout). */
+const LIMIT_RESET_BUFFER_MS = 2 * 60 * 1000;
+
+/**
+ * Parse the reset wall-clock time out of a session/rate-limit error message,
+ * e.g. "You've hit your session limit · resets 12:20am (UTC)" or
+ * "… resets 3pm (UTC)". Returns the epoch ms of the NEXT occurrence of that
+ * UTC time after `now`, or null when the message doesn't carry one.
+ */
+export function parseSessionLimitResetMs(
+  message: string,
+  now: number,
+): number | null {
+  const m = /resets\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*\(UTC\)/i.exec(
+    message,
+  );
+  if (!m) return null;
+  const rawHour = Number(m[1]);
+  const minute = m[2] ? Number(m[2]) : 0;
+  if (rawHour < 1 || rawHour > 12 || minute > 59) return null;
+  let hour = rawHour % 12;
+  if (m[3].toLowerCase() === "pm") hour += 12;
+  const d = new Date(now);
+  d.setUTCHours(hour, minute, 0, 0);
+  let t = d.getTime();
+  if (t <= now) t += 24 * 60 * 60 * 1000;
+  return t;
+}
+
+/**
+ * When to next allow an auto heartbeat after the Nth consecutive failure
+ * (1-based). Limit errors with a stated reset time wait until then (+buffer);
+ * everything else doubles from 5min up to a 60min cap.
+ */
+export function failureBackoffUntil(
+  err: unknown,
+  consecutiveFailures: number,
+  now: number,
+): number {
+  const message = err instanceof Error ? err.message : String(err);
+  if (/session limit|rate limit/i.test(message)) {
+    const reset = parseSessionLimitResetMs(message, now);
+    if (reset !== null) return reset + LIMIT_RESET_BUFFER_MS;
+  }
+  const exp = Math.min(
+    FAILURE_BACKOFF_BASE_MS * 2 ** Math.max(0, consecutiveFailures - 1),
+    FAILURE_BACKOFF_MAX_MS,
+  );
+  return now + exp;
+}
+
 export function initHeartbeat(cfg: HeartbeatConfig): void {
   hb.config = cfg;
 }
@@ -69,6 +128,9 @@ export function startHeartbeatTimer(intervalMinutes: number): void {
  */
 function runIfDue(intervalMs: number, startup: boolean): void {
   if (hb.running) return;
+  // Inside a failure backoff window — stay quiet instead of re-firing the
+  // same error every due check. (Logged once, when the window was set.)
+  if (Date.now() < hb.backoffUntil) return;
   const lastRun = readHeartbeatState()?.last_run ?? 0;
   if (lastRun <= 0) {
     // Never ran on this install — fire now to establish the cadence.
@@ -178,6 +240,8 @@ async function executeHeartbeat(trigger: "auto" | "forced"): Promise<void> {
         status: "idle",
         run_count: previousRunCount + 1,
       });
+      hb.consecutiveFailures = 0;
+      hb.backoffUntil = 0;
       log(
         "heartbeat",
         `Heartbeat #${previousRunCount + 1} complete (${trigger}), log: ${heartbeatLogPath}`,
@@ -199,6 +263,22 @@ async function executeHeartbeat(trigger: "auto" | "forced"): Promise<void> {
         status: "idle",
         run_count: isTimeout ? previousRunCount + 1 : previousRunCount,
       });
+      // Timeouts advance last_run (budget consumed), so the cadence itself
+      // spaces the next attempt. Every other failure retries against the same
+      // last_run — back off so the due check doesn't hammer it every minute.
+      if (!isTimeout) {
+        hb.consecutiveFailures += 1;
+        hb.backoffUntil = failureBackoffUntil(
+          err,
+          hb.consecutiveFailures,
+          Date.now(),
+        );
+        logWarn(
+          "heartbeat",
+          `Backing off until ${new Date(hb.backoffUntil).toISOString()} ` +
+            `after ${hb.consecutiveFailures} consecutive failure(s)`,
+        );
+      }
       if (trigger === "forced") throw err;
     } finally {
       hb.running = false;

package/src/core/background/heartbeat/state.ts

@@ -71,6 +71,10 @@ export const hb: {
   intervalMinutesRef: number;
   config: HeartbeatConfig | null;
   logFileSequence: number;
+  /** Consecutive failed runs — drives the failure backoff curve. */
+  consecutiveFailures: number;
+  /** Epoch ms before which auto runs are suppressed after a failure. */
+  backoffUntil: number;
 } = {
   running: false,
   currentRunPromise: null,
@@ -79,6 +83,8 @@ export const hb: {
   intervalMinutesRef: 60,
   config: null,
   logFileSequence: 0,
+  consecutiveFailures: 0,
+  backoffUntil: 0,
 };
 
 // ── State-file I/O ───────────────────────────────────────────────────────────

package/src/core/memory/retrieval.ts

@@ -73,7 +73,9 @@ export function isAutoInjectTrusted(
 /**
  * Enforce the #373 trust policy on a retrieval result: drop every item that
  * is not explicitly auto-inject trusted. Adapters should call this as their
- * last step so the filter cannot be forgotten upstream of the prompt.
+ * last step, and the Weaver's `prefetchMemory` applies it again to whatever
+ * a retriever returns — a buggy adapter cannot leak low-trust items into
+ * the prompt.
  */
 export function filterAutoInjectable(
   memory: RetrievedMemory | undefined,

package/src/core/plugin/builtins.ts

@@ -1,5 +1,5 @@
 /**
- * Built-in plugin loading (GitHub / MemPalace / Playwright) + the hot-reload
+ * Built-in plugin loading (GitHub / MemPalace / mem0 / Playwright) + the hot-reload
  * path that re-reads config, tears down, and re-loads everything.
  */
 
@@ -13,7 +13,7 @@ import {
 } from "./loader.js";
 
 /**
- * Load built-in plugins (GitHub, MemPalace, Playwright) based on config flags.
+ * Load built-in plugins (GitHub, MemPalace, mem0, Playwright) based on config flags.
  * Shared by both bootstrap and hot-reload to avoid duplication.
  */
 export async function loadBuiltinPlugins(config: TalonConfig): Promise<void> {
@@ -75,6 +75,34 @@ export async function loadBuiltinPlugins(config: TalonConfig): Promise<void> {
     }
   }
 
+  const mem0 = config.mem0;
+  if (mem0?.enabled) {
+    try {
+      const { createMem0Plugin } = await import("../../plugins/mem0/index.js");
+      const m0 = createMem0Plugin({
+        apiKey: mem0.apiKey,
+        host: mem0.host,
+        userId: mem0.userId,
+      });
+      const m0Config = mem0 as unknown as Record<string, unknown>;
+      const loaded = registerPlugin(m0, m0Config);
+      if (loaded) {
+        await initPluginWithTimeout(
+          loaded.plugin,
+          loaded.config,
+          15_000,
+          "mem0 init",
+          "mem0 init",
+        );
+      }
+    } catch (err) {
+      logError(
+        "plugin",
+        `mem0 init: ${err instanceof Error ? err.message : err}`,
+      );
+    }
+  }
+
   const playwright = config.playwright;
   if (playwright?.enabled) {
     try {

package/src/core/prompt/embedded-prompts.ts

@@ -16,22 +16,23 @@ import asset2 from "../../../prompts/discord.md" with { type: "file" };
 import asset3 from "../../../prompts/dream.md" with { type: "file" };
 import asset4 from "../../../prompts/heartbeat.md" with { type: "file" };
 import asset5 from "../../../prompts/identity.md" with { type: "file" };
-import asset6 from "../../../prompts/mempalace.md" with { type: "file" };
-import asset7 from "../../../prompts/native.md" with { type: "file" };
-import asset8 from "../../../prompts/system/contract-text-or-tools.md" with { type: "file" };
-import asset9 from "../../../prompts/system/contract-text-preferred.md" with { type: "file" };
-import asset10 from "../../../prompts/system/contract-tool-only.md" with { type: "file" };
-import asset11 from "../../../prompts/system/cron.md" with { type: "file" };
-import asset12 from "../../../prompts/system/daily-memory.md" with { type: "file" };
-import asset13 from "../../../prompts/system/goals.md" with { type: "file" };
-import asset14 from "../../../prompts/system/heartbeat-agent.md" with { type: "file" };
-import asset15 from "../../../prompts/system/persistent-memory.md" with { type: "file" };
-import asset16 from "../../../prompts/system/skills.md" with { type: "file" };
-import asset17 from "../../../prompts/system/triggers.md" with { type: "file" };
-import asset18 from "../../../prompts/system/workspace.md" with { type: "file" };
-import asset19 from "../../../prompts/teams.md" with { type: "file" };
-import asset20 from "../../../prompts/telegram.md" with { type: "file" };
-import asset21 from "../../../prompts/terminal.md" with { type: "file" };
+import asset6 from "../../../prompts/mem0.md" with { type: "file" };
+import asset7 from "../../../prompts/mempalace.md" with { type: "file" };
+import asset8 from "../../../prompts/native.md" with { type: "file" };
+import asset9 from "../../../prompts/system/contract-text-or-tools.md" with { type: "file" };
+import asset10 from "../../../prompts/system/contract-text-preferred.md" with { type: "file" };
+import asset11 from "../../../prompts/system/contract-tool-only.md" with { type: "file" };
+import asset12 from "../../../prompts/system/cron.md" with { type: "file" };
+import asset13 from "../../../prompts/system/daily-memory.md" with { type: "file" };
+import asset14 from "../../../prompts/system/goals.md" with { type: "file" };
+import asset15 from "../../../prompts/system/heartbeat-agent.md" with { type: "file" };
+import asset16 from "../../../prompts/system/persistent-memory.md" with { type: "file" };
+import asset17 from "../../../prompts/system/skills.md" with { type: "file" };
+import asset18 from "../../../prompts/system/triggers.md" with { type: "file" };
+import asset19 from "../../../prompts/system/workspace.md" with { type: "file" };
+import asset20 from "../../../prompts/teams.md" with { type: "file" };
+import asset21 from "../../../prompts/telegram.md" with { type: "file" };
+import asset22 from "../../../prompts/terminal.md" with { type: "file" };
 
 /** rel path (posix, under prompts/) → embedded file path (/$bunfs/… when compiled). */
 const ASSETS: Record<string, string> = {
@@ -41,22 +42,23 @@ const ASSETS: Record<string, string> = {
   "dream.md": asset3,
   "heartbeat.md": asset4,
   "identity.md": asset5,
-  "mempalace.md": asset6,
-  "native.md": asset7,
-  "system/contract-text-or-tools.md": asset8,
-  "system/contract-text-preferred.md": asset9,
-  "system/contract-tool-only.md": asset10,
-  "system/cron.md": asset11,
-  "system/daily-memory.md": asset12,
-  "system/goals.md": asset13,
-  "system/heartbeat-agent.md": asset14,
-  "system/persistent-memory.md": asset15,
-  "system/skills.md": asset16,
-  "system/triggers.md": asset17,
-  "system/workspace.md": asset18,
-  "teams.md": asset19,
-  "telegram.md": asset20,
-  "terminal.md": asset21,
+  "mem0.md": asset6,
+  "mempalace.md": asset7,
+  "native.md": asset8,
+  "system/contract-text-or-tools.md": asset9,
+  "system/contract-text-preferred.md": asset10,
+  "system/contract-tool-only.md": asset11,
+  "system/cron.md": asset12,
+  "system/daily-memory.md": asset13,
+  "system/goals.md": asset14,
+  "system/heartbeat-agent.md": asset15,
+  "system/persistent-memory.md": asset16,
+  "system/skills.md": asset17,
+  "system/triggers.md": asset18,
+  "system/workspace.md": asset19,
+  "teams.md": asset20,
+  "telegram.md": asset21,
+  "terminal.md": asset22,
 };
 
 /** Read an embedded prompt by its rel path (e.g. "system/cron.md"). */

package/src/core/weaver/memory-prefetch.ts

@@ -3,10 +3,16 @@
  * for live user messages, strictly fail-closed: a broken palace must
  * never block chat delivery. The result is dynamic turn context passed
  * through ChatRunParams; it never touches the frozen prompt.
+ *
+ * The #373 trust policy is enforced HERE, not just in adapters: whatever a
+ * retriever returns is passed through `filterAutoInjectable` before it can
+ * reach the prompt, so a buggy or future adapter cannot leak `user_claim` /
+ * `group_chat` items into auto-injection.
  */
 
 import type { RetrievedMemory } from "../agent-runtime/capabilities.js";
 import type { MemoryRetriever } from "../memory/retrieval.js";
+import { filterAutoInjectable } from "../memory/retrieval.js";
 import { logDebug, logWarn } from "../../util/log.js";
 
 export type PrefetchMemoryInput = {
@@ -23,13 +29,23 @@ export async function prefetchMemory(
   input: PrefetchMemoryInput,
 ): Promise<RetrievedMemory | undefined> {
   try {
-    const retrieved = await retrieve({
+    const raw = await retrieve({
       runKind: "chat",
       chatId: input.chatId,
       text: input.text,
       senderName: input.senderName,
       isGroup: input.isGroup,
     });
+    const retrieved = filterAutoInjectable(raw);
+    const droppedCount =
+      (raw?.items.length ?? 0) - (retrieved?.items.length ?? 0);
+    if (droppedCount > 0) {
+      logWarn(
+        "dispatcher",
+        `[${input.reqId}] memory pre-retrieval: dropped ${droppedCount} ` +
+          `low-trust item(s) the retriever failed to filter (#373)`,
+      );
+    }
     if (retrieved) {
       logDebug(
         "dispatcher",

package/src/frontend/discord/actions/messaging.ts

@@ -208,9 +208,12 @@ export const messagingHandlers: DiscordActionHandlers = {
 
   schedule_message: (body, chatId, { client, scheduledMessages }) => {
     const text = String(body.text ?? "");
+    // NaN (e.g. delay_seconds: "5m") must fall back to the default, not
+    // propagate: setTimeout(fn, NaN) fires immediately.
+    const requested = Number(body.delay_seconds ?? 60);
     const delaySec = Math.max(
       1,
-      Math.min(MAX_DELAY_SEC, Number(body.delay_seconds ?? 60)),
+      Math.min(MAX_DELAY_SEC, Number.isFinite(requested) ? requested : 60),
     );
     const entry: ScheduledMessage = {
       id: `sched_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,

package/src/frontend/discord/admin.ts

@@ -13,6 +13,7 @@ import type { TalonConfig } from "../../util/config.js";
 import type { Gateway } from "../../core/engine/gateway.js";
 import { resetSession, getAllSessions } from "../../storage/sessions.js";
 import { clearHistory } from "../../storage/history.js";
+import { todayLogDate } from "../../storage/daily-log.js";
 import { getChatSettings } from "../../storage/chat-settings.js";
 import {
   getAllCronJobs,
@@ -165,7 +166,7 @@ export async function handleAdminSubcommand(
     }
 
     case "daily": {
-      const today = new Date().toISOString().slice(0, 10);
+      const today = todayLogDate();
       const logPath = `${dirs.logs}/${today}.md`;
       try {
         const content = readFileSync(logPath, "utf-8");

package/src/frontend/telegram/actions/messaging.ts

@@ -243,9 +243,12 @@ export const messagingHandlers: TelegramActionHandlers = {
     const text = String(body.text ?? "");
     const replyTo = toPositiveId(body.reply_to_message_id);
     const rows = body.rows as ScheduledMessage["rows"];
+    // NaN (e.g. delay_seconds: "5m") must fall back to the default, not
+    // propagate: setTimeout(fn, NaN) fires immediately.
+    const requested = Number(body.delay_seconds ?? 60);
     const delaySec = Math.max(
       1,
-      Math.min(MAX_DELAY_SEC, Number(body.delay_seconds ?? 60)),
+      Math.min(MAX_DELAY_SEC, Number.isFinite(requested) ? requested : 60),
     );
     const entry: ScheduledMessage = {
       id: `sched_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,

package/src/frontend/telegram/admin.ts

@@ -10,6 +10,7 @@ import { tailFile } from "../../util/tail-file.js";
 import { escapeHtml } from "./formatting.js";
 import { resetSession, getAllSessions } from "../../storage/sessions.js";
 import { clearHistory } from "../../storage/history.js";
+import { todayLogDate } from "../../storage/daily-log.js";
 import { getChatSettings } from "../../storage/chat-settings.js";
 import {
   getAllCronJobs,
@@ -221,7 +222,7 @@ export async function handleAdminCommand(
     }
 
     case "daily": {
-      const today = new Date().toISOString().slice(0, 10);
+      const today = todayLogDate();
       const logPath = `${dirs.logs}/${today}.md`;
       try {
         const content = readFileSync(logPath, "utf-8");

package/src/plugins/mem0/index.ts

@@ -0,0 +1,88 @@
+/**
+ * mem0 plugin — long-term memory via the mem0 platform (https://mem0.ai).
+ *
+ * Registers a stdio MCP server (server.ts) bridging the `mem0ai` SDK,
+ * giving the agent semantic memory add/search/list/get/delete. Works
+ * against the hosted platform (API key) or a self-hosted mem0 server
+ * (host URL).
+ *
+ * Preferred configuration in ~/.talon/config.json:
+ *   "memory": {
+ *     "enabled": true,
+ *     "backend": "mem0",
+ *     "mem0": {
+ *       "apiKey": "m0-...",              // default: MEM0_API_KEY env var
+ *       "host": "http://localhost:8888", // optional self-hosted server
+ *       "userId": "talon"                // optional entity id (default "talon")
+ *     }
+ *   }
+ */
+
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { TalonPlugin } from "../../core/plugin/index.js";
+import { log, logWarn } from "../../util/log.js";
+import { dirs } from "../../util/paths.js";
+
+/** Load from ~/.talon/prompts/ (user-customisable, seeded on first run) */
+const PROMPT_PATH = resolve(dirs.prompts, "mem0.md");
+
+const SERVER_PATH = fileURLToPath(new URL("./server.ts", import.meta.url));
+
+export function createMem0Plugin(config: {
+  /** Platform API key. Falls back to the MEM0_API_KEY env var. */
+  apiKey?: string;
+  /** Self-hosted mem0 server URL; when set, apiKey may be omitted. */
+  host?: string;
+  /** Entity id memories are filed under (default "talon"). */
+  userId?: string;
+}): TalonPlugin {
+  const apiKey = config.apiKey?.trim() || process.env.MEM0_API_KEY?.trim();
+  const host = config.host?.trim();
+  const userId = config.userId?.trim() || "talon";
+
+  return {
+    name: "mem0",
+    description: "mem0 — long-term memory layer (hosted or self-hosted)",
+    version: "1.0.0",
+
+    mcpServerPath: SERVER_PATH,
+
+    validateConfig() {
+      if (!apiKey && !host) {
+        return [
+          'mem0 requires an API key ("memory.mem0.apiKey" or the MEM0_API_KEY env var) or a self-hosted "memory.mem0.host" URL.',
+        ];
+      }
+      return undefined;
+    },
+
+    init() {
+      log(
+        "mem0",
+        `Ready (${host ? `host: ${host}` : "hosted platform"}, user: ${userId})`,
+      );
+    },
+
+    getEnvVars() {
+      const env: Record<string, string> = { MEM0_USER_ID: userId };
+      if (apiKey) env.MEM0_API_KEY = apiKey;
+      if (host) env.MEM0_HOST = host;
+      return env;
+    },
+
+    getSystemPromptAddition() {
+      try {
+        const template = readFileSync(PROMPT_PATH, "utf-8");
+        return template.replace(/\{\{userId\}\}/g, userId);
+      } catch (err) {
+        logWarn(
+          "mem0",
+          `Failed to load prompt from ${PROMPT_PATH}: ${err instanceof Error ? err.message : err}`,
+        );
+        return `## mem0 — Long-term Memory\n\nMemory entity id: \`${userId}\``;
+      }
+    },
+  };
+}

package/src/plugins/mem0/server.ts

@@ -0,0 +1,180 @@
+/**
+ * mem0 MCP server — stdio subprocess spawned by the plugin loader.
+ *
+ * Thin bridge over the `mem0ai` MemoryClient (hosted platform or a
+ * self-hosted server via MEM0_HOST). All memories are scoped to one
+ * entity (MEM0_USER_ID) so the palace of a single Talon deployment
+ * stays isolated inside a shared mem0 project.
+ *
+ * Env contract (set by src/plugins/mem0/index.ts getEnvVars):
+ *   MEM0_API_KEY   — platform API key (required unless MEM0_HOST is set)
+ *   MEM0_HOST      — optional self-hosted API base URL
+ *   MEM0_USER_ID   — entity id memories are filed under (default "talon")
+ */
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import MemoryClient from "mem0ai";
+
+const apiKey = process.env.MEM0_API_KEY ?? "";
+const host = process.env.MEM0_HOST;
+const userId = process.env.MEM0_USER_ID || "talon";
+
+const client = new MemoryClient({ apiKey, ...(host ? { host } : {}) });
+
+/** v3 search/list scope every call to this deployment's entity. */
+const entityFilter = { AND: [{ user_id: userId }] };
+
+type ToolResult = {
+  content: Array<{ type: "text"; text: string }>;
+  isError?: boolean;
+};
+
+function textResult(value: unknown): ToolResult {
+  return {
+    content: [
+      {
+        type: "text",
+        text: typeof value === "string" ? value : JSON.stringify(value),
+      },
+    ],
+  };
+}
+
+function errorResult(err: unknown): ToolResult {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `mem0 error: ${err instanceof Error ? err.message : String(err)}`,
+      },
+    ],
+    isError: true,
+  };
+}
+
+const server = new McpServer({ name: "mem0-tools", version: "1.0.0" });
+
+server.tool(
+  "mem0_add_memory",
+  "Store new information in mem0 long-term memory. Pass conversational text; mem0 extracts and files the durable facts itself.",
+  {
+    text: z.string().min(1).describe("The information to remember"),
+    role: z
+      .enum(["user", "assistant"])
+      .optional()
+      .describe("Who the information came from (default user)"),
+    metadata: z
+      .record(z.string(), z.string())
+      .optional()
+      .describe("Optional key/value tags stored with the memory"),
+  },
+  async ({ text, role, metadata }) => {
+    try {
+      const memories = await client.add(
+        [{ role: role ?? "user", content: text }],
+        {
+          userId,
+          ...(metadata ? { metadata } : {}),
+        },
+      );
+      return textResult({ stored: memories.length, memories });
+    } catch (err) {
+      return errorResult(err);
+    }
+  },
+);
+
+server.tool(
+  "mem0_search_memory",
+  "Semantic search over mem0 memories. Use short keyword queries, not full sentences.",
+  {
+    query: z.string().min(1).describe("Search query"),
+    limit: z
+      .number()
+      .int()
+      .min(1)
+      .max(50)
+      .optional()
+      .describe("Max results (default 10)"),
+    threshold: z
+      .number()
+      .min(0)
+      .max(1)
+      .optional()
+      .describe("Minimum relevance score, 0-1"),
+  },
+  async ({ query, limit, threshold }) => {
+    try {
+      const { results } = await client.search(query, {
+        filters: entityFilter,
+        topK: limit ?? 10,
+        ...(threshold !== undefined ? { threshold } : {}),
+      });
+      return textResult({ count: results.length, results });
+    } catch (err) {
+      return errorResult(err);
+    }
+  },
+);
+
+server.tool(
+  "mem0_list_memories",
+  "Browse stored mem0 memories with pagination. Use for inventory/cleanup, not search.",
+  {
+    page: z
+      .number()
+      .int()
+      .min(1)
+      .optional()
+      .describe("Page number (default 1)"),
+    page_size: z
+      .number()
+      .int()
+      .min(1)
+      .max(100)
+      .optional()
+      .describe("Results per page (default 25)"),
+  },
+  async ({ page, page_size }) => {
+    try {
+      const result = await client.getAll({
+        filters: entityFilter,
+        page: page ?? 1,
+        pageSize: page_size ?? 25,
+      });
+      return textResult(result);
+    } catch (err) {
+      return errorResult(err);
+    }
+  },
+);
+
+server.tool(
+  "mem0_get_memory",
+  "Fetch a single mem0 memory by id, with full content and metadata.",
+  { memory_id: z.string().min(1).describe("Memory id from search/list") },
+  async ({ memory_id }) => {
+    try {
+      return textResult(await client.get(memory_id));
+    } catch (err) {
+      return errorResult(err);
+    }
+  },
+);
+
+server.tool(
+  "mem0_delete_memory",
+  "Delete a mem0 memory by id when it is wrong or stale.",
+  { memory_id: z.string().min(1).describe("Memory id from search/list") },
+  async ({ memory_id }) => {
+    try {
+      return textResult(await client.delete(memory_id));
+    } catch (err) {
+      return errorResult(err);
+    }
+  },
+);
+
+await server.connect(new StdioServerTransport());

package/src/storage/daily-log.ts

@@ -104,6 +104,14 @@ export function getLogsDir(): string {
   return LOGS_DIR;
 }
 
+/**
+ * Today's log-file date key. Readers must use this (not the UTC date from
+ * `toISOString`) or they look for the wrong file whenever local date ≠ UTC.
+ */
+export function todayLogDate(): string {
+  return localDateKey(new Date());
+}
+
 /** Matches YYYY-MM-DD.md filenames strictly. */
 const DAILY_FILE_RE = /^\d{4}-\d{2}-\d{2}\.md$/;
 

package/src/util/config.ts

@@ -195,6 +195,32 @@ const playwrightConfigSchema = z.object({
   endpointFile: z.string().optional(),
 });
 
+/** MemPalace backend settings, shared by `memory.mempalace` and the legacy top-level `mempalace` section. */
+const mempalaceSettingsSchema = z.object({
+  /** Palace directory path (default: ~/.talon/workspace/palace/) */
+  palacePath: z.string().min(1).optional(),
+  /** Python binary path (default: ~/.talon/mempalace-venv/bin/python) */
+  pythonPath: z.string().min(1).optional(),
+  /**
+   * BCP 47 language codes for entity detection (mempalace >= 3.3).
+   * Supported: en, es, fr, de, ja, ko, zh-CN, zh-TW, pt-br, ru, it, hi, id.
+   * Sets MEMPALACE_ENTITY_LANGUAGES for the MCP server.
+   */
+  entityLanguages: z.array(z.string().min(2)).nonempty().optional(),
+  /** Enable mempalace diagnostic diaries (sets MEMPAL_VERBOSE=1). */
+  verbose: z.boolean().optional(),
+});
+
+/** mem0 backend settings, shared by `memory.mem0` and the top-level `mem0` section. */
+const mem0SettingsSchema = z.object({
+  /** Platform API key (default: MEM0_API_KEY env var). */
+  apiKey: z.string().min(1).optional(),
+  /** Self-hosted mem0 server URL; when set, apiKey may be omitted. */
+  host: z.string().min(1).optional(),
+  /** Entity id memories are filed under (default "talon"). */
+  userId: z.string().min(1).optional(),
+});
+
 /**
  * Memory pre-retrieval (Phase B) — automatic per-turn palace retrieval.
  * Ships INERT: the flag gates wiring a real retriever into the dispatcher.
@@ -383,25 +409,30 @@ const configSchema = z.object({
     })
     .optional(),
 
-  // MemPalace — structured long-term memory with vector search
-  mempalace: z
+  // Long-term memory — unified backend selection. Preferred over the
+  // legacy top-level "mempalace"/"mem0" sections; when enabled it wins
+  // over them (loadConfig mirrors it onto the section the loaders read).
+  memory: z
     .object({
       enabled: z.boolean().default(false),
-      /** Palace directory path (default: ~/.talon/workspace/palace/) */
-      palacePath: z.string().min(1).optional(),
-      /** Python binary path (default: ~/.talon/mempalace-venv/bin/python) */
-      pythonPath: z.string().min(1).optional(),
-      /**
-       * BCP 47 language codes for entity detection (mempalace >= 3.3).
-       * Supported: en, es, fr, de, ja, ko, zh-CN, zh-TW, pt-br, ru, it, hi, id.
-       * Sets MEMPALACE_ENTITY_LANGUAGES for the MCP server.
-       */
-      entityLanguages: z.array(z.string().min(2)).nonempty().optional(),
-      /** Enable mempalace diagnostic diaries (sets MEMPAL_VERBOSE=1). */
-      verbose: z.boolean().optional(),
+      backend: z.enum(["mempalace", "mem0"]).default("mempalace"),
+      mempalace: mempalaceSettingsSchema.optional(),
+      mem0: mem0SettingsSchema.optional(),
     })
     .optional(),
 
+  // MemPalace — structured long-term memory with vector search
+  // (legacy section; prefer "memory": { "backend": "mempalace", ... })
+  mempalace: mempalaceSettingsSchema
+    .extend({ enabled: z.boolean().default(false) })
+    .optional(),
+
+  // mem0 — long-term memory layer, hosted platform or self-hosted
+  // (legacy-style section; prefer "memory": { "backend": "mem0", ... })
+  mem0: mem0SettingsSchema
+    .extend({ enabled: z.boolean().default(false) })
+    .optional(),
+
   // Playwright — headless browser automation via MCP
   playwright: playwrightConfigSchema.optional(),
 
@@ -577,6 +608,25 @@ export function loadConfig(): TalonConfig {
 
   const parsed = configSchema.parse(fileConfig);
 
+  // Unified memory section: mirror the selected backend onto the per-plugin
+  // section the loaders consume (builtins.ts reads config.mempalace /
+  // config.mem0). The memory section wins over a legacy section when both
+  // are present; the unselected backend is disabled so exactly one memory
+  // plugin loads.
+  if (parsed.memory?.enabled) {
+    if (parsed.memory.backend === "mempalace") {
+      parsed.mempalace = {
+        ...parsed.mempalace,
+        ...parsed.memory.mempalace,
+        enabled: true,
+      };
+      if (parsed.mem0) parsed.mem0.enabled = false;
+    } else {
+      parsed.mem0 = { ...parsed.mem0, ...parsed.memory.mem0, enabled: true };
+      if (parsed.mempalace) parsed.mempalace.enabled = false;
+    }
+  }
+
   // Apply timezone globally before building the system prompt
   setTimezone(parsed.timezone);
 

package/src/util/log.ts

@@ -54,6 +54,7 @@ export type LogComponent =
   | "access"
   | "github"
   | "mempalace"
+  | "mem0"
   | "playwright"
   | "soul"
   | "stickers"