talon-agent 1.38.1 → 1.40.0

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.38.1",
+  "version": "1.40.0",
   "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/engine/gateway-actions/mesh.ts

@@ -46,4 +46,12 @@ export const meshHandlers: SharedActionHandlers = {
       body.local_path,
       body.remote_path,
     ),
+  // Remote self-update: push a new APK and silently (re)install it, keeping
+  // the mesh connection across the app restart.
+  update_device: (body) =>
+    getMeshService().updateDeviceApp(
+      body.device,
+      body.apk_path,
+      body.remote_path,
+    ),
 };

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/mesh/service.ts

@@ -27,7 +27,9 @@
  */
 
 import { randomUUID } from "node:crypto";
-import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { mkdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import type { Readable } from "node:stream";
@@ -758,6 +760,87 @@ export class MeshService {
     };
   }
 
+  /**
+   * `update_device`: remote self-update for the companion. Streams a new APK
+   * to the device, then tells it to silently install (via Shizuku) and
+   * restart. The mesh foreground service's autoRunOnMyPackageReplaced brings
+   * the connection back on its own — the link drops only for the seconds the
+   * process is swapped, no manual reopen.
+   *
+   * The APK is hashed here and the digest travels with the install command;
+   * the device re-hashes the pushed file and refuses to install on a
+   * mismatch, so a truncated transfer can never be installed.
+   */
+  async updateDeviceApp(
+    query: unknown,
+    localApkPath: unknown,
+    remotePath?: unknown,
+  ): Promise<MeshToolResult> {
+    const local =
+      typeof localApkPath === "string" && localApkPath.trim()
+        ? resolve(dirs.workspace, localApkPath.trim())
+        : "";
+    if (!local) return { ok: false, text: "A local APK path is required." };
+    await this.load();
+    const resolved = this.resolveDevice(query);
+    if ("error" in resolved) return { ok: false, text: resolved.error };
+    const target = resolved.target;
+    if (target.capabilities && !target.capabilities.includes("install_apk")) {
+      return {
+        ok: false,
+        text: `${target.name} can't self-update — it needs a companion build with the install_apk capability and Shizuku enabled (device control on).`,
+      };
+    }
+
+    let sha256: string;
+    let size: number;
+    try {
+      ({ sha256, size } = await hashFile(local));
+    } catch (err) {
+      return {
+        ok: false,
+        text: `Cannot read APK ${local}: ${(err as Error).message}`,
+      };
+    }
+    if (size === 0) {
+      return { ok: false, text: `APK ${local} is empty.` };
+    }
+
+    const remote =
+      typeof remotePath === "string" && remotePath.trim()
+        ? remotePath.trim()
+        : "/sdcard/Download/talon-companion-update.apk";
+
+    // 1. Stream the APK to the device.
+    const push = await this.pushFileToDevice(target.id, local, remote);
+    if (!push.ok) {
+      return { ok: false, text: `Update aborted — push failed: ${push.text}` };
+    }
+
+    // 2. Trigger the silent install (device verifies the digest first).
+    const dispatched = await this.dispatchCommand(
+      target.id,
+      "install_apk",
+      { path: remote, sha256 },
+      this.commandTimeoutMs,
+    );
+    if ("error" in dispatched) return { ok: false, text: dispatched.error };
+    if (!dispatched.result.ok) {
+      return {
+        ok: false,
+        text:
+          dispatched.result.message ?? `${target.name} refused the install.`,
+      };
+    }
+    return {
+      ok: true,
+      text:
+        `Pushed ${formatBytes(size)} and staged the update on ${target.name}. ` +
+        `${dispatched.result.message ?? "Installing now."} ` +
+        `Confirm with get_device_status once it reconnects (appVersion should change).`,
+    };
+  }
+
   /**
    * Chunked read of a remote file into a Buffer. Loops `read_file` with
    * increasing offsets until the device reports EOF.
@@ -1246,6 +1329,22 @@ function formatBytes(bytes: number): string {
   return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
 }
 
+/** Stream a file through SHA-256 without loading it into memory (APKs are big
+ *  and Buffer has a hard ceiling). Returns the hex digest and byte size. */
+async function hashFile(
+  path: string,
+): Promise<{ sha256: string; size: number }> {
+  const { size } = await stat(path);
+  const hash = createHash("sha256");
+  await new Promise<void>((resolve, reject) => {
+    createReadStream(path)
+      .on("data", (chunk) => hash.update(chunk))
+      .on("end", () => resolve())
+      .on("error", reject);
+  });
+  return { sha256: hash.digest("hex"), size };
+}
+
 // ── Process-wide instance ─────────────────────────────────────────────────────
 
 let instance: MeshService | null = null;

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/tools/mesh.ts

@@ -150,4 +150,25 @@ export const meshTools: ToolDefinition[] = [
     execute: (params, bridge) => bridge("device_push_file", params),
     tag: "mesh",
   },
+  {
+    name: "update_device",
+    description:
+      "Remotely update a Talon companion (Android): stream a new APK from the daemon to the device and silently reinstall it via Shizuku, keeping app data. The companion's mesh runs in a foreground service that auto-restarts after the package is replaced, so the connection returns on its own within seconds — no manual reopen. The APK is hashed and the device verifies it before installing (a truncated push is refused; a differently-signed APK is refused by Android). Requires the device to have device control on and Shizuku granted. Confirm success with get_device_status afterwards (appVersion should change).",
+    schema: {
+      device: deviceParam,
+      apk_path: z
+        .string()
+        .describe(
+          "Path to the new APK, relative to the workspace (or absolute).",
+        ),
+      remote_path: z
+        .string()
+        .optional()
+        .describe(
+          "Where to stage the APK on the device (default /sdcard/Download/talon-companion-update.apk).",
+        ),
+    },
+    execute: (params, bridge) => bridge("update_device", params),
+    tag: "mesh",
+  },
 ];

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"